const { json, getKnownElement, getKnownShadowRoot } =
  ChromeUtils.importESModule("chrome://remote/content/marionette/json.sys.mjs");
const { NodeCache } = ChromeUtils.importESModule(
  "chrome://remote/content/shared/webdriver/NodeCache.sys.mjs"
);
const { ShadowRoot, WebElement, WebReference } = ChromeUtils.importESModule(
  "chrome://remote/content/marionette/web-reference.sys.mjs"
);

const MemoryReporter = Cc["@mozilla.org/memory-reporter-manager;1"].getService(
  Ci.nsIMemoryReporterManager
);

function setupTest() {
  const browser = Services.appShell.createWindowlessBrowser(false);
  const nodeCache = new NodeCache();

  const videoEl = browser.document.createElement("video");
  browser.document.body.appendChild(videoEl);

  const svgEl = browser.document.createElementNS(
    "http://www.w3.org/2000/svg",
    "rect"
  );
  browser.document.body.appendChild(svgEl);

  const shadowRoot = videoEl.openOrClosedShadowRoot;

  const iframeEl = browser.document.createElement("iframe");
  browser.document.body.appendChild(iframeEl);
  const childEl = iframeEl.contentDocument.createElement("div");

  return {
    browser,
    browsingContext: browser.browsingContext,
    nodeCache,
    childEl,
    iframeEl,
    seenNodeIds: new Map(),
    shadowRoot,
    svgEl,
    videoEl,
  };
}

function assert_cloned_value(value, clonedValue, nodeCache, seenNodes = []) {
  const { seenNodeIds, serializedValue } = json.clone(value, nodeCache);

  deepEqual(serializedValue, clonedValue);
  deepEqual([...seenNodeIds.values()], seenNodes);
}

add_task(function test_clone_generalTypes() {
  const { nodeCache } = setupTest();

  // null
  assert_cloned_value(undefined, null, nodeCache);
  assert_cloned_value(null, null, nodeCache);

  // primitives
  assert_cloned_value(true, true, nodeCache);
  assert_cloned_value(42, 42, nodeCache);
  assert_cloned_value("foo", "foo", nodeCache);

  // toJSON
  assert_cloned_value(
    {
      toJSON() {
        return "foo";
      },
    },
    "foo",
    nodeCache
  );
});

add_task(function test_clone_ShadowRoot() {
  const { nodeCache, seenNodeIds, shadowRoot } = setupTest();

  const shadowRootRef = nodeCache.getOrCreateNodeReference(
    shadowRoot,
    seenNodeIds
  );
  assert_cloned_value(
    shadowRoot,
    WebReference.from(shadowRoot, shadowRootRef).toJSON(),
    nodeCache,
    seenNodeIds
  );
});

add_task(function test_clone_WebElement() {
  const { videoEl, nodeCache, seenNodeIds, svgEl } = setupTest();

  const videoElRef = nodeCache.getOrCreateNodeReference(videoEl, seenNodeIds);
  assert_cloned_value(
    videoEl,
    WebReference.from(videoEl, videoElRef).toJSON(),
    nodeCache,
    seenNodeIds
  );

  // Check an element with a different namespace
  const svgElRef = nodeCache.getOrCreateNodeReference(svgEl, seenNodeIds);
  assert_cloned_value(
    svgEl,
    WebReference.from(svgEl, svgElRef).toJSON(),
    nodeCache,
    seenNodeIds
  );
});

add_task(function test_clone_Sequences() {
  const { videoEl, nodeCache, seenNodeIds } = setupTest();

  const videoElRef = nodeCache.getOrCreateNodeReference(videoEl, seenNodeIds);

  const input = [
    null,
    true,
    [42],
    videoEl,
    {
      toJSON() {
        return "foo";
      },
    },
    { bar: "baz" },
  ];

  assert_cloned_value(
    input,
    [
      null,
      true,
      [42],
      { [WebElement.Identifier]: videoElRef },
      "foo",
      { bar: "baz" },
    ],
    nodeCache,
    seenNodeIds
  );
});

add_task(function test_clone_objects() {
  const { videoEl, nodeCache, seenNodeIds } = setupTest();

  const videoElRef = nodeCache.getOrCreateNodeReference(videoEl, seenNodeIds);

  const input = {
    null: null,
    boolean: true,
    array: [42],
    element: videoEl,
    toJSON: {
      toJSON() {
        return "foo";
      },
    },
    object: { bar: "baz" },
  };

  assert_cloned_value(
    input,
    {
      null: null,
      boolean: true,
      array: [42],
      element: { [WebElement.Identifier]: videoElRef },
      toJSON: "foo",
      object: { bar: "baz" },
    },
    nodeCache,
    seenNodeIds
  );
});

add_task(function test_clone_сyclicReference() {
  const { nodeCache } = setupTest();

  // object
  Assert.throws(() => {
    const obj = {};
    obj.reference = obj;
    json.clone(obj, nodeCache);
  }, /JavaScriptError/);

  // array
  Assert.throws(() => {
    const array = [];
    array.push(array);
    json.clone(array, nodeCache);
  }, /JavaScriptError/);

  // array in object
  Assert.throws(() => {
    const array = [];
    array.push(array);
    json.clone({ array }, nodeCache);
  }, /JavaScriptError/);

  // object in array
  Assert.throws(() => {
    const obj = {};
    obj.reference = obj;
    json.clone([obj], nodeCache);
  }, /JavaScriptError/);
});

add_task(function test_deserialize_generalTypes() {
  const { browsingContext, nodeCache } = setupTest();

  // null
  equal(json.deserialize(undefined, nodeCache, browsingContext), undefined);
  equal(json.deserialize(null, nodeCache, browsingContext), null);

  // primitives
  equal(json.deserialize(true, nodeCache, browsingContext), true);
  equal(json.deserialize(42, nodeCache, browsingContext), 42);
  equal(json.deserialize("foo", nodeCache, browsingContext), "foo");
});

add_task(function test_deserialize_ShadowRoot() {
  const { browsingContext, nodeCache, seenNodeIds, shadowRoot } = setupTest();
  const seenNodes = new Set();

  // Fails to resolve for unknown elements
  const unknownShadowRootId = { [ShadowRoot.Identifier]: "foo" };
  Assert.throws(() => {
    json.deserialize(
      unknownShadowRootId,
      nodeCache,
      browsingContext,
      seenNodes
    );
  }, /NoSuchShadowRootError/);

  const shadowRootRef = nodeCache.getOrCreateNodeReference(
    shadowRoot,
    seenNodeIds
  );
  const shadowRootEl = { [ShadowRoot.Identifier]: shadowRootRef };

  // Fails to resolve for missing window reference
  Assert.throws(() => json.deserialize(shadowRootEl, nodeCache), /TypeError/);

  // Previously seen element is associated with original web element reference
  seenNodes.add(shadowRootRef);
  const root = json.deserialize(
    shadowRootEl,
    nodeCache,
    browsingContext,
    seenNodes
  );
  deepEqual(root, shadowRoot);
  deepEqual(root, nodeCache.getNode(browsingContext, shadowRootRef));
});

add_task(function test_deserialize_WebElement() {
  const { browser, browsingContext, videoEl, nodeCache, seenNodeIds } =
    setupTest();
  const seenNodes = new Set();

  // Fails to resolve for unknown elements
  const unknownWebElId = { [WebElement.Identifier]: "foo" };
  Assert.throws(() => {
    json.deserialize(unknownWebElId, nodeCache, browsingContext, seenNodes);
  }, /NoSuchElementError/);

  const videoElRef = nodeCache.getOrCreateNodeReference(videoEl, seenNodeIds);
  const htmlWebEl = { [WebElement.Identifier]: videoElRef };

  // Fails to resolve for missing window reference
  Assert.throws(() => json.deserialize(htmlWebEl, nodeCache), /TypeError/);

  // Previously seen element is associated with original web element reference
  seenNodes.add(videoElRef);
  const el = json.deserialize(htmlWebEl, nodeCache, browsingContext, seenNodes);
  deepEqual(el, videoEl);
  deepEqual(el, nodeCache.getNode(browser.browsingContext, videoElRef));
});

add_task(function test_deserialize_Sequences() {
  const { browsingContext, videoEl, nodeCache, seenNodeIds } = setupTest();
  const seenNodes = new Set();

  const videoElRef = nodeCache.getOrCreateNodeReference(videoEl, seenNodeIds);
  seenNodes.add(videoElRef);

  const input = [
    null,
    true,
    [42],
    { [WebElement.Identifier]: videoElRef },
    { bar: "baz" },
  ];

  const actual = json.deserialize(input, nodeCache, browsingContext, seenNodes);

  equal(actual[0], null);
  equal(actual[1], true);
  deepEqual(actual[2], [42]);
  deepEqual(actual[3], videoEl);
  deepEqual(actual[4], { bar: "baz" });
});

add_task(function test_deserialize_objects() {
  const { browsingContext, videoEl, nodeCache, seenNodeIds } = setupTest();
  const seenNodes = new Set();

  const videoElRef = nodeCache.getOrCreateNodeReference(videoEl, seenNodeIds);
  seenNodes.add(videoElRef);

  const input = {
    null: null,
    boolean: true,
    array: [42],
    element: { [WebElement.Identifier]: videoElRef },
    object: { bar: "baz" },
  };

  const actual = json.deserialize(input, nodeCache, browsingContext, seenNodes);

  equal(actual.null, null);
  equal(actual.boolean, true);
  deepEqual(actual.array, [42]);
  deepEqual(actual.element, videoEl);
  deepEqual(actual.object, { bar: "baz" });

  nodeCache.clear({ all: true });
});

add_task(async function test_getKnownElement() {
  const { browser, nodeCache, seenNodeIds, shadowRoot, videoEl } = setupTest();
  const seenNodes = new Set();

  // Unknown element reference
  Assert.throws(() => {
    getKnownElement(browser.browsingContext, "foo", nodeCache, seenNodes);
  }, /NoSuchElementError/);

  // With a ShadowRoot reference
  const shadowRootRef = nodeCache.getOrCreateNodeReference(
    shadowRoot,
    seenNodeIds
  );
  seenNodes.add(shadowRootRef);

  Assert.throws(() => {
    getKnownElement(
      browser.browsingContext,
      shadowRootRef,
      nodeCache,
      seenNodes
    );
  }, /NoSuchElementError/);

  let detachedEl = browser.document.createElement("div");
  const detachedElRef = nodeCache.getOrCreateNodeReference(
    detachedEl,
    seenNodeIds
  );
  seenNodes.add(detachedElRef);

  // Element not connected to the DOM
  Assert.throws(() => {
    getKnownElement(
      browser.browsingContext,
      detachedElRef,
      nodeCache,
      seenNodes
    );
  }, /StaleElementReferenceError/);

  // Element garbage collected
  detachedEl = null;

  await new Promise(resolve => MemoryReporter.minimizeMemoryUsage(resolve));
  Assert.throws(() => {
    getKnownElement(
      browser.browsingContext,
      detachedElRef,
      nodeCache,
      seenNodes
    );
  }, /StaleElementReferenceError/);

  // Known element reference
  const videoElRef = nodeCache.getOrCreateNodeReference(videoEl, seenNodeIds);
  seenNodes.add(videoElRef);

  equal(
    getKnownElement(browser.browsingContext, videoElRef, nodeCache, seenNodes),
    videoEl
  );
});

add_task(async function test_getKnownShadowRoot() {
  const { browser, nodeCache, seenNodeIds, shadowRoot, videoEl } = setupTest();
  const seenNodes = new Set();

  const videoElRef = nodeCache.getOrCreateNodeReference(videoEl, seenNodeIds);
  seenNodes.add(videoElRef);

  // Unknown ShadowRoot reference
  Assert.throws(() => {
    getKnownShadowRoot(browser.browsingContext, "foo", nodeCache, seenNodes);
  }, /NoSuchShadowRootError/);

  // With a videoElement reference
  Assert.throws(() => {
    getKnownShadowRoot(
      browser.browsingContext,
      videoElRef,
      nodeCache,
      seenNodes
    );
  }, /NoSuchShadowRootError/);

  // Known ShadowRoot reference
  const shadowRootRef = nodeCache.getOrCreateNodeReference(
    shadowRoot,
    seenNodeIds
  );
  seenNodes.add(shadowRootRef);

  equal(
    getKnownShadowRoot(
      browser.browsingContext,
      shadowRootRef,
      nodeCache,
      seenNodes
    ),
    shadowRoot
  );

  // Detached ShadowRoot host
  let el = browser.document.createElement("div");
  let detachedShadowRoot = el.attachShadow({ mode: "open" });
  detachedShadowRoot.innerHTML = "<input></input>";

  const detachedShadowRootRef = nodeCache.getOrCreateNodeReference(
    detachedShadowRoot,
    seenNodeIds
  );
  seenNodes.add(detachedShadowRootRef);

  // ... not connected to the DOM
  Assert.throws(() => {
    getKnownShadowRoot(
      browser.browsingContext,
      detachedShadowRootRef,
      nodeCache,
      seenNodes
    );
  }, /DetachedShadowRootError/);

  // ... host and shadow root garbage collected
  el = null;
  detachedShadowRoot = null;

  await new Promise(resolve => MemoryReporter.minimizeMemoryUsage(resolve));
  Assert.throws(() => {
    getKnownShadowRoot(
      browser.browsingContext,
      detachedShadowRootRef,
      nodeCache,
      seenNodes
    );
  }, /DetachedShadowRootError/);
});