import {
  expect,
  it,
  mock,
} from "https://code.thunderk.net/typescript/devtools/raw/1.2.2/testing.ts";
import { Serializer } from "./serializer.ts";

class TestSerializerObj1 {
  a: number;
  constructor(a = 0) {
    this.a = a;
  }
}

class TestSerializerObj2 {
  a = () => 1;
  b = [(obj: any) => 2];
}

class TestSerializerObj3 {
  a = [1, 2];
  postUnserialize() {
    this.a.push(3);
  }
}

class TestSerializerObj4 extends TestSerializerObj1 {
}

const TEST_NS = {
  TestSerializerObj1,
  TestSerializerObj2,
  TestSerializerObj3,
};

const TEST_NS_FLAT = [
  TestSerializerObj1,
  TestSerializerObj2,
  TestSerializerObj3,
];

const TEST_NS_RENAME = {
  ob1: TestSerializerObj1,
  ob2: TestSerializerObj2,
  ob3: TestSerializerObj3,
};

function checkReversability(
  obj: any,
  namespace: any = TEST_NS,
  equality?: (loaded: any, orig: any) => void,
): any {
  var serializer = new Serializer(namespace);
  var data = serializer.serialize(obj);
  serializer = new Serializer(namespace);
  var loaded = serializer.unserialize(data);
  if (equality) {
    equality(loaded, obj);
  } else {
    expect(loaded).toEqual(obj);
  }
  return loaded;
}

it("serializes simple objects", () => {
  var obj = {
    "a": 5,
    "b": null,
    "c": [{ "a": 2 }, "test"],
    "d": new Set([1, 4]),
    "e": new Map([["z", 8], ["t", 2]]),
  };
  const result = checkReversability(obj);
  expect(result["a"]).toBe(5);
  expect(result["b"]).toBe(null);
  expect(result["c"][0]["a"]).toBe(2);
  expect(result["d"].has(1)).toBe(true);
  expect(result["d"].has(2)).toBe(false);
  expect(result["e"].get("z")).toBe(8);
  expect(result["e"].get("k")).toBeUndefined();
});

it("restores objects constructed from class", () => {
  let loaded = checkReversability(new TestSerializerObj1(5));
  expect(loaded.a).toBe(5);
  expect(loaded).toBeInstanceOf(TestSerializerObj1);

  loaded = checkReversability(new TestSerializerObj1(5), TEST_NS_FLAT);
  expect(loaded.a).toBe(5);
  expect(loaded).toBeInstanceOf(TestSerializerObj1);

  loaded = checkReversability(new TestSerializerObj1(5), TEST_NS_RENAME);
  expect(loaded.a).toBe(5);
  expect(loaded).toBeInstanceOf(TestSerializerObj1);
});

it("stores one version of the same object", () => {
  var a = new TestSerializerObj1(8);
  var b = new TestSerializerObj1(8);
  var c = {
    "r": a,
    "s": ["test", a],
    "t": a,
    "u": b,
  };
  var loaded = checkReversability(c);
  expect(loaded.t).toBe(loaded.r);
  expect(loaded.s[1]).toBe(loaded.r);
  expect(loaded.u).not.toBe(loaded.r);
});

it("handles circular references", () => {
  var a: any = { b: {} };
  a.b.c = a;

  checkReversability(a, undefined, (loaded) => {
    expect(Object.keys(loaded)).toEqual(["b"]);
    expect(Object.keys(loaded.b)).toEqual(["c"]);
    expect(Object.keys(loaded.b.c)).toEqual(["b"]);
    expect(Object.keys(loaded.b.c.b)).toEqual(["c"]);
    expect(loaded.b.c).toBe(loaded);
    expect(loaded.b.c.b).toBe(loaded.b);
  });
});

it("ignores some classes", () => {
  let serializer = new Serializer(TEST_NS);
  serializer.addIgnoredClass("TestSerializerObj1");

  let data = serializer.serialize({ a: 5, b: new TestSerializerObj1() });
  let loaded = serializer.unserialize(data);

  expect(loaded).toEqual({ a: 5, b: undefined });

  serializer = new Serializer(TEST_NS);
  serializer.addIgnoredClass(TestSerializerObj1);

  data = serializer.serialize({ a: 5, b: new TestSerializerObj1() });
  loaded = serializer.unserialize(data);

  expect(loaded).toEqual({ a: 5, b: undefined });

  serializer = new Serializer(TEST_NS_RENAME);
  serializer.addIgnoredClass(TestSerializerObj1);

  data = serializer.serialize({ a: 5, b: new TestSerializerObj1() });
  loaded = serializer.unserialize(data);

  expect(loaded).toEqual({ a: 5, b: undefined });
});

it("ignores functions", () => {
  let serializer = new Serializer(TEST_NS);
  let data = serializer.serialize({ obj: new TestSerializerObj2() });
  let loaded = serializer.unserialize(data);

  let expected = <any> new TestSerializerObj2();
  expected.a = undefined;
  expected.b[0] = undefined;
  expect(loaded).toEqual({ obj: expected });
});

it("calls specific postUnserialize", () => {
  let serializer = new Serializer(TEST_NS);
  let data = serializer.serialize({ obj: new TestSerializerObj3() });
  let loaded = serializer.unserialize(data);

  let expected = new TestSerializerObj3();
  expected.a = [1, 2, 3];
  expect(loaded).toEqual({ obj: expected });
});

it("handles missing classes", () => {
  mock(console, "error", undefined, (mock_error) => {
    let serializer = new Serializer(TEST_NS);
    let data = serializer.serialize({ obj: new TestSerializerObj4() });
    let loaded = serializer.unserialize(data);
    expect(loaded).toEqual({ obj: { a: 0 } });
    expect(mock_error).toHaveBeenCalledWith(
      "Can't find class",
      "TestSerializerObj4",
    );
  });
});

it("uses namespace alias to protect from property mangling", () => {
  const data = {
    a: new TestSerializerObj1(1),
    b: new TestSerializerObj1(2),
    c: [new TestSerializerObj1(3)],
  };

  const serializer1 = new Serializer(TEST_NS);
  const serializer2 = new Serializer(TEST_NS_RENAME);

  const dumped1 = serializer1.serialize(data);
  const dumped2 = serializer2.serialize(data);

  expect(dumped1.length).toBeGreaterThan(dumped2.length);

  expect(serializer1.unserialize(dumped1)).toEqual(data);
  expect(serializer2.unserialize(dumped2)).toEqual(data);
});