// Production sync runner — composes the live vault adapter, WebSocket
// transport, and coordinator into the function the dispatcher injects via
// `setSyncRunner`. The runner is responsible for opening one Noise KK
// session against a single paired device, driving the sync protocol, and
// surfacing a `SyncRunResult` (or throwing on failure). The dispatcher in
// sync-trigger.ts iterates over hosts and aggregates results.
//
// Connection strategy: dial the mesh's relay, trying each clock-skew
// rendezvous window in turn. There is one transport. LAN peer-to-peer sync is
// retired (docs/sync-lan-retirement.md), so there is no address cache, no
// subnet probe and no fallback ladder to reason about.
//
// We do NOT verify vault_id here — the coordinator's SYNC_HELLO exchange
// does that (returns `status: "vault_mismatch"` if the peer holds a
// different vault). The runner just translates the coordinator's outcome
// into the throw-or-return contract the dispatcher expects.

import { runSyncInitiator, type SyncVaultAdapter } from "./sync-coordinator";
import { createSyncVaultAdapter } from "./sync-vault-adapter";
import {
  openRelaySyncSession,
  type SyncSession,
  type SyncPeerIdentity,
} from "../shared/sync-transport";
import { hexToPubkey } from "../shared/sync-identity";
import { buildLocalIdentity, deriveLocalSyncKeypair } from "./device-identity";
import { constantTimeEqualHex } from "../shared/constant-time";
import { getRootKeyHex, isUnlocked } from "./vault";
import type { PairedDevice } from "../shared/sync-types";
import type { SyncRunResult } from "./sync-trigger";
import {
  dialingRendezvousIds,
  rendezvousSecretFromHex,
} from "../shared/rendezvous";
import { getSyncSettings, type SyncSettings } from "./sync-settings";

/**
 * Test/injection seam. Production wires in the real `openSyncSession`;
 * unit tests inject a fake to avoid real WebSocket + Noise KK.
 */
export interface SyncRunnerDeps {
  openRelaySession: (
    relayUrl: string,
    ourIdentity: SyncPeerIdentity,
    expectedRemoteHex: string,
    rendezvousId: string,
  ) => Promise<SyncSession>;
  getSyncSettings: () => Promise<SyncSettings>;
  createAdapter: (context?: { deviceName?: string }) => SyncVaultAdapter;
}

const productionDeps: SyncRunnerDeps = {
  openRelaySession: (relayUrl, identity, expected, rendezvousId) =>
    openRelaySyncSession(relayUrl, identity, expected, rendezvousId),
  getSyncSettings,
  createAdapter: (context) => createSyncVaultAdapter(context),
};

export async function productionSyncRunner(device: PairedDevice): Promise<SyncRunResult> {
  return runWithDeps(device, productionDeps);
}

/**
 * Inner runner with explicit deps — exported so tests can inject fakes.
 */
export async function runWithDeps(
  device: PairedDevice,
  deps: SyncRunnerDeps,
): Promise<SyncRunResult> {
  if (!isUnlocked()) return { ok: false, error: "VAULT_LOCKED" };
  if (!device.longTermPublicKeyHex) {
    throw new Error("paired_device_missing_pubkey");
  }
  if (!device.rendezvousSecretHex) {
    throw new Error("paired_device_missing_rendezvous_secret");
  }
  const expectedRemoteHex = device.longTermPublicKeyHex;
  const reconnectIds = dialingRendezvousIds(
    rendezvousSecretFromHex(device.rendezvousSecretHex),
    Date.now() / 1000,
  );
  // Sync identity derives from the stable root key, not the password-derived
  // key. Reconnect uses both halves directly in standard Noise KK.
  const masterKeyHex = getRootKeyHex();
  if (!masterKeyHex) return { ok: false, error: "VAULT_LOCKED" };
  const masterKey = hexToBytesLocal(masterKeyHex);
  const publicIdentity = await buildLocalIdentity(masterKey);
  const localKeys = deriveLocalSyncKeypair(masterKey, publicIdentity.deviceId);
  if (!constantTimeEqualHex(
    publicIdentity.longTermPublicKeyHex,
    bytesToHex(localKeys.publicKey),
  )) {
    masterKey.fill(0);
    localKeys.secretKey.fill(0);
    throw new Error("derived reconnect identity mismatch");
  }
  const ourIdentity: SyncPeerIdentity = {
    ...publicIdentity,
    longTermPrivateKey: localKeys.secretKey,
  };

  // Sanity — the remote pubkey must be 32-byte hex so noise can compare it.
  void hexToPubkey(expectedRemoteHex);

  // HV-1b: pass the peer being synced so remote-mutation alerts can name it.
  const adapter = deps.createAdapter({ deviceName: device.deviceName });
  let session: SyncSession;
  try {
    const settings = await deps.getSyncSettings();
    if (settings.mode === "off") throw new Error("sync_disabled");
    session = await connectRelay(
      device.relayUrl ?? settings.relayUrl,
      expectedRemoteHex,
      ourIdentity,
      reconnectIds,
      deps.openRelaySession,
    );
  } finally {
    masterKey.fill(0);
    localKeys.secretKey.fill(0);
  }

  try {
    const outcome = await runSyncInitiator(session, adapter);
    if (outcome.status === "completed") {
      return {
        ok: true,
        entriesReceived: outcome.entriesReceived,
        entriesSent: outcome.entriesSent,
      };
    }
    if (outcome.status === "vault_mismatch") {
      throw new Error("vault_id_mismatch");
    }
    if (outcome.status === "timeout") {
      throw new Error("sync_timeout");
    }
    throw new Error(outcome.error ?? "sync_errored");
  } finally {
    // The coordinator does NOT close the session (it returns and leaves the
    // session open). This runner is the sole owner of session lifetime.
    await session.close().catch(() => undefined);
  }
}

async function connectRelay(
  relayUrl: string,
  expectedRemoteHex: string,
  ourIdentity: SyncPeerIdentity,
  rendezvousIds: string[],
  openRelaySession: SyncRunnerDeps["openRelaySession"],
): Promise<SyncSession> {
  let lastError: unknown;
  for (const rendezvousId of rendezvousIds) {
    try {
      return await openRelaySession(
        relayUrl,
        ourIdentity,
        expectedRemoteHex,
        rendezvousId,
      );
    } catch (error) {
      lastError = error;
    }
  }
  const detail = lastError instanceof Error ? lastError.message : "unreachable";
  throw new Error(`relay_sync_failed:${detail}`);
}

function hexToBytesLocal(hex: string): Uint8Array {
  const out = new Uint8Array(hex.length / 2);
  for (let i = 0; i < out.length; i++) {
    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
  }
  return out;
}

function bytesToHex(bytes: Uint8Array): string {
  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
}