import test from "node:test";
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";

test("auto-sync establishes the initial data baseline before debouncing edits", () => {
  const source = readFileSync(new URL("./useAutoSync.ts", import.meta.url), "utf8");
  const baselineCommentIndex = source.indexOf("Establish the initial baseline immediately");
  const baselineHelperIndex = source.indexOf("const establishInitialBaseline = () =>", baselineCommentIndex);
  const initializedAssignmentIndex = source.indexOf("isInitializedRef.current = true;", baselineHelperIndex);
  const hashReadIndex = source.indexOf("const currentHash = await getDataHash();", baselineHelperIndex);
  const initializationGuardIndex = source.indexOf("if (!isInitializedRef.current)", baselineCommentIndex);
  const baselineCallIndex = source.indexOf("establishInitialBaseline();", initializationGuardIndex);
  const debounceCommentIndex = source.indexOf("Debounce first, then build the expensive full-data hash", initializationGuardIndex);
  const debounceTimerIndex = source.indexOf("syncTimeoutRef.current = setTimeout", debounceCommentIndex);

  assert.notEqual(baselineCommentIndex, -1);
  assert.notEqual(baselineHelperIndex, -1);
  assert.notEqual(initializationGuardIndex, -1);
  assert.notEqual(initializedAssignmentIndex, -1);
  assert.notEqual(hashReadIndex, -1);
  assert.notEqual(baselineCallIndex, -1);
  assert.notEqual(debounceCommentIndex, -1);
  assert.notEqual(debounceTimerIndex, -1);
  assert.ok(
    initializedAssignmentIndex < hashReadIndex,
    "initialization must be marked synchronously before reading the baseline hash",
  );
  assert.ok(
    baselineCallIndex < debounceTimerIndex,
    "the first baseline hash must be captured before scheduling the debounced auto-sync timer",
  );
});

test("paused convergent sync captures a baseline before returning", () => {
  const source = readFileSync(new URL("./useAutoSync.ts", import.meta.url), "utf8");
  const effectIndex = source.indexOf("// Debounced auto-sync when data changes");
  const pausedGuardIndex = source.indexOf("if (convergentSyncPaused)", effectIndex);
  const initializationGuardIndex = source.indexOf("if (!isInitializedRef.current)", pausedGuardIndex);
  const baselineCallIndex = source.indexOf("establishInitialBaseline();", initializationGuardIndex);
  const pausedReturnIndex = source.indexOf("return () =>", baselineCallIndex);

  assert.notEqual(pausedGuardIndex, -1);
  assert.notEqual(initializationGuardIndex, -1);
  assert.notEqual(baselineCallIndex, -1);
  assert.notEqual(pausedReturnIndex, -1);
  assert.ok(
    pausedGuardIndex < initializationGuardIndex
      && initializationGuardIndex < baselineCallIndex
      && baselineCallIndex < pausedReturnIndex,
    "paused mode must preserve the pre-edit baseline before suppressing network sync",
  );
});

test("an unchanged remote check cannot absorb an existing paused-edit baseline", () => {
  const source = readFileSync(new URL("./useAutoSync.ts", import.meta.url), "utf8");
  const baselineSnapshotIndex = source.indexOf("const hadInitialBaseline = isInitializedRef.current");
  const remoteChangeIndex = source.indexOf("inspectedRemoteChange = true", baselineSnapshotIndex);
  const guardedUpdateIndex = source.indexOf(
    "if (markCurrentDataSynced && (!hadInitialBaseline || inspectedRemoteChange))",
    remoteChangeIndex,
  );

  assert.notEqual(baselineSnapshotIndex, -1);
  assert.notEqual(remoteChangeIndex, -1);
  assert.notEqual(guardedUpdateIndex, -1);
  assert.ok(
    baselineSnapshotIndex < remoteChangeIndex && remoteChangeIndex < guardedUpdateIndex,
    "remote inspection must preserve an existing baseline unless it reconciled changed cloud data",
  );
});

test("enabled convergent remote checks use the CRDT runtime before legacy inspection", () => {
  const source = readFileSync(new URL("./useAutoSync.ts", import.meta.url), "utf8");
  const checkIndex = source.indexOf("const checkRemoteVersion = useCallback");
  const convergentGuardIndex = source.indexOf(
    "if (currentConvergentConfig.initialized && currentConvergentConfig.enabled)",
    checkIndex,
  );
  const convergentSyncIndex = source.indexOf(
    "syncNowRef.current({ notifyOnFailure, allowEmptyConvergentSync })",
    convergentGuardIndex,
  );
  const legacyInspectionIndex = source.indexOf(
    "manager.inspectProviderRemote(connectedProvider)",
    convergentSyncIndex,
  );

  assert.notEqual(checkIndex, -1);
  assert.notEqual(convergentGuardIndex, -1);
  assert.notEqual(convergentSyncIndex, -1);
  assert.notEqual(legacyInspectionIndex, -1);
  assert.ok(
    convergentGuardIndex < convergentSyncIndex && convergentSyncIndex < legacyInspectionIndex,
    "v2 checks must return through the CRDT runtime before the legacy snapshot inspector",
  );
});

test("enabled convergent startup checks preview empty-vault recovery before syncing", () => {
  const source = readFileSync(new URL("./useAutoSync.ts", import.meta.url), "utf8");
  const convergentGuardIndex = source.indexOf(
    "if (currentConvergentConfig.initialized && currentConvergentConfig.enabled)",
  );
  const previewIndex = source.indexOf("manager.previewConvergentRecovery()", convergentGuardIndex);
  const recoveryPromptIndex = source.indexOf(
    "requestEmptyVaultRecovery(recoveryPayload)",
    previewIndex,
  );
  const cloudWinsIndex = source.indexOf(
    "conflictActionOverride: 'download-remote'",
    recoveryPromptIndex,
  );
  const manualTriggerIndex = source.indexOf("trigger: 'manual'", recoveryPromptIndex);
  const normalSyncIndex = source.indexOf(
    "syncNowRef.current({ notifyOnFailure, allowEmptyConvergentSync })",
    cloudWinsIndex,
  );

  assert.notEqual(convergentGuardIndex, -1);
  assert.notEqual(previewIndex, -1);
  assert.notEqual(recoveryPromptIndex, -1);
  assert.notEqual(cloudWinsIndex, -1);
  assert.notEqual(manualTriggerIndex, -1);
  assert.notEqual(normalSyncIndex, -1);
  assert.ok(
    convergentGuardIndex < previewIndex
      && previewIndex < recoveryPromptIndex
      && recoveryPromptIndex < manualTriggerIndex
      && manualTriggerIndex < cloudWinsIndex
      && cloudWinsIndex < normalSyncIndex,
    "v2 startup must offer recovery and use cloud-wins before the normal CRDT sync path",
  );
});

test("empty-vault recovery restore bypasses the auto-sync preference gate", () => {
  const source = readFileSync(new URL("./useAutoSync.ts", import.meta.url), "utf8");
  const recoveryPromptIndex = source.indexOf("requestEmptyVaultRecovery(recoveryPayload)");
  const restoreCallIndex = source.indexOf("syncNowRef.current({", recoveryPromptIndex);
  const triggerIndex = source.indexOf("trigger: 'manual'", restoreCallIndex);
  const conflictIndex = source.indexOf(
    "conflictActionOverride: 'download-remote'",
    restoreCallIndex,
  );
  const callEndIndex = source.indexOf("});", conflictIndex);

  assert.notEqual(recoveryPromptIndex, -1);
  assert.notEqual(restoreCallIndex, -1);
  assert.notEqual(triggerIndex, -1);
  assert.notEqual(conflictIndex, -1);
  assert.ok(
    restoreCallIndex < triggerIndex
      && triggerIndex < conflictIndex
      && conflictIndex < callEndIndex,
    "recovery Restore must pass trigger:manual so disabled auto-sync cannot block it",
  );
});

test("empty v2 startup checks allow a validated empty sync to open the gate", () => {
  const source = readFileSync(new URL("./useAutoSync.ts", import.meta.url), "utf8");
  const convergentGuardIndex = source.indexOf(
    "if (currentConvergentConfig.initialized && currentConvergentConfig.enabled)",
  );
  const replicaIndex = source.indexOf("manager.loadConvergentReplica()", convergentGuardIndex);
  const emptyDecisionIndex = source.indexOf("allowEmptyConvergentSync = (", replicaIndex);
  const syncIndex = source.indexOf(
    "syncNowRef.current({ notifyOnFailure, allowEmptyConvergentSync })",
    emptyDecisionIndex,
  );
  const guardIndex = source.indexOf(
    "options?.allowEmptyConvergentSync !== true",
    source.indexOf("const syncNow = useCallback"),
  );

  assert.notEqual(replicaIndex, -1);
  assert.notEqual(emptyDecisionIndex, -1);
  assert.notEqual(syncIndex, -1);
  assert.notEqual(guardIndex, -1);
  assert.ok(replicaIndex < emptyDecisionIndex && emptyDecisionIndex < syncIndex);
});

test("auto-sync skips only the exact remote-applied data hash", () => {
  const source = readFileSync(new URL("./useAutoSync.ts", import.meta.url), "utf8");
  const helperIndex = source.indexOf("const getSyncPayloadDataHash = (payload: SyncPayload): string");
  const skipRefIndex = source.indexOf("const skipNextSyncHashRef = useRef<string | null>(null)");
  const assignmentIndex = source.indexOf("skipNextSyncHashRef.current = getSyncPayloadDataHash(remotePayload)");
  const debounceTimerIndex = source.indexOf("syncTimeoutRef.current = setTimeout", assignmentIndex);
  const skipHashIndex = source.indexOf("const skipHash = skipNextSyncHashRef.current", debounceTimerIndex);
  const decisionIndex = source.indexOf("resolveAutoSyncHashDecision({", skipHashIndex);
  const appliedSkipIndex = source.indexOf("appliedSkipHash: skipHash", decisionIndex);
  const syncingGuardIndex = source.indexOf("if (sync.isSyncing || isSyncRunningRef.current)", decisionIndex);
  const restoreGuardIndex = source.indexOf("if (isRestoreInProgress())", decisionIndex);
  const interruptedGuardIndex = source.indexOf("if (readInterruptedVaultApply())", decisionIndex);
  const syncNowIndex = source.indexOf("const didSync = await syncNow();", interruptedGuardIndex);
  const didSyncGuardIndex = source.indexOf("if (didSync && skipHash !== null", syncNowIndex);
  const clearAfterSyncIndex = source.indexOf("skipNextSyncHashRef.current = null;", didSyncGuardIndex);
  const booleanSkipIndex = source.indexOf("skipNextSyncRef");

  assert.notEqual(helperIndex, -1);
  assert.notEqual(skipRefIndex, -1);
  assert.notEqual(assignmentIndex, -1);
  assert.notEqual(debounceTimerIndex, -1);
  assert.notEqual(skipHashIndex, -1);
  assert.notEqual(decisionIndex, -1);
  assert.notEqual(appliedSkipIndex, -1);
  assert.notEqual(syncingGuardIndex, -1);
  assert.notEqual(restoreGuardIndex, -1);
  assert.notEqual(interruptedGuardIndex, -1);
  assert.notEqual(syncNowIndex, -1);
  assert.notEqual(didSyncGuardIndex, -1);
  assert.notEqual(clearAfterSyncIndex, -1);
  assert.equal(booleanSkipIndex, -1);
  assert.ok(
    skipHashIndex < decisionIndex,
    "remote-apply skip must pass through the hash decision helper before suppressing a sync",
  );
  assert.ok(
    interruptedGuardIndex < syncNowIndex && syncNowIndex < clearAfterSyncIndex,
    "remote-apply skip hash must survive temporary sync blockers and clear only after a successful sync",
  );
});

test("auto syncNow and debounce re-check manager autoSyncEnabled before pushing", () => {
  const source = readFileSync(new URL("./useAutoSync.ts", import.meta.url), "utf8");
  const helperIndex = source.indexOf("function isPersistedAutoSyncEnabled");
  const syncNowIndex = source.indexOf("const syncNow = useCallback");
  const autoGateIndex = source.indexOf(
    "if (trigger === 'auto' && !isPersistedAutoSyncEnabled(manager.getState().autoSyncEnabled))",
    syncNowIndex,
  );
  const debounceIndex = source.indexOf("// Debounced auto-sync when data changes");
  const fireTimeGateIndex = source.indexOf(
    "if (!isPersistedAutoSyncEnabled(manager.getState().autoSyncEnabled))",
    debounceIndex,
  );
  const clearTimerIndex = source.indexOf(
    "if (syncTimeoutRef.current) {\n        clearTimeout(syncTimeoutRef.current);\n        syncTimeoutRef.current = null;\n      }\n      return;",
    debounceIndex,
  );

  assert.notEqual(helperIndex, -1);
  assert.notEqual(syncNowIndex, -1);
  assert.notEqual(autoGateIndex, -1);
  assert.notEqual(fireTimeGateIndex, -1);
  assert.notEqual(clearTimerIndex, -1);
  assert.ok(
    helperIndex < syncNowIndex
      && syncNowIndex < autoGateIndex
      && debounceIndex < fireTimeGateIndex
      && debounceIndex < clearTimerIndex,
    "auto-sync off must gate both syncNow(auto) and the debounced timer path",
  );
});

test("startup local-wins and merge round-trips refuse device-bound credential placeholders", () => {
  const source = readFileSync(new URL("./useAutoSync.ts", import.meta.url), "utf8");
  const uploadLocalIndex = source.indexOf("if (conflictAction === 'upload-local')");
  const uploadGuardIndex = source.indexOf(
    "findSyncPayloadEncryptedCredentialPaths(localPayload)",
    uploadLocalIndex,
  );
  const uploadPushIndex = source.indexOf("manager.syncAllProviders(localPayload)", uploadGuardIndex);
  const mergeRoundTripBlockIndex = source.indexOf(
    "stripSyncPayloadEncryptedCredentials(mergeResult.payload)",
  );
  const mergeLocalHealIndex = source.indexOf(
    "healPoisonedSecretsForMerge(localPayload, remoteRaw, base)",
  );
  const mergeRemoteHealIndex = source.indexOf(
    "healPoisonedSecretsForMerge(remoteRaw, localPayload, base)",
  );
  const mergePushIndex = source.indexOf(
    "manager.syncAllProviders(portableMerge)",
    mergeRoundTripBlockIndex,
  );
  const stripRemoteIndex = source.indexOf(
    "stripSyncPayloadEncryptedCredentials(remoteRaw)",
  );

  assert.notEqual(uploadLocalIndex, -1);
  assert.notEqual(uploadGuardIndex, -1);
  assert.notEqual(uploadPushIndex, -1);
  assert.notEqual(mergeLocalHealIndex, -1);
  assert.notEqual(mergeRemoteHealIndex, -1);
  assert.notEqual(mergeRoundTripBlockIndex, -1);
  assert.notEqual(mergePushIndex, -1);
  assert.notEqual(stripRemoteIndex, -1);
  assert.ok(
    uploadGuardIndex < uploadPushIndex,
    "startup local-wins must guard placeholders before syncAllProviders",
  );
  assert.ok(
    mergeLocalHealIndex < mergeRoundTripBlockIndex
      && mergeRemoteHealIndex < mergeRoundTripBlockIndex
      && mergeRoundTripBlockIndex < mergePushIndex,
    "startup merge must heal local+remote secrets, then strip, then upload",
  );
});