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

class TDummyPlugin {

  instance;

  constructor(el: Element & {
    isInCollection?: boolean | undefined;
  }) {
    this.instance = el;
  }

}

describe("Collection plugin", () => {
  it("adds and removes collection items", () => {
    const collection = new Collection("[data-js-dummy]", TDummyPlugin, false);
    const el = document.createElement("div");

    const item = collection.addToCollection(el);

    assert.ok(item instanceof TDummyPlugin);
    assert.equal(collection.collection.length, 1);

    collection.removeFromCollection(item);
    assert.equal(collection.collection.length, 0);
  });

  it("initializes with correct selector and plugin", () => {
    const collection = new Collection("[data-test]", TDummyPlugin, false);
    assert.equal(collection.collectionObserverSelector, "[data-test]");
    assert.equal(collection.collectionObserverClass, TDummyPlugin);
  });

  it("has correct event bubble names", () => {
    assert.equal(Collection.bubbles.mount, "collection::mount");
    assert.equal(Collection.bubbles.unmount, "collection::unmount");
  });

  it("does not add duplicate items to collection", () => {
    const collection = new Collection("[data-test]", TDummyPlugin, false);
    const el = document.createElement("div");

    const item1 = collection.addToCollection(el);
    const item2 = collection.addToCollection(el);

    assert.ok(item1 instanceof TDummyPlugin);
    assert.strictEqual(item2, null);
    assert.equal(collection.collection.length, 1);
  });

  it("gets item by DOM element", () => {
    const collection = new Collection("[data-test]", TDummyPlugin, false);
    const el = document.createElement("div");

    const item = collection.addToCollection(el);
    const found = collection.getByDOMElement(el);

    assert.strictEqual(found, item);
  });

  it("returns null for non-existent DOM element", () => {
    const collection = new Collection("[data-test]", TDummyPlugin, false);
    const el = document.createElement("div");

    const found = collection.getByDOMElement(el);

    assert.strictEqual(found, null);
  });

  it("gets item by index", () => {
    const collection = new Collection("[data-test]", TDummyPlugin, false);
    const el1 = document.createElement("div");
    const el2 = document.createElement("div");

    const item1 = collection.addToCollection(el1);
    const item2 = collection.addToCollection(el2);

    assert.strictEqual(collection.getByIndex(0), item1);
    assert.strictEqual(collection.getByIndex(1), item2);
  });

  it("returns null for out of bounds index", () => {
    const collection = new Collection("[data-test]", TDummyPlugin, false);

    assert.strictEqual(collection.getByIndex(0), null);
    assert.strictEqual(collection.getByIndex(99), null);
  });

  it("sets element state correctly", () => {
    const collection = new Collection("[data-test]", TDummyPlugin, false);
    const el = document.createElement("div");

    collection.setElementState(el, true);
    assert.equal((el as TCollectionElement).isInCollection, true);

    collection.setElementState(el, false);
    assert.equal((el as TCollectionElement).isInCollection, false);
  });

  it("marks element as in collection when added", () => {
    const collection = new Collection("[data-test]", TDummyPlugin, false);
    const el = document.createElement("div");

    collection.addToCollection(el);

    assert.equal((el as TCollectionElement).isInCollection, true);
  });

  it("unmarks element when removed from collection", () => {
    const collection = new Collection("[data-test]", TDummyPlugin, false);
    const el = document.createElement("div");

    const item = collection.addToCollection(el);
    assert.equal((el as TCollectionElement).isInCollection, true);

    collection.removeFromCollection(item!);
    assert.equal((el as TCollectionElement).isInCollection, false);
  });

  it("initializes from context with querySelectorAll", () => {
    document.body.innerHTML = "<div data-test></div><div data-test></div>";
    const collection = new Collection("[data-test]", TDummyPlugin, false);

    collection.init(document);

    assert.equal(collection.collection.length, 2);
    document.body.innerHTML = "";
  });

  it("adds multiple items correctly", () => {
    const collection = new Collection("[data-test]", TDummyPlugin, false);
    const el1 = document.createElement("div");
    const el2 = document.createElement("div");
    const el3 = document.createElement("div");

    collection.addToCollection(el1);
    collection.addToCollection(el2);
    collection.addToCollection(el3);

    assert.equal(collection.collection.length, 3);
  });

  it("calls beforeAddCallback when adding item", () => {
    let called = false;
    const collection = new Collection("[data-test]", TDummyPlugin, false);
    collection.beforeAddCallback = () => {
      called = true;
    };

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

    assert.ok(called);
  });

  it("calls afterAddCallback when adding item", () => {
    let called = false;
    const collection = new Collection("[data-test]", TDummyPlugin, false);
    collection.afterAddCallback = () => {
      called = true;
    };

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

    assert.ok(called);
  });

  it("calls beforeRemoveCallback when removing item", () => {
    let called = false;
    const collection = new Collection("[data-test]", TDummyPlugin, false);
    collection.beforeRemoveCallback = () => {
      called = true;
    };

    const el = document.createElement("div");
    const item = collection.addToCollection(el);
    collection.removeFromCollection(item!);

    assert.ok(called);
  });

  it("calls afterRemoveCallback when removing item", () => {
    let called = false;
    const collection = new Collection("[data-test]", TDummyPlugin, false);
    collection.afterRemoveCallback = () => {
      called = true;
    };

    const el = document.createElement("div");
    const item = collection.addToCollection(el);
    collection.removeFromCollection(item!);

    assert.ok(called);
  });

  it("does not remove last item when removing unknown instance", () => {
    const collection = new Collection("[data-test]", TDummyPlugin, false);
    const el1 = document.createElement("div");
    const el2 = document.createElement("div");
    const unknownEl = document.createElement("div");

    const item1 = collection.addToCollection(el1);
    const item2 = collection.addToCollection(el2);
    const unknownItem = new TDummyPlugin(unknownEl);

    assert.ok(item1 instanceof TDummyPlugin);
    assert.ok(item2 instanceof TDummyPlugin);
    assert.equal(collection.collection.length, 2);

    collection.removeFromCollection(unknownItem);

    assert.equal(collection.collection.length, 2);
    assert.strictEqual(collection.getByDOMElement(el1), item1);
    assert.strictEqual(collection.getByDOMElement(el2), item2);
  });
});