import { assert, hashValue } from '../assertions/core.mjs';
import { prepareCliBinary, runCli } from '../harness/process.mjs';
import {
  assertUnscriptedTaskPrompt,
  buildTaskPrompt,
  seedDisposableProject,
} from '../harness/project.mjs';
import {
  driveRuntimeToQuiescence,
  injectSameRunSteer,
  killRunnerOnce,
  validateLandedEvidence,
  waitForCanonicalRuntime,
  waitForPartiallyCompletedStructuredPlan,
  waitForRecoveredStructuredPlan,
} from '../harness/runtime.mjs';
import { mainAgentId, requestedRunId, state } from '../runtime-state.mjs';

export async function runRealE2e() {
  await seedDisposableProject();
  state.cliBinary = await prepareCliBinary();

  const task = buildTaskPrompt(state.suite);
  assertUnscriptedTaskPrompt(task);
  state.initialTask = {
    chars: [...task].length,
    sha256: hashValue(task),
  };
  await runCli(
    [
      '--agent-enqueue',
      '--init',
      state.projectRoot,
      mainAgentId,
      requestedRunId,
      task,
    ],
    { timeoutMs: 120_000 },
  );

  const beforeKill = await waitForCanonicalRuntime();
  state.initialRunId = beforeKill.runId;
  state.initialSessionId = beforeKill.sessionId;
  const preKillPlan = await waitForPartiallyCompletedStructuredPlan();
  state.planRecovery = {
    preKillRevision: preKillPlan.revision,
    preKillCompletedStepHashes: preKillPlan.completedStepHashes,
    preKillIncompleteStepCount: preKillPlan.incompleteStepCount,
    preKillTerminalStepHash: preKillPlan.terminalStepHash,
    recoveredRevision: 0,
    recoveredCompletedStepHashes: [],
    recoveredTerminalStepHash: null,
  };
  await killRunnerOnce();
  await runCli(['--agent-resume', state.projectRoot], { timeoutMs: 120_000 });
  state.resumed = true;

  const recoveredPlan = await waitForRecoveredStructuredPlan(preKillPlan);
  const afterResume = recoveredPlan.runtime;
  assert(
    afterResume.runId === state.initialRunId &&
      afterResume.sessionId === state.initialSessionId,
    'run-session-changed-after-resume',
  );
  state.identityStable = true;
  state.planRecovery.recoveredRevision = recoveredPlan.revision;
  state.planRecovery.recoveredCompletedStepHashes =
    recoveredPlan.completedStepHashes;
  state.planRecovery.recoveredTerminalStepHash = recoveredPlan.terminalStepHash;

  await injectSameRunSteer();

  await driveRuntimeToQuiescence();
  state.evidence = await validateLandedEvidence();
  assert(state.evidence.secretLeakCount === 0, 'loaded-key-leak-detected');
}