import assert from "node:assert";
import { describe, it } from "node:test";
import { Dispatcher } from "./index";

describe("Dispatcher plugin", () => {
  it("dispatches action to collection instances", () => {
    Dispatcher.clear();

    let calls = 0;
    const root = document.createElement("div");
    const el = document.createElement("div");
    root.appendChild(el);

    Dispatcher.initiator = {
      selector: "[data-js-dispatch-test]",
      initiator: () => null,
      getCollection: () => [ {
        instance: el,
        ping: () => {
          calls += 1;
        },
      } ],
    };

    Dispatcher.dispatchAction(root, "ping");

    assert.equal(calls, 1);
    Dispatcher.clear();
  });

  it("registers initiator correctly", () => {
    Dispatcher.clear();
    const testFn = () => null;

    Dispatcher.initiator = {
      selector: "[data-test]",
      initiator: testFn,
      getCollection: () => [],
    };

    assert.ok(Dispatcher.isInitiatorExist("[data-test]"));
    Dispatcher.clear();
  });

  it("does not register duplicate initiators", () => {
    Dispatcher.clear();
    const firstFn = () => 1;
    const secondFn = () => 2;

    Dispatcher.initiator = {
      selector: "[data-test]",
      initiator: firstFn,
    };

    Dispatcher.initiator = {
      selector: "[data-test]",
      initiator: secondFn,
    };

    assert.ok(Dispatcher.isInitiatorExist("[data-test]"));
    Dispatcher.clear();
  });

  it("removes initiator correctly", () => {
    Dispatcher.clear();

    Dispatcher.initiator = {
      selector: "[data-test]",
      initiator: () => null,
    };

    assert.ok(Dispatcher.isInitiatorExist("[data-test]"));

    Dispatcher.removeInitiator("[data-test]");

    assert.ok(!Dispatcher.isInitiatorExist("[data-test]"));
    Dispatcher.clear();
  });

  it("clears all initiators", () => {
    Dispatcher.clear();

    Dispatcher.initiator = {
      selector: "[data-test-1]",
      initiator: () => null,
    };

    Dispatcher.initiator = {
      selector: "[data-test-2]",
      initiator: () => null,
    };

    Dispatcher.clear();

    assert.ok(!Dispatcher.isInitiatorExist("[data-test-1]"));
    assert.ok(!Dispatcher.isInitiatorExist("[data-test-2]"));
  });

  it("dispatches action with filter function", () => {
    Dispatcher.clear();

    let calls = 0;
    const root = document.createElement("div");
    const el1 = document.createElement("div");
    const el2 = document.createElement("div");
    el1.setAttribute("data-id", "1");
    el2.setAttribute("data-id", "2");
    root.appendChild(el1);
    root.appendChild(el2);

    Dispatcher.initiator = {
      selector: "[data-test]",
      initiator: () => null,
      getCollection: () => [
        {
          instance: el1,
          action: () => {
            calls += 1;
          },
        },
        {
          instance: el2,
          action: () => {
            calls += 1;
          },
        },
      ],
    };

    Dispatcher.dispatchAction(root, "action", (instance) => instance.instance.getAttribute("data-id") === "1");

    assert.equal(calls, 1);
    Dispatcher.clear();
  });

  it("does not dispatch to instances outside root", () => {
    Dispatcher.clear();

    let calls = 0;
    const root = document.createElement("div");
    const outside = document.createElement("div");
    const inside = document.createElement("div");
    root.appendChild(inside);

    Dispatcher.initiator = {
      selector: "[data-test]",
      initiator: () => null,
      getCollection: () => [
        {
          instance: inside,
          ping: () => {
            calls += 1;
          },
        },
        {
          instance: outside,
          ping: () => {
            calls += 1;
          },
        },
      ],
    };

    Dispatcher.dispatchAction(root, "ping");

    assert.equal(calls, 1);
    Dispatcher.clear();
  });

  it("handles missing getCollection function", () => {
    Dispatcher.clear();

    Dispatcher.initiator = {
      selector: "[data-test]",
      initiator: () => null,
    };

    assert.doesNotThrow(() => {
      Dispatcher.dispatchAction(document.body, "anyAction");
    });

    Dispatcher.clear();
  });

  it("uses body as default root for dispatchAction", () => {
    Dispatcher.clear();

    let called = false;
    const el = document.createElement("div");
    document.body.appendChild(el);

    Dispatcher.initiator = {
      selector: "[data-test]",
      initiator: () => null,
      getCollection: () => [
        {
          instance: el,
          test: () => {
            called = true;
          },
        },
      ],
    };

    Dispatcher.dispatchAction(null, "test");

    assert.ok(called);
    document.body.removeChild(el);
    Dispatcher.clear();
  });

  it("has correct default configuration", () => {
    assert.equal(Dispatcher.defaultCfg.eventContentProp, "content");
    assert.equal(typeof Dispatcher.defaultCfg.isInitiatorValid, "function");
    assert.equal(Dispatcher.defaultCfg.isDebug, false);
  });
});