import assert from "node:assert/strict";
import test from "node:test";
import * as Automerge from "@automerge/automerge";
import {
  createAutomergeFieldValue,
  encodeAutomergeFieldWrite,
  isAutomergeFieldDoc,
  loadAutomergeFieldDoc,
  materializeAutomergeFieldValue,
  mergeAutomergeFieldValues,
  saveAutomergeFieldDoc,
} from "../src/crdt-automerge.js";

const type = "camino.CrdtJson";

test("Automerge CRDT fields explicitly create stored envelopes", () => {
  const stored = createAutomergeFieldValue({ title: "draft" }, type);

  assert.equal(stored.$caminoCrdtType, type);
  assert.equal(stored.$caminoCrdtEncoding, "base64");
  assert.deepEqual(materializeAutomergeFieldValue(stored, type), {
    title: "draft",
  });
});

test("Automerge CRDT field writes reject plain values", () => {
  assert.throws(
    () => encodeAutomergeFieldWrite({ title: "draft" }, type),
    /CRDT field writes must use an Automerge document/,
  );
});

test("Automerge CRDT fields encode rehydrated docs for writes", () => {
  const base = loadAutomergeFieldDoc(
    createAutomergeFieldValue({ title: "draft" }, type),
    type,
  );
  const changed = Automerge.change(base, (doc) => {
    (doc.value as { title: string }).title = "edited";
  });

  assert.equal(isAutomergeFieldDoc(changed), true);

  const stored = encodeAutomergeFieldWrite(changed, type);

  assert.deepEqual(materializeAutomergeFieldValue(stored, type), {
    title: "edited",
  });
});

test("Automerge CRDT fields merge divergent saved documents", () => {
  const base = loadAutomergeFieldDoc(
    createAutomergeFieldValue({ left: false, right: false }, type),
    type,
  );
  const left = Automerge.change(Automerge.clone(base, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), (doc) => {
    (doc.value as { left: boolean }).left = true;
  });
  const right = Automerge.change(Automerge.clone(base, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"), (doc) => {
    (doc.value as { right: boolean }).right = true;
  });

  const result = mergeAutomergeFieldValues({
    existing: saveAutomergeFieldDoc(left, type),
    incoming: saveAutomergeFieldDoc(right, type),
    type,
  });

  assert.deepEqual(result.materialized, { left: true, right: true });
  assert.deepEqual(materializeAutomergeFieldValue(result.stored, type), {
    left: true,
    right: true,
  });
});