text: "use strict";
  
  const {strict: assert} = require("assert");
  
  const {mock_cjs, mock_esm, set_global, zrequire} = require("../zjsunit/namespace");
  const {run_test} = require("../zjsunit/test");
  const blueslip = require("../zjsunit/zblueslip");
  const $ = require("../zjsunit/zjquery");
  const {page_params} = require("../zjsunit/zpage_params");
  
  mock_cjs("jquery", $);
  const window_stub = $.create("window-stub");
  set_global("to_$", () => window_stub);
  $(window).idle = () => {};
  
  let filter_key_handlers;
  
  const _document = {
      hasFocus() {
          return true;
      },
  };
  
  const compose_state = mock_esm("../../static/js/compose_state");
  const channel = mock_esm("../../static/js/channel");
  
  mock_esm("../../static/js/padded_widget", {
      update_padding: () => {},
  });
  mock_esm("../../static/js/keydown_util", {
      handle: (opts) => {
          filter_key_handlers = opts.handlers;
      },
  });
  mock_esm("../../static/js/pm_list", {
      update_private_messages: () => {},
  });
  mock_esm("../../static/js/popovers", {
      hide_all_except_sidebars() {},
      hide_all() {},
      show_userlist_sidebar() {},
  });
  mock_esm("../../static/js/resize", {
      resize_sidebars: () => {},
      resize_page_components: () => {},
  });
  mock_esm("../../static/js/scroll_util", {
      scroll_element_into_container: () => {},
  });
  mock_esm("../../static/js/stream_popover", {
      show_streamlist_sidebar() {},
  });
  mock_esm("../../static/js/watchdog", {
      check_for_unsuspend() {},
  });
  set_global("document", _document);
  
  const huddle_data = zrequire("huddle_data");
  const compose_fade = zrequire("compose_fade");
  const narrow = zrequire("narrow");
  const presence = zrequire("presence");
  const people = zrequire("people");
  const buddy_data = zrequire("buddy_data");
  const {buddy_list} = zrequire("buddy_list");
  const user_status = zrequire("user_status");
  const activity = zrequire("activity");
  
  const me = {
      email: "me@zulip.com",
      user_id: 999,
      full_name: "Me Myself",
  };
  
  const alice = {
      email: "alice@zulip.com",
      user_id: 1,
      full_name: "Alice Smith",
  };
  const fred = {
      email: "fred@zulip.com",
      user_id: 2,
      full_name: "Fred Flintstone",
  };
  const jill = {
      email: "jill@zulip.com",
      user_id: 3,
      full_name: "Jill Hill",
  };
  const mark = {
      email: "mark@zulip.com",
      user_id: 4,
      full_name: "Marky Mark",
  };
  const norbert = {
      email: "norbert@zulip.com",
      user_id: 5,
      full_name: "Norbert Oswald",
  };
  
  const zoe = {
      email: "zoe@example.com",
      user_id: 6,
      full_name: "Zoe Yang",
  };
  
  people.add_active_user(alice);
  people.add_active_user(fred);
  people.add_active_user(jill);
  people.add_active_user(mark);
  people.add_active_user(norbert);
  people.add_active_user(zoe);
  people.add_active_user(me);
  people.initialize_current_user(me.user_id);
  
  const presence_info = new Map();
  presence_info.set(alice.user_id, {status: "inactive"});
  presence_info.set(fred.user_id, {status: "active"});
  presence_info.set(jill.user_id, {status: "active"});
  
  presence.__Rewire__("presence_info", presence_info);
  
  // Simulate a small window by having the
  // fill_screen_with_content render the entire
  // list in one pass.  We will do more refined
  // testing in the buddy_list node tests.
  buddy_list.fill_screen_with_content = () => {
      buddy_list.render_more({
          chunk_size: 100,
      });
  };
  
  run_test("reload_defaults", () => {
      blueslip.expect("warn", "get_filter_text() is called before initialization");
      assert.equal(activity.get_filter_text(), "");
  });
  
  run_test("get_status", () => {
      page_params.realm_users = [];
      page_params.user_id = 999;
  
      assert.equal(presence.get_status(page_params.user_id), "active");
      assert.equal(presence.get_status(alice.user_id), "inactive");
      assert.equal(presence.get_status(fred.user_id), "active");
      assert.equal(presence.get_status(zoe.user_id), "offline");
  });
  
  run_test("sort_users", () => {
      const user_ids = [alice.user_id, fred.user_id, jill.user_id];
  
      buddy_data.sort_users(user_ids);
  
      assert.deepEqual(user_ids, [fred.user_id, jill.user_id, alice.user_id]);
  });
  
  run_test("huddle_data.process_loaded_messages", () => {
      // TODO: move this to a module for just testing `huddle_data`
  
      const huddle1 = "jill@zulip.com,norbert@zulip.com";
      const timestamp1 = 1382479029; // older
  
      const huddle2 = "alice@zulip.com,fred@zulip.com";
      const timestamp2 = 1382479033; // newer
  
      const old_timestamp = 1382479000;
  
      const messages = [
          {
              type: "private",
              display_recipient: [{id: jill.user_id}, {id: norbert.user_id}],
              timestamp: timestamp1,
          },
          {
              type: "stream",
          },
          {
              type: "private",
              display_recipient: [{id: me.user_id}], // PM to myself
          },
          {
              type: "private",
              display_recipient: [{id: alice.user_id}, {id: fred.user_id}],
              timestamp: timestamp2,
          },
          {
              type: "private",
              display_recipient: [{id: fred.user_id}, {id: alice.user_id}],
              timestamp: old_timestamp,
          },
      ];
  
      huddle_data.process_loaded_messages(messages);
  
      const user_ids_string1 = people.emails_strings_to_user_ids_string(huddle1);
      const user_ids_string2 = people.emails_strings_to_user_ids_string(huddle2);
      assert.deepEqual(huddle_data.get_huddles(), [user_ids_string2, user_ids_string1]);
  });
  
  presence.__Rewire__("presence_info", new Map());
  presence.presence_info.set(alice.user_id, {status: activity.IDLE});
  presence.presence_info.set(fred.user_id, {status: activity.ACTIVE});
  presence.presence_info.set(jill.user_id, {status: activity.ACTIVE});
  presence.presence_info.set(mark.user_id, {status: activity.IDLE});
  presence.presence_info.set(norbert.user_id, {status: activity.ACTIVE});
  presence.presence_info.set(zoe.user_id, {status: activity.ACTIVE});
  presence.presence_info.set(me.user_id, {status: activity.ACTIVE});
  
  function clear_buddy_list() {
      buddy_list.populate({
          keys: [],
      });
  }
  
  function test_ui(label, f) {
      run_test(label, (override) => {
          clear_buddy_list();
          f(override);
      });
  }
  
  test_ui("presence_list_full_update", () => {
      activity.set_cursor_and_filter();
  
      $(".user-list-filter").trigger("focus");
      compose_state.private_message_recipient = () => fred.email;
      compose_fade.set_focused_recipient("private");
  
      const user_ids = activity.build_user_sidebar();
  
      assert.deepEqual(user_ids, [
          me.user_id,
          fred.user_id,
          jill.user_id,
          norbert.user_id,
          zoe.user_id,
          alice.user_id,
          mark.user_id,
      ]);
  });
  
  function simulate_right_column_buddy_list() {
      $(".user-list-filter").closest = (selector) => {
          assert.equal(selector, ".app-main [class^='column-']");
          return $.create("right-sidebar").addClass("column-right");
      };
  }
  
  function simulate_left_column_buddy_list() {
      $(".user-list-filter").closest = (selector) => {
          assert.equal(selector, ".app-main [class^='column-']");
          return $.create("left-sidebar").addClass("column-left");
      };
  }
  
  function buddy_list_add(user_id, stub) {
      if (stub.attr) {
          stub.attr("data-user-id", user_id);
      }
      stub.length = 1;
      const sel = `li.user_sidebar_entry[data-user-id='${CSS.escape(user_id)}']`;
      $("#user_presences").set_find_results(sel, stub);
  }
  
  test_ui("PM_update_dom_counts", () => {
      const value = $.create("alice-value");
      const count = $.create("alice-count");
      const pm_key = alice.user_id.toString();
      const li = $.create("alice stub");
      buddy_list_add(pm_key, li);
      count.set_find_results(".value", value);
      li.set_find_results(".count", count);
      count.set_parents_result("li", li);
  
      const counts = new Map();
      counts.set(pm_key, 5);
      li.addClass("user_sidebar_entry");
  
      activity.update_dom_with_unread_counts({pm_count: counts});
      assert(li.hasClass("user-with-count"));
      assert.equal(value.text(), "5");
  
      counts.set(pm_key, 0);
  
      activity.update_dom_with_unread_counts({pm_count: counts});
      assert(!li.hasClass("user-with-count"));
      assert.equal(value.text(), "");
  });
  
  test_ui("handlers", (override) => {
      // This is kind of weak coverage; we are mostly making sure that
      // keys and clicks got mapped to functions that don't crash.
      let me_li;
      let alice_li;
      let fred_li;
  
      let narrowed;
  
      override(narrow, "by", (method, email) => {
          assert.equal(email, "alice@zulip.com");
          narrowed = true;
      });
  
      function init() {
          $.clear_all_elements();
          buddy_list.populate({
              keys: [me.user_id, alice.user_id, fred.user_id],
          });
          activity.set_cursor_and_filter();
  
          me_li = $.create("me stub");
          alice_li = $.create("alice stub");
          fred_li = $.create("fred stub");
  
          buddy_list_add(me.user_id, me_li);
          buddy_list_add(alice.user_id, alice_li);
          buddy_list_add(fred.user_id, fred_li);
      }
  
      (function test_filter_keys() {
          init();
          activity.user_cursor.go_to(alice.user_id);
          filter_key_handlers.down_arrow();
          filter_key_handlers.up_arrow();
      })();
  
      (function test_click_filter() {
          init();
          const e = {
              stopPropagation: () => {},
          };
  
          const handler = $(".user-list-filter").get_on_handler("focus");
          handler(e);
      })();
  
      (function test_click_header_filter() {
          init();
          const e = {};
          const handler = $("#userlist-header").get_on_handler("click");
  
          simulate_right_column_buddy_list();
  
          handler(e);
          // and click again
          handler(e);
      })();
  
      (function test_enter_key() {
          init();
  
          $(".user-list-filter").val("al");
          narrowed = false;
          activity.user_cursor.go_to(alice.user_id);
          filter_key_handlers.enter_key();
          assert(narrowed);
  
          // get line coverage for cleared case
          activity.user_cursor.clear();
          filter_key_handlers.enter_key();
      })();
  
      (function test_click_handler() {
          init();
          // We wire up the click handler in click_handlers.js,
          // so this just tests the called function.
          narrowed = false;
          activity.narrow_for_user({li: alice_li});
          assert(narrowed);
      })();
  
      (function test_blur_filter() {
          init();
          const e = {};
          const handler = $(".user-list-filter").get_on_handler("blur");
          handler(e);
      })();
  });
  
  presence.__Rewire__("presence_info", new Map());
  presence.presence_info.set(alice.user_id, {status: activity.ACTIVE});
  presence.presence_info.set(fred.user_id, {status: activity.ACTIVE});
  presence.presence_info.set(jill.user_id, {status: activity.ACTIVE});
  presence.presence_info.set(mark.user_id, {status: activity.IDLE});
  presence.presence_info.set(norbert.user_id, {status: activity.ACTIVE});
  presence.presence_info.set(zoe.user_id, {status: activity.ACTIVE});
  
  test_ui("first/prev/next", () => {
      clear_buddy_list();
  
      assert.equal(buddy_list.first_key(), undefined);
      assert.equal(buddy_list.prev_key(alice.user_id), undefined);
      assert.equal(buddy_list.next_key(alice.user_id), undefined);
  
      buddy_list.container.append = () => {};
  
      activity.redraw_user(alice.user_id);
      activity.redraw_user(fred.user_id);
  
      assert.equal(buddy_list.first_key(), alice.user_id);
      assert.equal(buddy_list.prev_key(alice.user_id), undefined);
      assert.equal(buddy_list.prev_key(fred.user_id), alice.user_id);
  
      assert.equal(buddy_list.next_key(alice.user_id), fred.user_id);
      assert.equal(buddy_list.next_key(fred.user_id), undefined);
  });
  
  test_ui("filter_user_ids", () => {
      const user_filter = $(".user-list-filter");
      user_filter.val(""); // no search filter
      activity.set_cursor_and_filter();
  
      function get_user_ids() {
          const filter_text = activity.get_filter_text();
          const user_ids = buddy_data.get_filtered_and_sorted_user_ids(filter_text);
          return user_ids;
      }
  
      let user_ids = buddy_data.get_filtered_and_sorted_user_ids();
      assert.deepEqual(user_ids, [
          alice.user_id,
          fred.user_id,
          jill.user_id,
          norbert.user_id,
          zoe.user_id,
          mark.user_id,
      ]);
  
      user_filter.val("abc"); // no match
      user_ids = get_user_ids();
      assert.deepEqual(user_ids, []);
  
      user_filter.val("fred"); // match fred
      user_ids = get_user_ids();
      assert.deepEqual(user_ids, [fred.user_id]);
  
      user_filter.val("fred,alice"); // match fred and alice
      user_ids = get_user_ids();
      assert.deepEqual(user_ids, [alice.user_id, fred.user_id]);
  
      user_filter.val("fr,al"); // match fred and alice partials
      user_ids = get_user_ids();
      assert.deepEqual(user_ids, [alice.user_id, fred.user_id]);
  
      user_filter.val("fr|al"); // test | as OR-operator
      user_ids = get_user_ids();
      assert.deepEqual(user_ids, [alice.user_id, fred.user_id]);
  
      presence.presence_info.set(alice.user_id, {status: activity.IDLE});
      user_filter.val("fr,al"); // match fred and alice partials and idle user
      user_ids = get_user_ids();
      assert.deepEqual(user_ids, [fred.user_id, alice.user_id]);
  
      presence.presence_info.set(alice.user_id, {status: activity.ACTIVE});
      user_ids = get_user_ids();
      assert.deepEqual(user_ids, [alice.user_id, fred.user_id]);
  });
  
  test_ui("insert_one_user_into_empty_list", (override) => {
      let appended_html;
      override(buddy_list.container, "append", (html) => {
          appended_html = html;
      });
  
      activity.redraw_user(alice.user_id);
      assert(appended_html.indexOf('data-user-id="1"') > 0);
      assert(appended_html.indexOf("user_circle_green") > 0);
  });
  
  test_ui("insert_alice_then_fred", (override) => {
      let appended_html;
      override(buddy_list.container, "append", (html) => {
          appended_html = html;
      });
  
      activity.redraw_user(alice.user_id);
      assert(appended_html.indexOf('data-user-id="1"') > 0);
      assert(appended_html.indexOf("user_circle_green") > 0);
  
      activity.redraw_user(fred.user_id);
      assert(appended_html.indexOf('data-user-id="2"') > 0);
      assert(appended_html.indexOf("user_circle_green") > 0);
  });
  
  test_ui("insert_fred_then_alice_then_rename", (override) => {
      let appended_html;
      override(buddy_list.container, "append", (html) => {
          appended_html = html;
      });
  
      activity.redraw_user(fred.user_id);
      assert(appended_html.indexOf('data-user-id="2"') > 0);
      assert(appended_html.indexOf("user_circle_green") > 0);
  
      const fred_stub = $.create("fred-first");
      buddy_list_add(fred.user_id, fred_stub);
  
      let inserted_html;
      fred_stub.before = (html) => {
          inserted_html = html;
      };
  
      let fred_removed;
      fred_stub.remove = () => {
          fred_removed = true;
      };
  
      activity.redraw_user(alice.user_id);
      assert(inserted_html.indexOf('data-user-id="1"') > 0);
      assert(inserted_html.indexOf("user_circle_green") > 0);
  
      // Next rename fred to Aaron.
      const fred_with_new_name = {
          email: fred.email,
          user_id: fred.user_id,
          full_name: "Aaron",
      };
      people.add_active_user(fred_with_new_name);
  
      const alice_stub = $.create("alice-first");
      buddy_list_add(alice.user_id, alice_stub);
  
      alice_stub.before = (html) => {
          inserted_html = html;
      };
  
      activity.redraw_user(fred_with_new_name.user_id);
      assert(fred_removed);
      assert(appended_html.indexOf('data-user-id="2"') > 0);
  
      // restore old Fred data
      people.add_active_user(fred);
  });
  
  test_ui("insert_unfiltered_user_with_filter", () => {
      // This test only tests that we do not explode when
      // try to insert Fred into a list where he does not
      // match the search filter.
      activity.set_cursor_and_filter();
  
      const user_filter = $(".user-list-filter");
      user_filter.val("do-not-match-filter");
      activity.redraw_user(fred.user_id);
  });
  
  test_ui("realm_presence_disabled", () => {
      page_params.realm_presence_disabled = true;
  
      activity.redraw_user();
      activity.build_user_sidebar();
  });
  
  test_ui("clear_search", () => {
      activity.set_cursor_and_filter();
  
      $(".user-list-filter").val("somevalue");
      $("#clear_search_people_button").trigger("click");
      assert.equal($(".user-list-filter").val(), "");
      $("#clear_search_people_button").trigger("click");
      assert($("#user_search_section").hasClass("notdisplayed"));
  });
  
  test_ui("escape_search", () => {
      page_params.realm_presence_disabled = true;
  
      activity.set_cursor_and_filter();
  
      $(".user-list-filter").val("somevalue");
      activity.escape_search();
      assert.equal($(".user-list-filter").val(), "");
      activity.escape_search();
      assert($("#user_search_section").hasClass("notdisplayed"));
  });
  
  test_ui("initiate_search", () => {
      activity.set_cursor_and_filter();
  
      $(".user-list-filter").trigger("blur");
      simulate_right_column_buddy_list();
      activity.initiate_search();
      assert.equal($(".user-list-filter").is_focused(), true);
  
      simulate_left_column_buddy_list();
      activity.initiate_search();
      assert.equal($(".user-list-filter").is_focused(), true);
  });
  
  test_ui("toggle_filter_display", () => {
      page_params.realm_presence_disabled = true;
  
      activity.set_cursor_and_filter();
  
      activity.user_filter.toggle_filter_displayed();
      assert($("#user_search_section").hasClass("notdisplayed"));
      $(".user-list-filter").closest = (selector) => {
          assert.equal(selector, ".app-main [class^='column-']");
          return $.create("sidebar").addClass("column-right");
      };
      activity.user_filter.toggle_filter_displayed();
      assert.equal($("#user_search_section").hasClass("notdisplayed"), false);
  });
  
  test_ui("searching", () => {
      activity.set_cursor_and_filter();
  
      $(".user-list-filter").trigger("focus");
      assert.equal(activity.searching(), true);
      $(".user-list-filter").trigger("blur");
      assert.equal(activity.searching(), false);
  });
  
  test_ui("update_presence_info", (override) => {
      page_params.realm_presence_disabled = false;
  
      const server_time = 500;
      const info = {
          website: {
              status: "active",
              timestamp: server_time,
          },
      };
  
      override(buddy_data, "matches_filter", () => true);
  
      const alice_li = $.create("alice stub");
      buddy_list_add(alice.user_id, alice_li);
  
      let inserted;
      buddy_list.insert_or_move = () => {
          inserted = true;
      };
  
      presence.presence_info.delete(me.user_id);
      activity.update_presence_info(me.user_id, info, server_time);
      assert(inserted);
      assert.deepEqual(presence.presence_info.get(me.user_id).status, "active");
  
      presence.presence_info.delete(alice.user_id);
      activity.update_presence_info(alice.user_id, info, server_time);
      assert(inserted);
  
      const expected = {status: "active", last_active: 500};
      assert.deepEqual(presence.presence_info.get(alice.user_id), expected);
  });
  
  test_ui("initialize", (override) => {
      let payload;
      override(channel, "post", (arg) => {
          payload = arg;
      });
  
      function clear() {
          $.clear_all_elements();
          buddy_list.container = $("#user_presences");
          buddy_list.container.append = () => {};
          clear_buddy_list();
          page_params.presences = {};
      }
  
      clear();
  
      let scroll_handler_started;
      buddy_list.start_scroll_handler = () => {
          scroll_handler_started = true;
      };
  
      activity.__Rewire__("client_is_active", false);
  
      $(window).off("focus");
      activity.initialize();
      payload.success({});
      $(window).trigger("focus");
      clear();
  
      assert(scroll_handler_started);
      assert(!activity.new_user_input);
      assert(!$("#zephyr-mirror-error").hasClass("show"));
      assert(activity.client_is_active);
      $(window).idle = (params) => {
          params.onIdle();
      };
  
      set_global("setInterval", (func) => func());
  
      $(window).off("focus");
      activity.initialize();
      payload.success({
          zephyr_mirror_active: false,
          presences: {},
      });
  
      assert($("#zephyr-mirror-error").hasClass("show"));
      assert(!activity.new_user_input);
      assert(!activity.client_is_active);
  
      // Exercise the mousemove handler, which just
      // sets a flag.
      $("html").get_on_handler("mousemove")();
  
      clear();
  });
  
  run_test("away_status", () => {
      assert(!user_status.is_away(alice.user_id));
      activity.on_set_away(alice.user_id);
      assert(user_status.is_away(alice.user_id));
      activity.on_revoke_away(alice.user_id);
      assert(!user_status.is_away(alice.user_id));
  });
  
  test_ui("electron_bridge", () => {
      activity.__Rewire__("client_is_active", false);
      window.electron_bridge = undefined;
      assert.equal(activity.compute_active_status(), activity.IDLE);
  
      activity.__Rewire__("client_is_active", true);
      assert.equal(activity.compute_active_status(), activity.ACTIVE);
  
      window.electron_bridge = {
          get_idle_on_system: () => true,
      };
      assert.equal(activity.compute_active_status(), activity.IDLE);
      activity.__Rewire__("client_is_active", false);
      assert.equal(activity.compute_active_status(), activity.IDLE);
  
      window.electron_bridge = {
          get_idle_on_system: () => false,
      };
      assert.equal(activity.compute_active_status(), activity.ACTIVE);
      activity.__Rewire__("client_is_active", true);
      assert.equal(activity.compute_active_status(), activity.ACTIVE);
  });
  
  test_ui("test_send_or_receive_no_presence_for_web_public_visitor", () => {
      page_params.is_web_public_visitor = true;
      activity.send_presence_to_server();
  });
  