/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
/* vim: set sts=2 sw=2 et tw=80: */
"use strict";

/* exported testCookies */
/* import-globals-from head.js */

async function testCookies(options) {
  // Changing the options object is a bit of a hack, but it allows us to easily
  // pass an expiration date to the background script.
  options.expiry = Date.now() / 1000 + 3600;

  async function background(backgroundOptions) {
    // Ask the parent scope to change some cookies we may or may not have
    // permission for.
    let awaitChanges = new Promise(resolve => {
      browser.test.onMessage.addListener(msg => {
        browser.test.assertEq("cookies-changed", msg, "browser.test.onMessage");
        resolve();
      });
    });

    let changed = [];
    browser.cookies.onChanged.addListener(event => {
      changed.push(`${event.cookie.name}:${event.cause}`);
    });
    browser.test.sendMessage("change-cookies");

    // Try to access some cookies in various ways.
    let {url, domain, secure} = backgroundOptions;

    let failures = 0;
    let tallyFailure = error => {
      failures++;
    };

    try {
      await awaitChanges;

      let cookie = await browser.cookies.get({url, name: "foo"});
      browser.test.assertEq(backgroundOptions.shouldPass, cookie != null, "should pass == get cookie");

      let cookies = await browser.cookies.getAll({domain});
      if (backgroundOptions.shouldPass) {
        browser.test.assertEq(2, cookies.length, "expected number of cookies");
      } else {
        browser.test.assertEq(0, cookies.length, "expected number of cookies");
      }

      await Promise.all([
        browser.cookies.set({url, domain, secure, name: "foo", "value": "baz", expirationDate: backgroundOptions.expiry}).catch(tallyFailure),
        browser.cookies.set({url, domain, secure, name: "bar", "value": "quux", expirationDate: backgroundOptions.expiry}).catch(tallyFailure),
        browser.cookies.remove({url, name: "deleted"}),
      ]);

      if (backgroundOptions.shouldPass) {
        // The order of eviction events isn't guaranteed, so just check that
        // it's there somewhere.
        let evicted = changed.indexOf("evicted:evicted");
        if (evicted < 0) {
          browser.test.fail("got no eviction event");
        } else {
          browser.test.succeed("got eviction event");
          changed.splice(evicted, 1);
        }

        browser.test.assertEq("x:explicit,x:overwrite,x:explicit,x:explicit,foo:overwrite,foo:explicit,bar:explicit,deleted:explicit",
                              changed.join(","), "expected changes");
      } else {
        browser.test.assertEq("", changed.join(","), "expected no changes");
      }

      if (!(backgroundOptions.shouldPass || backgroundOptions.shouldWrite)) {
        browser.test.assertEq(2, failures, "Expected failures");
      } else {
        browser.test.assertEq(0, failures, "Expected no failures");
      }

      browser.test.notifyPass("cookie-permissions");
    } catch (error) {
      browser.test.fail(`Error: ${error} :: ${error.stack}`);
      browser.test.notifyFail("cookie-permissions");
    }
  }

  let extension = ExtensionTestUtils.loadExtension({
    manifest: {
      "permissions": options.permissions,
    },

    background: `(${background})(${JSON.stringify(options)})`,
  });

  let stepOne = loadChromeScript(() => {
    const {addMessageListener, sendAsyncMessage} = this;
    addMessageListener("options", options => {
      let domain = options.domain.replace(/^\.?/, ".");
      // This will be evicted after we add a fourth cookie.
      Services.cookies.add(domain, "/", "evicted", "bar", options.secure, false, false, options.expiry);
      // This will be modified by the background script.
      Services.cookies.add(domain, "/", "foo", "bar", options.secure, false, false, options.expiry);
      // This will be deleted by the background script.
      Services.cookies.add(domain, "/", "deleted", "bar", options.secure, false, false, options.expiry);
      sendAsyncMessage("done");
    });
  });
  stepOne.sendAsyncMessage("options", options);
  await stepOne.promiseOneMessage("done");
  stepOne.destroy();

  await extension.startup();

  await extension.awaitMessage("change-cookies");

  let stepTwo = loadChromeScript(() => {
    const {addMessageListener, sendAsyncMessage} = this;
    addMessageListener("options", options => {
      let domain = options.domain.replace(/^\.?/, ".");

      Services.cookies.add(domain, "/", "x", "y", options.secure, false, false, options.expiry);
      Services.cookies.add(domain, "/", "x", "z", options.secure, false, false, options.expiry);
      Services.cookies.remove(domain, "x", "/", false, {});
      sendAsyncMessage("done");
    });
  });
  stepTwo.sendAsyncMessage("options", options);
  await stepTwo.promiseOneMessage("done");
  stepTwo.destroy();

  extension.sendMessage("cookies-changed");

  await extension.awaitFinish("cookie-permissions");
  await extension.unload();


  let stepThree = loadChromeScript(() => {
    const {addMessageListener, sendAsyncMessage, assert} = this;
    let cookieSvc = Services.cookies;

    function getCookies(host) {
      let cookies = [];
      let enum_ = cookieSvc.getCookiesFromHost(host, {});
      while (enum_.hasMoreElements()) {
        cookies.push(enum_.getNext().QueryInterface(Components.interfaces.nsICookie2));
      }
      return cookies.sort((a, b) => a.name.localeCompare(b.name));
    }

    addMessageListener("options", options => {
      let cookies = getCookies(options.domain);

      if (options.shouldPass) {
        assert.equal(cookies.length, 2, "expected two cookies for host");

        assert.equal(cookies[0].name, "bar", "correct cookie name");
        assert.equal(cookies[0].value, "quux", "correct cookie value");

        assert.equal(cookies[1].name, "foo", "correct cookie name");
        assert.equal(cookies[1].value, "baz", "correct cookie value");
      } else if (options.shouldWrite) {
        // Note: |shouldWrite| applies only when |shouldPass| is false.
        // This is necessary because, unfortunately, websites (and therefore web
        // extensions) are allowed to write some cookies which they're not allowed
        // to read.
        assert.equal(cookies.length, 3, "expected three cookies for host");

        assert.equal(cookies[0].name, "bar", "correct cookie name");
        assert.equal(cookies[0].value, "quux", "correct cookie value");

        assert.equal(cookies[1].name, "deleted", "correct cookie name");

        assert.equal(cookies[2].name, "foo", "correct cookie name");
        assert.equal(cookies[2].value, "baz", "correct cookie value");
      } else {
        assert.equal(cookies.length, 2, "expected two cookies for host");

        assert.equal(cookies[0].name, "deleted", "correct second cookie name");

        assert.equal(cookies[1].name, "foo", "correct cookie name");
        assert.equal(cookies[1].value, "bar", "correct cookie value");
      }

      for (let cookie of cookies) {
        cookieSvc.remove(cookie.host, cookie.name, "/", false, {});
      }
      // Make sure we don't silently poison subsequent tests if something goes wrong.
      assert.equal(getCookies(options.domain).length, 0, "cookies cleared");
      sendAsyncMessage("done");
    });
  });
  stepThree.sendAsyncMessage("options", options);
  await stepThree.promiseOneMessage("done");
  stepThree.destroy();
}
