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

describe("Observer plugin", () => {
  it("toggles observable state attrs", () => {
    Observer.defaultCfg.includedSelector = "[data-js-ObserverInclude]";
    Observer.defaultCfg.excludedSelector = "[data-js-ObserverExclude]";

    const el = document.createElement("div");

    Observer.setElObservableState(el, false);
    assert.equal(el.hasAttribute("data-js-ObserverExclude"), true);

    Observer.setElObservableState(el, true);
    assert.equal(el.hasAttribute("data-js-ObserverInclude"), true);
  });

  it("removes excluded attr when setting included", () => {
    const el = document.createElement("div");
    el.setAttribute("data-js-ObserverExclude", "");

    Observer.setElObservableState(el, true);

    assert.equal(el.hasAttribute("data-js-ObserverInclude"), true);
    assert.equal(el.hasAttribute("data-js-ObserverExclude"), false);
  });

  it("removes included attr when setting excluded", () => {
    const el = document.createElement("div");
    el.setAttribute("data-js-ObserverInclude", "");

    Observer.setElObservableState(el, false);

    assert.equal(el.hasAttribute("data-js-ObserverExclude"), true);
    assert.equal(el.hasAttribute("data-js-ObserverInclude"), false);
  });

  it("has correct default configuration", () => {
    assert.deepEqual(Observer.defaultCfg.observerExcludedTags, [
      "iframe",
      "script",
      "svg",
      "ymaps",
      "object",
      "img",
      "template",
      "picture",
    ]);
    assert.equal(Observer.defaultCfg.observerCfg.childList, true);
    assert.equal(Observer.defaultCfg.observerCfg.subtree, true);
    assert.equal(Observer.defaultCfg.excludedSelector, "[data-js-ObserverExclude]");
    assert.equal(Observer.defaultCfg.includedSelector, "[data-js-ObserverInclude]");
  });

  it("initializes callbacks map", () => {
    assert.ok(Observer.callbacks instanceof Map);
  });

  it("checks if callback exists", () => {
    Observer.callbacks.clear();
    Observer.subscribe = { selector: "[test]", callback: () => null };

    assert.ok(Observer.isCallbackExist("[test]"));
    assert.ok(!Observer.isCallbackExist("[nonexistent]"));

    Observer.callbacks.clear();
  });

  it("subscribes callback for selector", () => {
    Observer.callbacks.clear();
    const callback = () => null;

    Observer.subscribe = { selector: "[test]", callback };

    assert.ok(Observer.callbacks.has("[test]"));
    assert.equal(Observer.callbacks.get("[test]"), callback);

    Observer.callbacks.clear();
  });

  it("does not subscribe duplicate callbacks", () => {
    Observer.callbacks.clear();
    const callback = () => null;

    Observer.subscribe = { selector: "[test]", callback };
    Observer.subscribe = { selector: "[test]", callback };

    assert.equal(Observer.callbacks.size, 1);

    Observer.callbacks.clear();
  });

  it("unsubscribes callback by selector", () => {
    Observer.callbacks.clear();
    Observer.subscribe = { selector: "[test]", callback: () => null };

    Observer.unsubscribe = "[test]";

    assert.ok(!Observer.callbacks.has("[test]"));
  });

  it("creates singleton instance", () => {
    const observer1 = new Observer();
    const observer2 = new Observer();

    assert.strictEqual(observer1, observer2);
  });

  it("initializes with disconnected state", () => {
    const observer = new Observer();
    assert.equal(observer.isConnected, false);
  });

  it("has correct default target", () => {
    const target = Observer.getTarget();
    assert.equal(target, document.body);
  });

  it("allows reconnect after disconnect", () => {
    const observer = new Observer();
    observer.connect(document.body);
    assert.equal(observer.isConnected, true);

    observer.disconnect();
    assert.equal(observer.isConnected, false);

    observer.connect(document.body);
    assert.equal(observer.isConnected, true);
  });
});