import assert from "node:assert";
import { describe, it } from "node:test";
import { getCheckedItems } from "./getCheckedItems";
import type { IChecker } from "../../checker/config/types/index";
import type { ICheckerGroup, ICheckerGroupItemsGroup } from "../index";

describe("getCheckedItems util", () => {
  type TCheckerGroupItem = ICheckerGroup["items"][number];

  const isGroupItem = (item: TCheckerGroupItem): item is ICheckerGroupItemsGroup => {
    return "items" in item;
  };

  const isCheckerItem = (item: TCheckerGroupItem): item is IChecker => {
    return !isGroupItem(item);
  };

  const getCheckerItemByIndex = (
    items: ICheckerGroup["items"],
    index: number
  ): IChecker => {
    const item = items[index];
    assert.ok(item && isCheckerItem(item));
    return item;
  };

  const getGroupItemByIndex = (
    items: ICheckerGroup["items"],
    index: number
  ): ICheckerGroupItemsGroup => {
    const item = items[index];
    assert.ok(item && isGroupItem(item));
    return item;
  };

  const getGroupCheckerItemByIndex = (
    group: ICheckerGroupItemsGroup,
    index: number
  ): IChecker => {
    const item = group.items[index];
    assert.ok(item && isCheckerItem(item));
    return item;
  };

  const flatItems: ICheckerGroup["items"] = [
    { name: "item1", value: "1", isChecked: false },
    { name: "item2", value: "2", isChecked: true },
    { name: "item3", value: "3", isChecked: false },
  ];

  const nestedItems: ICheckerGroup["items"] = [
    {
      label: "Group 1",
      items: [
        { name: "group1-item1", value: "group1-value1", isChecked: true },
        { name: "group1-item2", value: "group1-value2", isChecked: false },
      ],
    },
    {
      label: "Group 2",
      items: [
        { name: "group2-item1", value: "group2-value1", isChecked: false },
      ],
    },
  ];

  const flatRadioItems: ICheckerGroup["items"] = [
    { name: "group", value: "opt1", isChecked: true },
    { name: "group", value: "opt2", isChecked: false },
    { name: "group", value: "opt3", isChecked: false },
  ];

  const nestedRadioItems: ICheckerGroup["items"] = [
    {
      label: "Radio Group",
      items: [
        { name: "radioGroup1", value: "r1", isChecked: true },
        { name: "radioGroup1", value: "r2", isChecked: false },
      ],
    },
  ];

  /* CHECKBOX */

  describe("checkbox type", () => {
    it("should toggle specific checkbox by name", () => {
      const result = getCheckedItems(flatItems, {
        type: "checkbox",
        name: "item1",
        checked: true,
      });

      assert.strictEqual(getCheckerItemByIndex(result, 0).isChecked, true);
      assert.strictEqual(getCheckerItemByIndex(result, 1).isChecked, true); // unchanged
      assert.strictEqual(getCheckerItemByIndex(result, 2).isChecked, false); // unchanged
    });

    it("should uncheck previously checked checkbox", () => {
      const result = getCheckedItems(flatItems, {
        type: "checkbox",
        name: "item2",
        checked: false,
      });

      assert.strictEqual(getCheckerItemByIndex(result, 1).isChecked, false);
    });

    it("should handle nested structures for checkboxes", () => {
      const result = getCheckedItems(nestedItems, {
        type: "checkbox",
        name: "group1-item2",
        checked: true,
      });

      const group1 = getGroupItemByIndex(result, 0);
      assert.strictEqual(getGroupCheckerItemByIndex(group1, 0).isChecked, true); // unchanged
      assert.strictEqual(getGroupCheckerItemByIndex(group1, 1).isChecked, true); // changed
    });

    it("should preserve other properties when updating", () => {
      const result = getCheckedItems(flatItems, {
        type: "checkbox",
        name: "item1",
        checked: true,
      });

      assert.strictEqual(getCheckerItemByIndex(result, 0).name, "item1");
      assert.strictEqual(getCheckerItemByIndex(result, 0).value, "1");
    });
  });

  /* RADIO */

  describe("radio type", () => {
    it("should check radio by value and uncheck others", () => {
      const result = getCheckedItems(flatRadioItems, {
        type: "radio",
        value: "opt2",
        checked: true,
      });

      assert.strictEqual(getCheckerItemByIndex(result, 0).isChecked, false);
      assert.strictEqual(getCheckerItemByIndex(result, 1).isChecked, true);
      assert.strictEqual(getCheckerItemByIndex(result, 2).isChecked, false);
    });

    it("should handle radio groups in nested structures", () => {
      const result = getCheckedItems(nestedRadioItems, {
        type: "radio",
        value: "r2",
        checked: true,
      });

      const group1 = getGroupItemByIndex(result, 0);
      assert.strictEqual(getGroupCheckerItemByIndex(group1, 0).isChecked, false);
      assert.strictEqual(getGroupCheckerItemByIndex(group1, 1).isChecked, true);
    });

    it("should ignore name parameter for radio type", () => {
      const result = getCheckedItems(flatItems, {
        type: "radio",
        name: "item1",
        checked: true,
        value: "3",
      });

      // Radio selection is based on value, not name
      assert.strictEqual(getCheckerItemByIndex(result, 0).isChecked, false);
      assert.strictEqual(getCheckerItemByIndex(result, 1).isChecked, false);
      assert.strictEqual(getCheckerItemByIndex(result, 2).isChecked, true);
    });
  });

  /* COMMON */

  it("should return new array without mutating original", () => {
    const original = [ ...flatItems ];
    const result = getCheckedItems(flatItems, {
      type: "checkbox",
      name: "item1",
      checked: true,
    });

    assert.notStrictEqual(result, flatItems);
    assert.strictEqual(getCheckerItemByIndex(original, 0).isChecked, false); // original unchanged
    assert.strictEqual(getCheckerItemByIndex(result, 0).isChecked, true); // new array has changes
  });

  it("should handle empty items array", () => {
    const result = getCheckedItems([], {
      type: "checkbox",
      name: "test",
      checked: true,
    });

    assert.deepStrictEqual(result, []);
  });

  it("should handle items without isChecked property", () => {
    const itemsWithoutChecked: ICheckerGroup["items"] = [
      { name: "item1", value: "1" },
      { name: "item2", value: "2" },
    ];

    const result = getCheckedItems(itemsWithoutChecked, {
      type: "checkbox",
      name: "item1",
      checked: true,
    });

    assert.strictEqual(getCheckerItemByIndex(result, 0).isChecked, true);
    assert.strictEqual(getCheckerItemByIndex(result, 1).isChecked, false);
  });

  it("should handle mixed structure with groups and individual items", () => {
    const mixedItems: ICheckerGroup["items"] = [
      { name: "single1", value: "s1", isChecked: false },
      {
        label: "Mixed Group",
        items: [
          { name: "mg1", value: "mgv1", isChecked: true },
          { name: "mg2", value: "mgv2", isChecked: false },
        ],
      },
      { name: "single2", value: "s2", isChecked: true },
    ];

    const result = getCheckedItems(mixedItems, {
      type: "checkbox",
      name: "single1",
      checked: true,
    });

    assert.strictEqual(getCheckerItemByIndex(result, 0).isChecked, true);
    const group = getGroupItemByIndex(result, 1);
    assert.strictEqual(getGroupCheckerItemByIndex(group, 0).isChecked, true);
    assert.strictEqual(getGroupCheckerItemByIndex(group, 1).isChecked, false);
    assert.strictEqual(getCheckerItemByIndex(result, 2).isChecked, true);
  });
});