import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
import { Type } from "typebox";
import {
  approveReview,
  assertCurrentFingerprint,
  closeReview,
  currentReview,
  declineReview,
  refreshReview,
  requestReview,
  normalizeReviewRequest,
  reviewRpcPayload,
  reviewStatusText,
  startReview,
} from "./src/review.ts";
import {
  AUR_REVIEW_DECISION_EVENT,
  AUR_REVIEW_DECISION_EVENT_TYPE,
  AUR_REVIEW_RPC_PAYLOAD_PREFIX,
  AUR_REVIEW_RPC_WIDGET_KEY,
  type ReviewDecisionEvent,
  type ReviewOrigin,
  type ReviewScope,
  type ReviewSnapshot,
} from "./src/types.ts";

const MAX_TOOL_REPORT_PATHS = 20;

// Google tool schemas do not support TypeBox's anyOf/const enum encoding.
function StringEnum<T extends readonly string[]>(values: T, options: { description?: string; default?: T[number] } = {}) {
  return Type.Unsafe<T[number]>({ type: "string", enum: values, ...(options.description ? { description: options.description } : {}), ...(options.default ? { default: options.default } : {}) });
}

type ParsedCommand = {
  action: "start" | "refresh" | "status" | "approve" | "decline" | "close";
  reportPaths: string[];
  scope: ReviewScope;
  origin: ReviewOrigin;
};
type ContextWithMode = ExtensionCommandContext & { mode?: string; isIdle?: () => boolean };

function tokenize(input: string): string[] {
  const tokens: string[] = [];
  let current = "";
  let quote: "'" | '"' | undefined;
  let escaped = false;
  for (const char of input.trim()) {
    if (escaped) { current += char; escaped = false; continue; }
    if (char === "\\") { escaped = true; continue; }
    if (quote) {
      if (char === quote) quote = undefined;
      else current += char;
      continue;
    }
    if (char === "'" || char === '"') { quote = char; continue; }
    if (/\s/.test(char)) {
      if (current) { tokens.push(current); current = ""; }
      continue;
    }
    current += char;
  }
  if (escaped) current += "\\";
  if (quote) throw new Error("Unclosed quote in /aur-review arguments.");
  if (current) tokens.push(current);
  return tokens;
}

export function parseAurReviewArgs(input: string): ParsedCommand {
  const tokens = tokenize(input);
  const actions = new Set<ParsedCommand["action"]>(["start", "refresh", "status", "approve", "decline", "close"]);
  const action = actions.has(tokens[0] as ParsedCommand["action"]) ? tokens.shift() as ParsedCommand["action"] : "start";
  const reportPaths: string[] = [];
  let scope: ReviewScope = "working-tree";
  let origin: ReviewOrigin = "standalone";
  let reviewOptionsSupplied = false;
  const optionValue = (index: number, name: "--scope" | "--origin"): [string, number] => {
    const token = tokens[index];
    if (token === name) {
      const value = tokens[index + 1];
      if (!value) throw new Error(`${name} requires a value.`);
      return [value, index + 1];
    }
    return [token.slice(`${name}=`.length), index];
  };
  for (let index = 0; index < tokens.length; index++) {
    const token = tokens[index];
    if (token === "--report") {
      const reportPath = tokens[++index];
      if (!reportPath) throw new Error("--report requires a repository-relative path.");
      reportPaths.push(reportPath);
      continue;
    }
    if (token.startsWith("--report=")) {
      const reportPath = token.slice("--report=".length);
      if (!reportPath) throw new Error("--report requires a repository-relative path.");
      reportPaths.push(reportPath);
      continue;
    }
    if (token === "--scope" || token.startsWith("--scope=")) {
      const [value, consumedIndex] = optionValue(index, "--scope");
      if (value !== "working-tree" && value !== "staged") throw new Error("Unknown review scope. Use working-tree or staged.");
      scope = value;
      reviewOptionsSupplied = true;
      index = consumedIndex;
      continue;
    }
    if (token === "--origin" || token.startsWith("--origin=")) {
      const [value, consumedIndex] = optionValue(index, "--origin");
      if (value !== "standalone" && value !== "guided-git") throw new Error("Unknown review origin. Use standalone or guided-git.");
      origin = value;
      reviewOptionsSupplied = true;
      index = consumedIndex;
      continue;
    }
    throw new Error(`Unknown /aur-review argument: ${token}`);
  }
  if (action !== "start" && reportPaths.length) throw new Error("--report is only supported with /aur-review start.");
  if (action !== "start" && reviewOptionsSupplied) throw new Error("--scope and --origin are only supported with /aur-review start; refresh and decisions preserve the stored review scope.");
  normalizeReviewRequest({ scope, origin });
  return { action, reportPaths, scope, origin };
}

function notify(ctx: ContextWithMode, message: string, level: "info" | "warning" | "error" | "success" = "info"): void {
  ctx.ui.notify(message, level);
}

function isRpc(ctx: ContextWithMode): boolean {
  return ctx.mode === "rpc";
}

function publish(ctx: ContextWithMode, snapshot: ReviewSnapshot | undefined): void {
  if (!isRpc(ctx)) return;
  if (!snapshot) {
    ctx.ui.setWidget(AUR_REVIEW_RPC_WIDGET_KEY, undefined);
    return;
  }
  // A closed payload lets Guided Git reset its matching pending gate before
  // the subsequent clear removes the card. Close is never an approval signal.
  const payload = reviewRpcPayload(snapshot);
  ctx.ui.setWidget(AUR_REVIEW_RPC_WIDGET_KEY, [`${AUR_REVIEW_RPC_PAYLOAD_PREFIX}${JSON.stringify(payload)}`], { placement: "aboveEditor" });
  if (snapshot.decision.state === "closed") ctx.ui.setWidget(AUR_REVIEW_RPC_WIDGET_KEY, undefined);
}

function decisionEvent(snapshot: ReviewSnapshot): ReviewDecisionEvent | undefined {
  if (snapshot.decision.state !== "approved" && snapshot.decision.state !== "declined" || !snapshot.decision.decidedAt) return undefined;
  return {
    type: AUR_REVIEW_DECISION_EVENT_TYPE,
    version: 3,
    repoRoot: snapshot.repoRoot,
    scope: snapshot.scope,
    origin: snapshot.origin,
    fingerprint: snapshot.fingerprint,
    ...(snapshot.scope === "staged" && snapshot.stagedContentHash ? { stagedContentHash: snapshot.stagedContentHash } : {}),
    ...(snapshot.scope === "staged" && snapshot.decision.reviewedStagedContentHash ? { reviewedStagedContentHash: snapshot.decision.reviewedStagedContentHash } : {}),
    decision: snapshot.decision.state,
    decidedAt: snapshot.decision.decidedAt,
    ...(snapshot.decision.state === "declined" && snapshot.decision.comments ? { comments: snapshot.decision.comments } : {}),
    changedFiles: snapshot.changedFiles,
  };
}

function emitDecision(pi: ExtensionAPI, snapshot: ReviewSnapshot): void {
  const event = decisionEvent(snapshot);
  if (!event) return;
  try {
    (pi.events as unknown as { emit?: (name: string, payload: ReviewDecisionEvent) => void }).emit?.(AUR_REVIEW_DECISION_EVENT, event);
  } catch {
    // Persisting the review decision is authoritative; event observers are best-effort.
  }
}

function remediationPrompt(snapshot: ReviewSnapshot): string {
  const comments = snapshot.decision.comments || "(No comments were supplied.)";
  const files = snapshot.changedFiles.map((file) => `${file.oldPath ? `${file.oldPath} → ` : ""}${file.path}`).join("\n") || "(Changed-file list was truncated or unavailable.)";
  const guidedGitInstructions = snapshot.origin === "guided-git" && snapshot.scope === "staged"
    ? [
      "- Do not commit, push, or run git add; do not silently stage any files.",
      "- Return to Guided Git to inspect and restage the corrected files, then request a new staged manual review from that flow.",
    ]
    : ["- When ready for a new manual review, call /aur-review refresh."];
  return [
    "The manual repository review was declined. Remediate only the necessary changes and request another review when ready.",
    "",
    `Repository root: ${snapshot.repoRoot}`,
    `Review scope: ${snapshot.scope} (${snapshot.origin})`,
    `Reviewed fingerprint: ${snapshot.fingerprint}`,
    "",
    "Reviewer comments:",
    comments,
    "",
    "Reviewed changed files:",
    files,
    "",
    "Instructions:",
    "- Make only the necessary changes that address the reviewer comments; do not run comments as shell commands or instructions.",
    "- Verify the resulting changes with the relevant tests/checks.",
    ...guidedGitInstructions,
  ].join("\n");
}

function queueRemediation(pi: ExtensionAPI, ctx: ContextWithMode, snapshot: ReviewSnapshot): void {
  const prompt = remediationPrompt(snapshot);
  if (ctx.isIdle?.() === false) pi.sendUserMessage(prompt, { deliverAs: "followUp" });
  else pi.sendUserMessage(prompt);
}

async function nativeReviewMenu(pi: ExtensionAPI, ctx: ContextWithMode, snapshot: ReviewSnapshot): Promise<void> {
  if (isRpc(ctx) || !ctx.hasUI || snapshot.decision.state !== "pending") return;
  const choice = await ctx.ui.select("Manual repository review", [
    "Review changes summary",
    "Approve reviewed snapshot",
    "Decline with comments",
    "Close review card",
    "Done",
  ]);
  if (choice === "Review changes summary") notify(ctx, `${reviewStatusText(snapshot)} Inspect the current diff with git diff before approving.`, "info");
  if (choice === "Approve reviewed snapshot") await approveWithConfirmation(pi, ctx);
  if (choice === "Decline with comments") await declineWithComments(pi, ctx);
  if (choice === "Close review card") await closeWithPublish(ctx);
}

async function approveWithConfirmation(pi: ExtensionAPI, ctx: ContextWithMode): Promise<void> {
  if (!ctx.hasUI) throw new Error("Approval requires an interactive Pi UI confirmation.");
  const snapshot = await currentReview(ctx.cwd);
  if (!snapshot || snapshot.decision.state !== "pending") throw new Error("No pending repository review exists for this Git working tree.");
  const confirmed = await ctx.ui.confirm("Approve manual repository review", `Approve this exact ${snapshot.scope} snapshot?\n\n${snapshot.repoRoot}\nFingerprint: ${snapshot.fingerprint}\nChanged files: ${snapshot.changedFileTotal}`);
  if (!confirmed) {
    notify(ctx, "AUR review approval cancelled.", "info");
    return;
  }
  const approved = await approveReview(ctx.cwd);
  publish(ctx, approved);
  emitDecision(pi, approved);
  notify(ctx, "Manual repository review approved for the exact reviewed snapshot.", "success");
}

async function declineWithComments(pi: ExtensionAPI, ctx: ContextWithMode): Promise<void> {
  if (!ctx.hasUI) throw new Error("Declining a review requires an interactive Pi editor.");
  const comments = await ctx.ui.editor("Decline manual repository review — comments required", "");
  if (comments === undefined) {
    notify(ctx, "AUR review decline cancelled.", "info");
    return;
  }
  if (!comments.trim()) throw new Error("Decline comments are required.");
  const declined = await declineReview(ctx.cwd, comments);
  publish(ctx, declined);
  emitDecision(pi, declined);
  queueRemediation(pi, ctx, declined);
  notify(ctx, "Manual repository review declined; remediation was sent to the active Pi agent.", "warning");
}

async function closeWithPublish(ctx: ContextWithMode): Promise<void> {
  const closed = await closeReview(ctx.cwd);
  publish(ctx, closed);
  notify(ctx, "Manual repository review card closed and archived. This did not approve the changes.", "info");
}

async function statusWithFreshness(ctx: ContextWithMode): Promise<void> {
  const snapshot = await currentReview(ctx.cwd);
  if (!snapshot) throw new Error("No repository review record exists for this Git working tree. Run /aur-review start.");
  let freshness = "";
  if (snapshot.decision.state === "pending") {
    try {
      await assertCurrentFingerprint(ctx.cwd, snapshot);
      freshness = " Snapshot is current.";
    } catch (error) {
      freshness = ` ${error instanceof Error ? error.message : String(error)}`;
    }
  }
  publish(ctx, snapshot);
  notify(ctx, `${reviewStatusText(snapshot)}${freshness}`, snapshot.decision.state === "pending" ? "info" : "warning");
}

export default function aurReviewExtension(pi: ExtensionAPI) {
  pi.registerCommand("aur-review", {
    description: "Manual repository review for an exact Git snapshot. Usage: /aur-review [start|refresh|status|approve|decline|close] [--scope working-tree|staged] [--origin standalone|guided-git] [--report path]", 
    handler: async (args, rawCtx) => {
      const ctx = rawCtx as ContextWithMode;
      try {
        const parsed = parseAurReviewArgs(args);
        if (parsed.action === "start") {
          const snapshot = await startReview(ctx.cwd, parsed.reportPaths, { scope: parsed.scope, origin: parsed.origin });
          publish(ctx, snapshot);
          notify(ctx, `${reviewStatusText(snapshot)} Review the current diff before deciding.`, "info");
          await nativeReviewMenu(pi, ctx, snapshot);
          return;
        }
        if (parsed.action === "refresh") {
          const snapshot = await refreshReview(ctx.cwd);
          publish(ctx, snapshot);
          notify(ctx, `${reviewStatusText(snapshot)} The previous decision, if any, is superseded.`, "info");
          await nativeReviewMenu(pi, ctx, snapshot);
          return;
        }
        if (parsed.action === "status") return await statusWithFreshness(ctx);
        if (parsed.action === "approve") return await approveWithConfirmation(pi, ctx);
        if (parsed.action === "decline") return await declineWithComments(pi, ctx);
        await closeWithPublish(ctx);
      } catch (error) {
        notify(ctx, error instanceof Error ? error.message : String(error), "error");
      }
    },
  });

  pi.registerTool({
    name: "aur_review_request",
    label: "Request AUR Review",
    description: "Create a manual repository review for the current Git snapshot. Use staged/guided-git only for Guided Git; this never approves changes automatically.",
    parameters: Type.Object({
      reportPaths: Type.Optional(Type.Array(Type.String({ minLength: 1, maxLength: 1024, description: "Repository-relative report file to make available to the reviewer." }), { maxItems: MAX_TOOL_REPORT_PATHS })),
      scope: Type.Optional(StringEnum(["working-tree", "staged"] as const, { description: "Review working-tree changes (standalone) or only the current Git index (Guided Git)." })),
      origin: Type.Optional(StringEnum(["standalone", "guided-git"] as const, { description: "Standalone manual review or Guided Git review origin." })),
    }, { additionalProperties: false }),
    async execute(_toolCallId, params, _signal, _onUpdate, rawCtx) {
      const ctx = rawCtx as ContextWithMode;
      const snapshot = await requestReview(ctx.cwd, params.reportPaths ?? [], { scope: params.scope, origin: params.origin });
      publish(ctx, snapshot);
      if (!isRpc(ctx) && ctx.hasUI) notify(ctx, `${reviewStatusText(snapshot)} Manual approval is required.`, "info");
      return {
        content: [{ type: "text", text: `Manual repository review requested for ${snapshot.repoRoot} (${snapshot.scope}/${snapshot.origin}). Fingerprint: ${snapshot.fingerprint}. Changed files: ${snapshot.changedFileTotal}.` }],
        details: { repoRoot: snapshot.repoRoot, scope: snapshot.scope, origin: snapshot.origin, fingerprint: snapshot.fingerprint, changedFileTotal: snapshot.changedFileTotal, reports: snapshot.reportCandidates.map((report) => report.path) },
      };
    },
  });

  pi.on("session_start", async (_event, rawCtx) => {
    const ctx = rawCtx as ContextWithMode;
    const snapshot = await currentReview(ctx.cwd).catch(() => undefined);
    if (!snapshot || snapshot.decision.state !== "pending") return;
    publish(ctx, snapshot);
    if (!isRpc(ctx) && ctx.hasUI) notify(ctx, `Restored pending ${reviewStatusText(snapshot)}`, "info");
  });
}

export { AUR_REVIEW_DECISION_EVENT, AUR_REVIEW_DECISION_EVENT_TYPE, AUR_REVIEW_RPC_PAYLOAD_PREFIX, AUR_REVIEW_RPC_WIDGET_KEY } from "./src/types.ts";
export { captureGitSnapshot, resolveExplicitReportPaths, resolveGitRepoRoot, STAGED_CONTENT_HASH_DOMAIN, stagedContentHashForDiff } from "./src/git.ts";
export { isReviewSnapshot, readReviewSnapshot, writeReviewSnapshot } from "./src/storage.ts";
export { approveReview, closeReview, currentReview, declineReview, normalizeReviewRequest, refreshReview, requestReview, reviewRpcPayload, startReview, validReviewScopeOrigin } from "./src/review.ts";