import { assert, describe, it } from "vitest";
import { updateModelValue } from "../../components/forms/defs";

// ---------------------------------------------------------------------------
// updateModelValue — flat keys (existing behavior / regression)
// ---------------------------------------------------------------------------

describe("updateModelValue — flat keys", () => {
  it("sets a top-level string field", () => {
    const result = updateModelValue({ name: "John" }, { name: "name" }, "Jane");
    assert.equal(result.name, "Jane");
  });

  it("preserves unrelated keys", () => {
    const result = updateModelValue(
      { name: "John", age: 30 },
      { name: "name" },
      "Jane",
    );
    assert.equal(result.age, 30);
  });

  it("coerces number-type fields to a number", () => {
    const result = updateModelValue(
      { qty: 0 },
      { name: "qty", type: "number" },
      "5",
    );
    assert.strictEqual(result.qty, 5);
    assert.typeOf(result.qty, "number");
  });

  it("adds a value to a checkbox-list array (key = checked option)", () => {
    const result = updateModelValue(
      { tags: ["a"] },
      { name: "tags" },
      true,
      "b",
    );
    assert.deepEqual(result.tags, ["a", "b"]);
  });

  it("removes a value from a checkbox-list array", () => {
    const result = updateModelValue(
      { tags: ["a", "b"] },
      { name: "tags" },
      false,
      "a",
    );
    assert.deepEqual(result.tags, ["b"]);
  });

  it("does not re-add an already-checked value", () => {
    const result = updateModelValue(
      { tags: ["a"] },
      { name: "tags" },
      true,
      "a",
    );
    assert.deepEqual(result.tags, ["a"]);
  });

  it("does not mutate the original object", () => {
    const original = { name: "John" };
    updateModelValue(original, { name: "name" }, "Jane");
    assert.equal(original.name, "John");
  });
});

// ---------------------------------------------------------------------------
// updateModelValue — dot-notation keys
// ---------------------------------------------------------------------------

describe("updateModelValue — dot-notation keys", () => {
  it("sets a one-level-deep nested field", () => {
    const result = updateModelValue(
      { address: { street: "Old St", city: "NYC" } },
      { name: "address.street" },
      "New St",
    );
    assert.equal(result.address.street, "New St");
  });

  it("preserves sibling keys at the nested level", () => {
    const result = updateModelValue(
      { address: { street: "Old St", city: "NYC" } },
      { name: "address.street" },
      "New St",
    );
    assert.equal(result.address.city, "NYC");
  });

  it("preserves top-level keys not on the path", () => {
    const result = updateModelValue(
      { name: "John", address: { street: "Old St" } },
      { name: "address.street" },
      "New St",
    );
    assert.equal(result.name, "John");
  });

  it("sets a two-levels-deep nested field", () => {
    const result = updateModelValue(
      { a: { b: { c: 1 } } },
      { name: "a.b.c" },
      99,
    );
    assert.equal(result.a.b.c, 99);
  });

  it("creates intermediate objects when the path does not exist", () => {
    const result = updateModelValue({}, { name: "address.street" }, "Main St");
    assert.equal(result.address.street, "Main St");
  });

  it("creates deeply nested intermediate objects", () => {
    const result = updateModelValue({}, { name: "a.b.c" }, "deep");
    assert.equal(result.a.b.c, "deep");
  });

  it("coerces number-type fields at a nested path", () => {
    const result = updateModelValue(
      { meta: { count: 0 } },
      { name: "meta.count", type: "number" },
      "7",
    );
    assert.strictEqual(result.meta.count, 7);
    assert.typeOf(result.meta.count, "number");
  });

  it("adds to a checkbox-list at a nested path", () => {
    const result = updateModelValue(
      { prefs: { tags: ["a"] } },
      { name: "prefs.tags" },
      true,
      "b",
    );
    assert.deepEqual(result.prefs.tags, ["a", "b"]);
  });

  it("removes from a checkbox-list at a nested path", () => {
    const result = updateModelValue(
      { prefs: { tags: ["a", "b"] } },
      { name: "prefs.tags" },
      false,
      "a",
    );
    assert.deepEqual(result.prefs.tags, ["b"]);
  });

  it("does not mutate the original object", () => {
    const original = { address: { street: "Old" } };
    updateModelValue(original, { name: "address.street" }, "New");
    assert.equal(original.address.street, "Old");
  });
});