const EVENT_SCHEMA = "event-log.v1";
const SNAPSHOT_SCHEMA = "snapshot.v1";

export function canonicalJson(value) {
  if (value === null || typeof value !== "object") return JSON.stringify(value);
  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
}

export function fnv1a64(value) {
  const bytes = new TextEncoder().encode(typeof value === "string" ? value : canonicalJson(value));
  let hash = 1469598103934665603n;
  for (const byte of bytes) {
    hash ^= BigInt(byte);
    hash = BigInt.asUintN(64, hash * 1099511628211n);
  }
  return `fnv1a64:${hash.toString(16).padStart(16, "0")}`;
}

function requireInteger(value, name) {
  if (!Number.isSafeInteger(value) || value < 0) throw new Error(`invalid_${name}`);
}

export class EventLog {
  constructor(events = []) {
    this.events = [];
    for (const event of events) this.append(event.seq, event.tick, event.kind, event.payload, event.payload_hash);
  }

  append(seq, tick, kind, payload = {}, expectedHash = undefined) {
    requireInteger(seq, "seq");
    requireInteger(tick, "tick");
    if (seq !== this.cursor + 1) throw new Error("event_sequence_gap");
    if (tick < this.tick) throw new Error("event_tick_regression");
    if (typeof kind !== "string" || kind.length === 0 || kind.length > 64) throw new Error("event_kind_invalid");
    const payloadHash = fnv1a64(payload);
    if (expectedHash !== undefined && expectedHash !== payloadHash) throw new Error("event_payload_hash_mismatch");
    const event = { seq, tick, kind, payload, payload_hash: payloadHash };
    this.events.push(event);
    return event;
  }

  get cursor() { return this.events.length === 0 ? 0 : this.events[this.events.length - 1].seq; }
  get tick() { return this.events.length === 0 ? 0 : this.events[this.events.length - 1].tick; }

  export() {
    return { schema: EVENT_SCHEMA, cursor: this.cursor, tick: this.tick, events: this.events.map((event) => ({ ...event })) };
  }

  static import(value) {
    if (!value || value.schema !== EVENT_SCHEMA || !Array.isArray(value.events)) throw new Error("event_log_schema");
    const log = new EventLog(value.events);
    if (log.cursor !== value.cursor || log.tick !== value.tick) throw new Error("event_log_cursor_mismatch");
    return log;
  }
}

export class SnapshotStore {
  constructor(snapshots = []) {
    this.snapshots = new Map();
    for (const snapshot of snapshots) this.importSnapshot(snapshot);
  }

  create(seq, tick, state, baseSnapshotId = null) {
    requireInteger(seq, "snapshot_seq");
    requireInteger(tick, "snapshot_tick");
    if (baseSnapshotId !== null && !this.snapshots.has(baseSnapshotId)) throw new Error("snapshot_base_missing");
    const stateHash = fnv1a64(state);
    const snapshot = {
      schema: SNAPSHOT_SCHEMA,
      snapshot_id: `snap:${seq}:${stateHash}`,
      base_snapshot_id: baseSnapshotId,
      seq,
      tick,
      state,
      state_hash: stateHash,
    };
    this.snapshots.set(snapshot.snapshot_id, snapshot);
    return snapshot;
  }

  importSnapshot(snapshot) {
    if (!snapshot || snapshot.schema !== SNAPSHOT_SCHEMA || typeof snapshot.snapshot_id !== "string") throw new Error("snapshot_schema");
    if (snapshot.base_snapshot_id !== null && !this.snapshots.has(snapshot.base_snapshot_id)) throw new Error("snapshot_base_missing");
    if (fnv1a64(snapshot.state) !== snapshot.state_hash) throw new Error("snapshot_hash_mismatch");
    if (snapshot.snapshot_id !== `snap:${snapshot.seq}:${snapshot.state_hash}`) throw new Error("snapshot_id_mismatch");
    this.snapshots.set(snapshot.snapshot_id, { ...snapshot });
    return snapshot;
  }

  latest() {
    return this.snapshots.size === 0 ? null : [...this.snapshots.values()][this.snapshots.size - 1];
  }

  export() {
    return { schema: SNAPSHOT_SCHEMA, snapshots: [...this.snapshots.values()].map((snapshot) => ({ ...snapshot })) };
  }
}

export class ReplayTimeline {
  constructor(value = null) {
    this.events = value ? EventLog.import(value.events) : new EventLog();
    this.snapshots = value ? new SnapshotStore(value.snapshots.snapshots) : new SnapshotStore();
  }

  appendEvent(seq, tick, kind, payload = {}) {
    return this.events.append(seq, tick, kind, payload);
  }

  checkpoint(seq, tick, state, baseSnapshotId = null) {
    return this.snapshots.create(seq, tick, state, baseSnapshotId);
  }

  replay(initialState, apply) {
    let state = initialState;
    for (const event of this.events.events) state = apply(state, event);
    return { state, state_hash: fnv1a64(state), cursor: this.events.cursor, tick: this.events.tick };
  }

  export() {
    return { events: this.events.export(), snapshots: this.snapshots.export() };
  }
}

export { EVENT_SCHEMA, SNAPSHOT_SCHEMA };