/* Any copyright is dedicated to the Public Domain.
 * http://creativecommons.org/publicdomain/zero/1.0/ */

"use strict";

var gTestTab;
var gContentAPI;

ChromeUtils.defineESModuleGetters(this, {
  ProfileAge: "resource://gre/modules/ProfileAge.sys.mjs",
  TelemetryArchiveTesting:
    "resource://testing-common/TelemetryArchiveTesting.sys.mjs",
  TelemetryTestUtils: "resource://testing-common/TelemetryTestUtils.sys.mjs",
  UpdateUtils: "resource://gre/modules/UpdateUtils.sys.mjs",
});

function test() {
  UITourTest();
}

var tests = [
  function test_untrusted_host(done) {
    loadUITourTestPage(function() {
      CustomizableUI.addWidgetToArea(
        "bookmarks-menu-button",
        CustomizableUI.AREA_NAVBAR,
        0
      );
      registerCleanupFunction(() =>
        CustomizableUI.removeWidgetFromArea("bookmarks-menu-button")
      );
      let bookmarksMenu = document.getElementById("bookmarks-menu-button");
      is(bookmarksMenu.open, false, "Bookmark menu should initially be closed");

      gContentAPI.showMenu("bookmarks");
      is(
        bookmarksMenu.open,
        false,
        "Bookmark menu should not open on a untrusted host"
      );

      done();
    }, "http://mochi.test:8888/");
  },
  function test_testing_host(done) {
    // Add two testing origins intentionally surrounded by whitespace to be ignored.
    Services.prefs.setCharPref(
      "browser.uitour.testingOrigins",
      "https://test1.example.org, https://test2.example.org:443 "
    );

    registerCleanupFunction(() => {
      Services.prefs.clearUserPref("browser.uitour.testingOrigins");
    });
    function callback(result) {
      ok(result, "Callback should be called on a testing origin");
      done();
    }

    loadUITourTestPage(function() {
      gContentAPI.getConfiguration("appinfo", callback);
    }, "https://test2.example.org/");
  },
  function test_unsecure_host(done) {
    loadUITourTestPage(function() {
      let bookmarksMenu = document.getElementById("bookmarks-menu-button");
      is(bookmarksMenu.open, false, "Bookmark menu should initially be closed");

      gContentAPI.showMenu("bookmarks");
      is(
        bookmarksMenu.open,
        false,
        "Bookmark menu should not open on a unsecure host"
      );

      done();
    }, "http://example.org/");
  },
  function test_unsecure_host_override(done) {
    Services.prefs.setBoolPref("browser.uitour.requireSecure", false);
    loadUITourTestPage(function() {
      let highlight = document.getElementById("UITourHighlight");
      is_element_hidden(highlight, "Highlight should initially be hidden");

      gContentAPI.showHighlight("urlbar").then(() => {
        waitForElementToBeVisible(
          highlight,
          done,
          "Highlight should be shown on a unsecure host when override pref is set"
        );

        Services.prefs.setBoolPref("browser.uitour.requireSecure", true);
      });
    }, "http://example.org/");
  },
  function test_disabled(done) {
    Services.prefs.setBoolPref("browser.uitour.enabled", false);

    let bookmarksMenu = document.getElementById("bookmarks-menu-button");
    is(bookmarksMenu.open, false, "Bookmark menu should initially be closed");

    gContentAPI.showMenu("bookmarks").then(() => {
      is(
        bookmarksMenu.open,
        false,
        "Bookmark menu should not open when feature is disabled"
      );

      Services.prefs.setBoolPref("browser.uitour.enabled", true);
    });
    done();
  },
  function test_highlight(done) {
    function test_highlight_2() {
      let highlight = document.getElementById("UITourHighlight");
      gContentAPI.hideHighlight();

      waitForElementToBeHidden(
        highlight,
        test_highlight_3,
        "Highlight should be hidden after hideHighlight()"
      );
    }
    function test_highlight_3() {
      is_element_hidden(
        highlight,
        "Highlight should be hidden after hideHighlight()"
      );

      gContentAPI.showHighlight("urlbar");
      waitForElementToBeVisible(
        highlight,
        test_highlight_4,
        "Highlight should be shown after showHighlight()"
      );
    }
    function test_highlight_4() {
      let highlight = document.getElementById("UITourHighlight");
      gContentAPI.showHighlight("backForward");
      waitForElementToBeVisible(
        highlight,
        done,
        "Highlight should be shown after showHighlight()"
      );
    }

    let highlight = document.getElementById("UITourHighlight");
    is_element_hidden(highlight, "Highlight should initially be hidden");

    gContentAPI.showHighlight("urlbar");
    waitForElementToBeVisible(
      highlight,
      test_highlight_2,
      "Highlight should be shown after showHighlight()"
    );
  },
  function test_highlight_toolbar_button(done) {
    function check_highlight_size() {
      let panel = highlight.parentElement;
      let anchor = panel.anchorNode;
      let anchorRect = anchor.getBoundingClientRect();
      info(
        "addons target: width: " +
          anchorRect.width +
          " height: " +
          anchorRect.height
      );
      let dimension = anchorRect.width;
      let highlightRect = highlight.getBoundingClientRect();
      info(
        "highlight: width: " +
          highlightRect.width +
          " height: " +
          highlightRect.height
      );
      is(
        Math.round(highlightRect.width),
        dimension,
        "The width of the highlight should be equal to the width of the target"
      );
      is(
        Math.round(highlightRect.height),
        dimension,
        "The height of the highlight should be equal to the width of the target"
      );
      is(
        highlight.classList.contains("rounded-highlight"),
        true,
        "Highlight should be rounded-rectangle styled"
      );
      CustomizableUI.removeWidgetFromArea("home-button");
      done();
    }
    info("Adding home button.");
    CustomizableUI.addWidgetToArea("home-button", "nav-bar");
    // Force the button to get layout so we can show the highlight.
    document.getElementById("home-button").clientHeight;
    let highlight = document.getElementById("UITourHighlight");
    is_element_hidden(highlight, "Highlight should initially be hidden");

    gContentAPI.showHighlight("home");
    waitForElementToBeVisible(
      highlight,
      check_highlight_size,
      "Highlight should be shown after showHighlight()"
    );
  },
  function test_highlight_addons_auto_open_close(done) {
    let highlight = document.getElementById("UITourHighlight");
    gContentAPI.showHighlight("addons");
    waitForElementToBeVisible(
      highlight,
      function checkPanelIsOpen() {
        isnot(PanelUI.panel.state, "closed", "Panel should have opened");
        isnot(
          highlight.classList.contains("rounded-highlight"),
          true,
          "Highlight should not be round-rectangle styled."
        );

        let hiddenPromise = promisePanelElementHidden(window, PanelUI.panel);
        // Move the highlight outside which should close the app menu.
        gContentAPI.showHighlight("appMenu");
        hiddenPromise.then(() => {
          waitForElementToBeVisible(
            highlight,
            function checkPanelIsClosed() {
              isnot(
                PanelUI.panel.state,
                "open",
                "Panel should have closed after the highlight moved elsewhere."
              );
              done();
            },
            "Highlight should move to the appMenu button"
          );
        });
      },
      "Highlight should be shown after showHighlight() for fixed panel items"
    );
  },
  function test_highlight_addons_manual_open_close(done) {
    let highlight = document.getElementById("UITourHighlight");
    // Manually open the app menu then show a highlight there. The menu should remain open.
    let shownPromise = promisePanelShown(window);
    gContentAPI.showMenu("appMenu");
    shownPromise
      .then(() => {
        isnot(PanelUI.panel.state, "closed", "Panel should have opened");
        gContentAPI.showHighlight("addons");

        waitForElementToBeVisible(
          highlight,
          function checkPanelIsStillOpen() {
            isnot(PanelUI.panel.state, "closed", "Panel should still be open");

            // Move the highlight outside which shouldn't close the app menu since it was manually opened.
            gContentAPI.showHighlight("appMenu");
            waitForElementToBeVisible(
              highlight,
              function() {
                isnot(
                  PanelUI.panel.state,
                  "closed",
                  "Panel should remain open since UITour didn't open it in the first place"
                );
                gContentAPI.hideMenu("appMenu");
                done();
              },
              "Highlight should move to the appMenu button"
            );
          },
          "Highlight should be shown after showHighlight() for fixed panel items"
        );
      })
      .catch(Cu.reportError);
  },
  function test_highlight_effect(done) {
    function waitForHighlightWithEffect(highlightEl, effect, next, error) {
      return waitForCondition(
        () => highlightEl.getAttribute("active") == effect,
        next,
        error
      );
    }
    function checkDefaultEffect() {
      is(
        highlight.getAttribute("active"),
        "none",
        "The default should be no effect"
      );

      gContentAPI.showHighlight("urlbar", "none");
      waitForHighlightWithEffect(
        highlight,
        "none",
        checkZoomEffect,
        "There should be no effect"
      );
    }
    function checkZoomEffect() {
      gContentAPI.showHighlight("urlbar", "zoom");
      waitForHighlightWithEffect(
        highlight,
        "zoom",
        () => {
          let style = window.getComputedStyle(highlight);
          is(
            style.animationName,
            "uitour-zoom",
            "The animation-name should be uitour-zoom"
          );
          checkSameEffectOnDifferentTarget();
        },
        "There should be a zoom effect"
      );
    }
    function checkSameEffectOnDifferentTarget() {
      gContentAPI.showHighlight("appMenu", "wobble");
      waitForHighlightWithEffect(
        highlight,
        "wobble",
        () => {
          highlight.addEventListener(
            "animationstart",
            function(aEvent) {
              ok(
                true,
                "Animation occurred again even though the effect was the same"
              );
              checkRandomEffect();
            },
            { once: true }
          );
          gContentAPI.showHighlight("backForward", "wobble");
        },
        "There should be a wobble effect"
      );
    }
    function checkRandomEffect() {
      function waitForActiveHighlight(highlightEl, next, error) {
        return waitForCondition(
          () => highlightEl.hasAttribute("active"),
          next,
          error
        );
      }

      gContentAPI.hideHighlight();
      gContentAPI.showHighlight("urlbar", "random");
      waitForActiveHighlight(
        highlight,
        () => {
          ok(
            highlight.hasAttribute("active"),
            "The highlight should be active"
          );
          isnot(
            highlight.getAttribute("active"),
            "none",
            "A random effect other than none should have been chosen"
          );
          isnot(
            highlight.getAttribute("active"),
            "random",
            "The random effect shouldn't be 'random'"
          );
          isnot(
            UITour.highlightEffects.indexOf(highlight.getAttribute("active")),
            -1,
            "Check that a supported effect was randomly chosen"
          );
          done();
        },
        "There should be an active highlight with a random effect"
      );
    }

    let highlight = document.getElementById("UITourHighlight");
    is_element_hidden(highlight, "Highlight should initially be hidden");

    gContentAPI.showHighlight("urlbar");
    waitForElementToBeVisible(
      highlight,
      checkDefaultEffect,
      "Highlight should be shown after showHighlight()"
    );
  },
  function test_highlight_effect_unsupported(done) {
    function checkUnsupportedEffect() {
      is(
        highlight.getAttribute("active"),
        "none",
        "No effect should be used when an unsupported effect is requested"
      );
      done();
    }

    let highlight = document.getElementById("UITourHighlight");
    is_element_hidden(highlight, "Highlight should initially be hidden");

    gContentAPI.showHighlight("urlbar", "__UNSUPPORTED__");
    waitForElementToBeVisible(
      highlight,
      checkUnsupportedEffect,
      "Highlight should be shown after showHighlight()"
    );
  },
  function test_info_1(done) {
    let popup = document.getElementById("UITourTooltip");
    let title = document.getElementById("UITourTooltipTitle");
    let desc = document.getElementById("UITourTooltipDescription");
    let icon = document.getElementById("UITourTooltipIcon");
    let buttons = document.getElementById("UITourTooltipButtons");

    popup.addEventListener(
      "popupshown",
      function() {
        is(
          popup.anchorNode,
          document.getElementById("urlbar"),
          "Popup should be anchored to the urlbar"
        );
        is(title.textContent, "test title", "Popup should have correct title");
        is(
          desc.textContent,
          "test text",
          "Popup should have correct description text"
        );
        is(icon.src, "", "Popup should have no icon");
        is(buttons.hasChildNodes(), false, "Popup should have no buttons");

        popup.addEventListener(
          "popuphidden",
          function() {
            popup.addEventListener(
              "popupshown",
              function() {
                done();
              },
              { once: true }
            );

            gContentAPI.showInfo("urlbar", "test title", "test text");
          },
          { once: true }
        );
        gContentAPI.hideInfo();
      },
      { once: true }
    );

    gContentAPI.showInfo("urlbar", "test title", "test text");
  },
  taskify(async function test_info_2() {
    let popup = document.getElementById("UITourTooltip");
    let title = document.getElementById("UITourTooltipTitle");
    let desc = document.getElementById("UITourTooltipDescription");
    let icon = document.getElementById("UITourTooltipIcon");
    let buttons = document.getElementById("UITourTooltipButtons");

    await showInfoPromise("urlbar", "urlbar title", "urlbar text");

    is(
      popup.anchorNode,
      document.getElementById("urlbar"),
      "Popup should be anchored to the urlbar"
    );
    is(title.textContent, "urlbar title", "Popup should have correct title");
    is(
      desc.textContent,
      "urlbar text",
      "Popup should have correct description text"
    );
    is(icon.src, "", "Popup should have no icon");
    is(buttons.hasChildNodes(), false, "Popup should have no buttons");

    // Place the search bar in the navigation toolbar temporarily.
    await SpecialPowers.pushPrefEnv({
      set: [["browser.search.widget.inNavBar", true]],
    });

    await showInfoPromise("search", "search title", "search text");

    is(
      popup.anchorNode,
      document.getElementById("searchbar"),
      "Popup should be anchored to the searchbar"
    );
    is(title.textContent, "search title", "Popup should have correct title");
    is(
      desc.textContent,
      "search text",
      "Popup should have correct description text"
    );

    await SpecialPowers.popPrefEnv();
  }),
  function test_getConfigurationVersion(done) {
    function callback(result) {
      ok(
        typeof result.version !== "undefined",
        "Check version isn't undefined."
      );
      is(
        result.version,
        Services.appinfo.version,
        "Should have the same version property."
      );
      is(
        result.defaultUpdateChannel,
        UpdateUtils.getUpdateChannel(false),
        "Should have the correct update channel."
      );
      done();
    }

    gContentAPI.getConfiguration("appinfo", callback);
  },
  function test_getConfigurationDistribution(done) {
    gContentAPI.getConfiguration("appinfo", result => {
      ok(
        typeof result.distribution !== "undefined",
        "Check distribution isn't undefined."
      );
      // distribution id defaults to "default" for most builds, and
      // "mozilla-MSIX" for MSIX builds.
      is(
        result.distribution,
        AppConstants.platform === "win" &&
          Services.sysinfo.getProperty("hasWinPackageId")
          ? "mozilla-MSIX"
          : "default",
        'Should be "default" without preference set.'
      );

      let defaults = Services.prefs.getDefaultBranch("distribution.");
      let testDistributionID = "TestDistribution";
      defaults.setCharPref("id", testDistributionID);
      gContentAPI.getConfiguration("appinfo", result2 => {
        ok(
          typeof result2.distribution !== "undefined",
          "Check distribution isn't undefined."
        );
        is(
          result2.distribution,
          testDistributionID,
          "Should have the distribution as set in preference."
        );

        done();
      });
    });
  },
  function test_getConfigurationProfileAge(done) {
    gContentAPI.getConfiguration("appinfo", result => {
      ok(
        typeof result.profileCreatedWeeksAgo === "number",
        "profileCreatedWeeksAgo should be number."
      );
      ok(
        result.profileResetWeeksAgo === null,
        "profileResetWeeksAgo should be null."
      );

      // Set profile reset date to 15 days ago.
      ProfileAge().then(profileAccessor => {
        profileAccessor.recordProfileReset(
          Date.now() - 15 * 24 * 60 * 60 * 1000
        );
        gContentAPI.getConfiguration("appinfo", result2 => {
          ok(
            typeof result2.profileResetWeeksAgo === "number",
            "profileResetWeeksAgo should be number."
          );
          is(
            result2.profileResetWeeksAgo,
            2,
            "profileResetWeeksAgo should be 2."
          );
          done();
        });
      });
    });
  },
  function test_addToolbarButton(done) {
    let placement = CustomizableUI.getPlacementOfWidget("panic-button");
    is(placement, null, "default UI has panic button in the palette");

    gContentAPI.getConfiguration("availableTargets", data => {
      let available = data.targets.includes("forget");
      ok(!available, "Forget button should not be available by default");

      gContentAPI.addNavBarWidget("forget", () => {
        info("addNavBarWidget callback successfully called");

        let updatedPlacement = CustomizableUI.getPlacementOfWidget(
          "panic-button"
        );
        is(updatedPlacement.area, CustomizableUI.AREA_NAVBAR);

        gContentAPI.getConfiguration("availableTargets", data2 => {
          let updatedAvailable = data2.targets.includes("forget");
          ok(updatedAvailable, "Forget button should now be available");

          // Cleanup
          CustomizableUI.removeWidgetFromArea("panic-button");
          done();
        });
      });
    });
  },
  taskify(async function test_search() {
    let defaultEngine = await Services.search.getDefault();
    let visibleEngines = await Services.search.getVisibleEngines();
    let expectedEngines = visibleEngines
      .filter(engine => engine.identifier)
      .map(engine => "searchEngine-" + engine.identifier);

    let data = await new Promise(resolve =>
      gContentAPI.getConfiguration("search", resolve)
    );
    let engines = data.engines;
    ok(Array.isArray(engines), "data.engines should be an array");
    is(
      engines.sort().toString(),
      expectedEngines.sort().toString(),
      "Engines should be as expected"
    );

    is(
      data.searchEngineIdentifier,
      defaultEngine.identifier,
      "the searchEngineIdentifier property should contain the defaultEngine's identifier"
    );

    let someOtherEngineID = data.engines.filter(
      t => t != "searchEngine-" + defaultEngine.identifier
    )[0];
    someOtherEngineID = someOtherEngineID.replace(/^searchEngine-/, "");

    Services.telemetry.clearEvents();
    Services.fog.testResetFOG();

    await new Promise(resolve => {
      let observe = function(subject, topic, verb) {
        Services.obs.removeObserver(observe, "browser-search-engine-modified");
        info("browser-search-engine-modified: " + verb);
        if (verb == "engine-default") {
          is(
            Services.search.defaultEngine.identifier,
            someOtherEngineID,
            "correct engine was switched to"
          );
          resolve();
        }
      };
      Services.obs.addObserver(observe, "browser-search-engine-modified");
      registerCleanupFunction(async () => {
        await Services.search.setDefault(
          defaultEngine,
          Ci.nsISearchService.CHANGE_REASON_UNKNOWN
        );
      });

      gContentAPI.setDefaultSearchEngine(someOtherEngineID);
    });

    let engine = (await Services.search.getVisibleEngines()).filter(
      e => e.identifier == someOtherEngineID
    )[0];

    let submissionUrl = engine
      .getSubmission("dummy")
      .uri.spec.replace("dummy", "");

    TelemetryTestUtils.assertEvents(
      [
        {
          object: "change_default",
          value: "uitour",
          extra: {
            prev_id: defaultEngine.telemetryId,
            new_id: engine.telemetryId,
            new_name: engine.name,
            new_load_path: engine.wrappedJSObject._loadPath,
            // Telemetry has a limit of 80 characters.
            new_sub_url: submissionUrl.slice(0, 80),
          },
        },
      ],
      { category: "search", method: "engine" }
    );

    let snapshot = await Glean.searchEngineDefault.changed.testGetValue();
    delete snapshot[0].timestamp;
    Assert.deepEqual(
      snapshot[0],
      {
        category: "search.engine.default",
        name: "changed",
        extra: {
          change_source: "uitour",
          previous_engine_id: defaultEngine.telemetryId,
          new_engine_id: engine.telemetryId,
          new_display_name: engine.name,
          new_load_path: engine.wrappedJSObject._loadPath,
          // Glean has a limit of 100 characters.
          new_submission_url: submissionUrl.slice(0, 100),
        },
      },
      "Should have received the correct event details"
    );
  }),
  taskify(async function test_treatment_tag() {
    let ac = new TelemetryArchiveTesting.Checker();
    await ac.promiseInit();
    await gContentAPI.setTreatmentTag("foobar", "baz");
    // Wait until the treatment telemetry is sent before looking in the archive.
    await BrowserTestUtils.waitForContentEvent(
      gTestTab.linkedBrowser,
      "mozUITourNotification",
      false,
      event => event.detail.event === "TreatmentTag:TelemetrySent"
    );
    await new Promise(resolve => {
      gContentAPI.getTreatmentTag("foobar", data => {
        is(data.value, "baz", "set and retrieved treatmentTag");
        ac.promiseFindPing("uitour-tag", [
          [["payload", "tagName"], "foobar"],
          [["payload", "tagValue"], "baz"],
        ]).then(
          found => {
            ok(found, "Telemetry ping submitted for setTreatmentTag");
            resolve();
          },
          err => {
            ok(false, "Exception finding uitour telemetry ping: " + err);
            resolve();
          }
        );
      });
    });
  }),

  // Make sure this test is last in the file so the appMenu gets left open and done will confirm it got tore down.
  taskify(async function cleanupMenus() {
    let shownPromise = promisePanelShown(window);
    gContentAPI.showMenu("appMenu");
    await shownPromise;
  }),
];