const form = document.getElementById("intakeForm");
const steps = [...document.querySelectorAll(".step")];
const stepCount = document.getElementById("stepCount");
const backButton = document.getElementById("back");
const nextButton = document.getElementById("next");
const copyButton = document.getElementById("copy");
const packet = document.getElementById("packet");
const failureWarning = document.getElementById("failureWarning");
let currentStep = 0;

function checkedValues(name) {
  return [...document.querySelectorAll(`input[name="${name}"]:checked`)].map((item) => item.value);
}

function value(id) {
  return document.getElementById(id)?.value.trim() || "";
}

function updateStep() {
  steps.forEach((step, index) => step.classList.toggle("active", index === currentStep));
  stepCount.textContent = currentStep >= 6
    ? "Owner Intake Packet"
    : `Step ${currentStep + 1} of 6 / ${steps[currentStep].dataset.title}`;
  backButton.disabled = currentStep === 0;
  nextButton.textContent = currentStep === 5 ? "Generate packet" : currentStep >= 6 ? "Edit intake" : "Next";
  copyButton.style.display = currentStep >= 6 ? "inline-flex" : "none";
  window.scrollTo(0, 0);
}

function stepIsValid() {
  const required = [...steps[currentStep].querySelectorAll("[required]")];
  return required.every((field) => field.reportValidity());
}

function classifyLevel(tools, frequency) {
  const toolSet = new Set(tools);
  if (["Claude Code Terminal", "Codex CLI", "Hermes", "terminal-based agent workflow"].some((tool) => toolSet.has(tool)) || frequency === "core workflow") return "terminal workflow operator";
  if (["OpenCode", "custom harness", "Cline", "Aider"].some((tool) => toolSet.has(tool))) return "agentic builder";
  if (["Claude Code Mac App", "Codex App", "Cursor", "Lovable", "Google Antigravity"].some((tool) => toolSet.has(tool))) return "tool-surface user";
  return "tool user";
}

function toolFitNote(tools) {
  const toolSet = new Set(tools);
  const hasCore = ["Claude Code Terminal", "Codex CLI", "Hermes", "terminal-based agent workflow"].some((tool) => toolSet.has(tool));
  const hasAdjacent = ["OpenCode", "custom harness", "Cline", "Aider"].some((tool) => toolSet.has(tool));
  const hasApp = ["Claude Code Mac App", "Codex App", "ChatGPT", "Claude"].some((tool) => toolSet.has(tool));
  const hasNonFocus = ["Cursor", "Lovable", "Google Antigravity", "GitHub Copilot", "Devin", "OpenHands"].some((tool) => toolSet.has(tool));

  if (hasCore && hasNonFocus) {
    return "Very strong if the real break happens in the terminal agent loop; IDE or platform-specific support is secondary.";
  }
  if (hasCore) {
    return "Very strong fit: terminal-based agent workflow, project context, hooks, verification, and ownership boundaries.";
  }
  if (hasAdjacent) {
    return "Possible fit: close enough if the issue is workflow structure, verification, scope control, or handoff.";
  }
  if (hasApp) {
    return "Limited fit: method and ownership help are possible, but deep app-surface support is not the main focus.";
  }
  if (hasNonFocus) {
    return "Not the main focus: likely better for method, gates, and ownership boundaries than product-specific tool advice.";
  }
  return "Unknown fit until the tool surface and workflow break are made concrete.";
}

function fitNote(failure, humanOwned, agentOwned, verification) {
  const weakVerification = verification.includes("no clear rule") || verification.includes("manual review") || failure.includes("weak verification") || failure.includes("false done");
  const ownershipRisk = agentOwned.includes("goal") || agentOwned.includes("scope") || agentOwned.includes("risk") || humanOwned.length === 0;
  if (failure.length > 0 && agentOwned.length > 0 && (weakVerification || ownershipRisk)) {
    return "Strong fit: real agent work, visible failure pattern, and a control or verification gap.";
  }
  if (failure.length > 0) {
    return "Medium fit: real task and pain are visible; the first HAI step should narrow delegation and evidence.";
  }
  return "Weak fit until the workflow pain is made concrete.";
}

function humanGates(humanOwned, never, stopApproving) {
  const gates = [];
  if (humanOwned.length) gates.push(`Human keeps: ${humanOwned.join(", ")}`);
  if (never) gates.push(`Never without human: ${never}`);
  if (stopApproving.length && !stopApproving.includes("none yet")) {
    gates.push(`Still approving manually: ${stopApproving.join(", ")}`);
  }
  return gates.length ? gates.map((g, i) => `${i + 1}. ${g}`).join("\n") : "1. Not specified yet — clarify before delegating.";
}

function verificationRule(verification, evidence, reliability) {
  const parts = [];
  if (verification.length) parts.push(`Check via: ${verification.join(", ")}`);
  if (evidence.length) parts.push(`Trust when: ${evidence.join(", ")}`);
  if (reliability) parts.push(`Current reliability: ${reliability}`);
  return parts.join("\n") || "No verifier rule yet — define one before scaling agent output.";
}

function nextActionPacket(currentWork, failure, autonomy) {
  const outcome = currentWork
    ? `One bounded improvement to: ${currentWork.slice(0, 120)}${currentWork.length > 120 ? "…" : ""}`
    : "One bounded workflow improvement with explicit owner gate";
  const topFailure = failure[0] || "unclear failure pattern";
  return `Outcome: ${outcome}
Evidence: ${failure.length ? `Failure pattern "${topFailure}" no longer blocks the next verifiable step` : "One visible proof that the workflow is checkable"}
Boundaries: ${autonomy || "L2 or lower until verifier rule exists"}; no commit/push/deploy without human gate
Stop condition: Stop when one next step is written, scoped, and verifiable — or when scope needs an owner decision`;
}

function generatePacket() {
  const tools = checkedValues("tools");
  const failure = checkedValues("failure");
  const humanOwned = checkedValues("humanOwned");
  const agentOwned = checkedValues("agentOwned");
  const verification = checkedValues("verification");
  const evidence = checkedValues("evidence");
  const stopApproving = checkedValues("stopApproving");
  const currentWork = value("currentWork");
  const level = classifyLevel(tools, value("frequency"));
  const toolFit = toolFitNote(tools);
  const fit = fitNote(failure, humanOwned, agentOwned, verification);
  const friction = failure.length
    ? failure.slice(0, 3).map((f, i) => `${i + 1}. ${f}`).join("\n")
    : "1. Not specified\n2. —\n3. —";

  packet.textContent = `# HAI Owner Intake Packet

## Problem (one sentence)
${currentWork || "not specified"}

## Three friction points
${friction}

## Current workflow
${currentWork}

Tools in use:
${tools.join(", ") || "not specified"}${value("customSetup") ? `\nCustom setup: ${value("customSetup")}` : ""}

Tool fit signal:
${toolFit}

Usage frequency:
${value("frequency")}

Break point:
${value("breakPoint") || "not specified"}

Customer level:
${level}

## Human gates
${humanGates(humanOwned, value("never"), stopApproving)}

Human-owned decisions/work:
${humanOwned.join(", ") || "not specified"}

Agent-owned work:
${agentOwned.join(", ") || "not specified"}

Handoff clarity:
${value("handoff") || "not specified"}

Missing layer:
${checkedValues("missingLayer").join(", ") || "not specified"}

Desired autonomy level:
${value("autonomy")}

Hard autonomy boundary:
${value("never")}

## Verification rule
${verificationRule(verification, evidence, value("reliability"))}

Existing verification methods:
${verification.join(", ") || "not specified"}

Trusted evidence:
${evidence.join(", ") || "not specified"}${value("evidenceNote") ? `\nEvidence note: ${value("evidenceNote")}` : ""}

## Next Action Packet
${nextActionPacket(currentWork, failure, value("autonomy"))}

## Audit fit
${fit}

---
Next step: Book a 20 min HAI fit call — samuel@human-agent-interface.com
Subject: HAI fit call + attach this packet`;
}

document.querySelectorAll("[data-toggle]").forEach((button) => {
  button.addEventListener("click", () => {
    const panel = document.getElementById(button.dataset.toggle);
    const open = panel.classList.toggle("open");
    button.textContent = open
      ? button.textContent.replace("More", "Hide")
      : button.textContent.replace("Hide", "More");
  });
});

document.querySelectorAll('input[name="failure"]').forEach((box) => {
  box.addEventListener("change", () => {
    if (checkedValues("failure").length > 3) {
      box.checked = false;
      failureWarning.classList.add("visible");
      setTimeout(() => failureWarning.classList.remove("visible"), 1800);
    }
  });
});

backButton.addEventListener("click", () => {
  if (currentStep > 0) {
    currentStep -= 1;
    updateStep();
  }
});

nextButton.addEventListener("click", () => {
  if (currentStep >= 6) {
    currentStep = 0;
    updateStep();
    return;
  }

  if (!stepIsValid()) return;

  if (currentStep === 5) {
    generatePacket();
    currentStep = 6;
  } else {
    currentStep += 1;
  }
  updateStep();
});

copyButton.addEventListener("click", async () => {
  try {
    await navigator.clipboard.writeText(packet.textContent);
    const old = copyButton.textContent;
    copyButton.textContent = "Copied";
    setTimeout(() => { copyButton.textContent = old; }, 1200);
  } catch (error) {
    copyButton.textContent = "Copy manually";
  }
});

updateStep();