import { assert } from "chai";
import { describe, it, test } from "vitest";

import { dottedGet, dottedSet } from "../../functions/dotted_get";

describe("dottedGet", () => {
  it("correctly handles various objects", () => {
    const testObject = {
      A: {
        A1: {
          A1a: undefined,
          A1b: null,
          A1c: NaN,
          A1d: 0,
          A1e: "",
          A1f: false,
          A1g: true,
          A1h: "foo",
          A1i: 1,
          A1j: Infinity,
          A1k: [undefined, null, NaN, 0, "", false, true, "foo", 1, Infinity],
        },
        A2: undefined,
        A3: null,
        A4: NaN,
        A5: 0,
        A6: "",
        A7: false,
        A8: true,
        A9: "foo",
        A10: 1,
        A11: Infinity,
        A12: [undefined, null, NaN, 0, "", false, true, "foo", 1, Infinity],
      },
      B: undefined,
      C: null,
      D: NaN,
      E: 0,
      F: "",
      G: false,
      H: true,
      I: "foo",
      J: 1,
      K: Infinity,
      L: [undefined, null, NaN, 0, "", false, true, "foo", 1, Infinity],
    };

    assert(Object.keys(dottedGet(testObject, "A")).includes("A1"));
    assert(Object.keys(dottedGet(testObject, "A.A1")).includes("A1a"));
    assert.isUndefined(dottedGet(testObject, "A.A1.A1a"));
    assert.isNull(dottedGet(testObject, "A.A1.A1b"));
    assert.isNaN(dottedGet(testObject, "A.A1.A1c"));
    assert.equal(dottedGet(testObject, "A.A1.A1d"), 0);
    assert.equal(dottedGet(testObject, "A.A1.A1e"), "");
    assert.isFalse(dottedGet(testObject, "A.A1.A1f"));
    assert.isTrue(dottedGet(testObject, "A.A1.A1g"));
    assert.equal(dottedGet(testObject, "A.A1.A1h"), "foo");
    assert.equal(dottedGet(testObject, "A.A1.A1i"), 1);
    assert.equal(dottedGet(testObject, "A.A1.A1j"), Infinity);
    assert.isArray(dottedGet(testObject, "A.A1.A1k"));
    assert.isUndefined(dottedGet(testObject, "A.A1.A1k.0"));
    assert.isNull(dottedGet(testObject, "A.A1.A1k.1"));
    assert.isNaN(dottedGet(testObject, "A.A1.A1k.2"));
    assert.equal(dottedGet(testObject, "A.A1.A1k.3"), 0);
    assert.equal(dottedGet(testObject, "A.A1.A1k.4"), "");
    assert.isFalse(dottedGet(testObject, "A.A1.A1k.5"));
    assert.isTrue(dottedGet(testObject, "A.A1.A1k.6"));
    assert.equal(dottedGet(testObject, "A.A1.A1k.7"), "foo");
    assert.equal(dottedGet(testObject, "A.A1.A1k.8"), 1);
    assert.equal(dottedGet(testObject, "A.A1.A1k.9"), Infinity);
    assert.isUndefined(dottedGet(testObject, "A.A2"));
    assert.isNull(dottedGet(testObject, "A.A3"));
    assert.isNaN(dottedGet(testObject, "A.A4"));
    assert.equal(dottedGet(testObject, "A.A5"), 0);
    assert.equal(dottedGet(testObject, "A.A6"), "");
    assert.isFalse(dottedGet(testObject, "A.A7"));
    assert.isTrue(dottedGet(testObject, "A.A8"));
    assert.equal(dottedGet(testObject, "A.A9"), "foo");
    assert.equal(dottedGet(testObject, "A.A10"), 1);
    assert.equal(dottedGet(testObject, "A.A11"), Infinity);
    assert.isArray(dottedGet(testObject, "A.A12"));
    assert.isUndefined(dottedGet(testObject, "A.A12.0"));
    assert.isNull(dottedGet(testObject, "A.A12.1"));
    assert.isNaN(dottedGet(testObject, "A.A12.2"));
    assert.equal(dottedGet(testObject, "A.A12.3"), 0);
    assert.equal(dottedGet(testObject, "A.A12.4"), "");
    assert.isFalse(dottedGet(testObject, "A.A12.5"));
    assert.isTrue(dottedGet(testObject, "A.A12.6"));
    assert.equal(dottedGet(testObject, "A.A12.7"), "foo");
    assert.equal(dottedGet(testObject, "A.A12.8"), 1);
    assert.equal(dottedGet(testObject, "A.A12.9"), Infinity);
    assert.isUndefined(dottedGet(testObject, "B"));
    assert.isNull(dottedGet(testObject, "C"));
    assert.isNaN(dottedGet(testObject, "D"));
    assert.equal(dottedGet(testObject, "E"), 0);
    assert.equal(dottedGet(testObject, "F"), "");
    assert.isFalse(dottedGet(testObject, "G"));
    assert.isTrue(dottedGet(testObject, "H"));
    assert.equal(dottedGet(testObject, "I"), "foo");
    assert.equal(dottedGet(testObject, "J"), 1);
    assert.equal(dottedGet(testObject, "K"), Infinity);
    assert.isArray(dottedGet(testObject, "L"));
    assert.isUndefined(dottedGet(testObject, "L.0"));
    assert.isNull(dottedGet(testObject, "L.1"));
    assert.isNaN(dottedGet(testObject, "L.2"));
    assert.equal(dottedGet(testObject, "L.3"), 0);
    assert.equal(dottedGet(testObject, "L.4"), "");
    assert.isFalse(dottedGet(testObject, "L.5"));
    assert.isTrue(dottedGet(testObject, "L.6"));
    assert.equal(dottedGet(testObject, "L.7"), "foo");
    assert.equal(dottedGet(testObject, "L.8"), 1);
    assert.equal(dottedGet(testObject, "L.9"), Infinity);
    assert.isUndefined(dottedGet(testObject, "A.A1.A1a.foo.bar.baz"));
    assert.isUndefined(dottedGet(testObject, "A.A1.A1a.foo.bar"));
    assert.isUndefined(dottedGet(testObject, "A.A1.A1a.foo"));

    assert.isUndefined(dottedGet(testObject, "A.A1.A1b.foo"));
    assert.isUndefined(dottedGet(testObject, "A.A1.A1c.foo"));
    assert.isUndefined(dottedGet(testObject, "A.A1.A1d.foo"));
    assert.isUndefined(dottedGet(testObject, "A.A1.A1e.foo"));
    assert.isUndefined(dottedGet(testObject, "A.A1.A1f.foo"));

    assert.isUndefined(dottedGet(testObject, "A.A1.A1g.foo"));
    assert.isUndefined(dottedGet(testObject, "A.A1.A1h.foo"));
    assert.isUndefined(dottedGet(testObject, "A.A1.A1i.foo"));
    assert.isUndefined(dottedGet(testObject, "A.A1.A1j.foo"));
    assert.isUndefined(dottedGet(testObject, "A.A1.A1k.foo"));
    assert.throw(() => dottedGet(testObject, "A.A1.A1k.10"));
    assert.isUndefined(dottedGet(testObject, "A.A13"));
    assert.isUndefined(dottedGet(testObject, "M"));
  });
  test("get pass", () => {
    assert.equal(dottedGet({ a: 1, b: 2 }, "a"), 1);
    assert.equal(dottedGet({ a: 1, b: 2 }, "b"), 2);
    assert.deepEqual(dottedGet({ a: { c: 3 }, b: { d: 4 } }, "a"), { c: 3 });
    assert.deepEqual(dottedGet({ a: { c: 3 }, b: { d: 4 } }, "b"), { d: 4 });
    assert.deepEqual(dottedGet({ a: { c: 3 }, b: { d: 4 } }, "a.c"), 3);
    assert.deepEqual(dottedGet({ a: { c: 3 }, b: { d: 4 } }, "b.d"), 4);
    assert.equal(dottedGet({ a: [1], b: [2] }, "a.0"), 1);
    assert.equal(dottedGet({ a: [1], b: [2] }, "b.0"), 2);
    assert.equal(dottedGet({ a: [1, 3], b: [2, 4] }, "a.1"), 3);
    assert.equal(dottedGet({ a: [1, 3], b: [2, 4] }, "b.1"), 4);
    assert.equal(dottedGet({ a: [{ c: 3 }], b: [{ d: 4 }] }, "a.0.c"), 3);
    assert.equal(dottedGet({ a: [{ c: 3 }], b: [{ d: 4 }] }, "b.0.d"), 4);
  });
  test("get fail", () => {
    assert.equal(dottedGet({ a: { b: { c: 1 } } }, "b"), undefined);
    assert.equal(dottedGet({ a: { b: { c: 1 } } }, "a.c"), undefined);
    assert.equal(dottedGet({ a: { b: { c: 1 } } }, "a.c.e"), undefined);
    assert.throws(() => dottedGet({ a: [1, 2, 3] }, "a.4"));
    assert.throws(() => dottedGet({ a: [1, 2, 3] }, "a.-1"));
  });
});

describe("dottedSet", () => {
  it("can assign values with a dot path", () => {
    const object = { a: 1, b: { c: 2 } };
    dottedSet(object, "b.c", 3);
    assert.equal(object.b.c, 3);
  });
  it("can assign top level values", () => {
    const object = { a: 1, b: { c: 2 } };
    dottedSet(object, "a", 3);
    assert.equal(object.a, 3);
  });
  it("will create sub objects", () => {
    const object = { a: 1, b: { c: 2 } };
    dottedSet(object, "d.e.f", 3);
    assert.equal(object.d.e.f, 3);
  });
  test("set pass", () => {
    const obj = {
      a: 1,
      b: { a: 2, b: 3, c: 4 },
      c: [5, 6, 7],
      d: [{ a: 1 }, { b: 2 }],
    };
    dottedSet(obj, "a", 2);
    assert.equal(obj.a, 2);

    dottedSet(obj, "b.a", 3);
    assert.equal(obj.b.a, 3);

    dottedSet(obj, "c.1", 7);
    assert.equal(obj.c[1], 7);

    dottedSet(obj, "d.1.a", 2);
    assert.equal(obj.d[1].a, 2);
  });
  test("set missing", () => {
    const obj: any = {
      a: 1,
      b: { a: 2, b: 3, c: 4 },
      c: [5, 6, 7],
      d: [{ a: 1 }, { b: 2 }],
    };
    dottedSet(obj, "e", 2);
    assert.equal(obj.e, 2);

    dottedSet(obj, "b.d", 3);
    assert.equal(obj.b.d, 3);

    dottedSet(obj, "c.3", 7);
    assert.equal(obj.c[3], 7);

    dottedSet(obj, "d.0.b", 2);
    assert.equal(obj.d[0].b, 2);

    dottedSet(obj, "f.0", 2);
    assert.equal(obj.f[0], 2);

    dottedSet(obj, "g.a.a.a.a", 2);
    assert.equal(obj.g.a.a.a.a, 2);
  });
  test("set fail", () => {
    const obj: any = {
      a: 1,
      b: { a: 2 },
      c: [5, 6, 7],
      d: [{ a: 1 }, { b: 2 }],
    };
    // assert.throws(() => dottedSet(obj, "0", 2));
    assert.throws(() => dottedSet(obj, "a.0", 2));
    assert.throws(() => dottedSet(obj, "a.b", 2));
    // assert.throws(() => dottedSet(obj, "b.b.b", 2)); // this is ok
    assert.throws(() => dottedSet(obj, "c.10", 2));
    // assert.throws(() => dottedSet(obj, "d.0.c", 2)); // this is ok
    assert.throws(() => dottedSet(obj, "d.3.c", 2));
  });
});