import * as vscode from "vscode";
import { fetchSdkSummary } from "./cline";
import { CoauthorStore } from "./store";
import { ThreadController } from "./threadController";
import { AttributionController } from "./attributionController";
import { ProposalController } from "./proposalController";
import { buildFingerprint } from "./anchorer";
import { VersionGuard } from "./versionGuard";
import { BaselineStore } from "./baselineStore";
import { GlobalSidecarStore } from "./globalSidecarStore";
import { SidecarRouter } from "./sidecarRouter";
import { DiffViewController } from "./diffViewController";
import { GitBaselineAdapter } from "./gitBaseline";
import { TrackChangesPreviewController } from "./trackChangesPreview";
import { EditFlow } from "./editFlow";
import { LiveProgressUi } from "./liveProgressUi";
import { EditorProposalController } from "./editorProposalController";
import { isAuthorable, routeEdit, selectionRejection } from "./workspacePath";
import { CoeditingRegistry } from "./coeditingRegistry";
import { ScmSurfaceController } from "./scmSurface";

const CHANNEL_NAME = "Cowriting (Cline SDK)";
/** The exact warning copy for every gated edit gesture (INV-10). */
const NOT_COEDITING_WARNING = "Run ✦ Coedit this Document with Claude first.";

export interface CowritingApi {
  threadController: ThreadController;
  attributionController: AttributionController;
  proposalController: ProposalController;
  versionGuard: VersionGuard;
  diffViewController: DiffViewController;
  trackChangesPreviewController: TrackChangesPreviewController;
  editFlow: EditFlow;
  sidecarRouter: SidecarRouter;
  liveProgressUi: LiveProgressUi;
  editorProposalController: EditorProposalController;
  coeditingRegistry: CoeditingRegistry;
  scmSurfaceController: ScmSurfaceController;
}

export function activate(context: vscode.ExtensionContext): CowritingApi | undefined {
  // --- POC command (Feature #2), unchanged ---
  const output = vscode.window.createOutputChannel(CHANNEL_NAME);
  context.subscriptions.push(output);

  // #60: shared live-progress UI (notification activity line + "Cowriting: Claude"
  // OutputChannel) for both Ask-Claude entry points.
  const liveProgressUi = new LiveProgressUi();
  context.subscriptions.push(liveProgressUi);
  context.subscriptions.push(
    vscode.commands.registerCommand("cowriting.showClineSdkInfo", async () => {
      try {
        const summary = await fetchSdkSummary();
        output.clear();
        output.appendLine(`@cline/sdk version: ${summary.version}`);
        output.appendLine(`Builtin tools (${summary.tools.length}):`);
        for (const tool of summary.tools) output.appendLine(`  • ${tool.id} — ${tool.description}`);
        output.show(true);
        await vscode.window.showInformationMessage(
          `Cline SDK ${summary.version} loaded — ${summary.tools.length} builtin tools. See the "${CHANNEL_NAME}" output channel.`,
        );
      } catch (err) {
        const message = err instanceof Error ? err.message : String(err);
        output.appendLine(`Failed to drive @cline/sdk: ${message}`);
        output.show(true);
        await vscode.window.showErrorMessage(`Cowriting: failed to load @cline/sdk — ${message}`);
      }
    }),
  );

  // --- PUC-7 (native-surfaces migration): the INV-10 opt-in gate ---
  // Every later native surface (SCM/QuickDiff, comments, preview annotations,
  // edit commands, decorations) checks isCoediting before attaching. Persisted
  // in workspaceState so a reload restores the set.
  const coeditingRegistry = new CoeditingRegistry(context.workspaceState);
  context.subscriptions.push(coeditingRegistry);
  context.subscriptions.push(
    vscode.commands.registerCommand("cowriting.coeditDocument", () => {
      const ed = vscode.window.activeTextEditor;
      if (!ed || ed.document.languageId !== "markdown" || !isAuthorable(ed.document.uri.scheme)) {
        void vscode.window.showWarningMessage("Cowriting: open a Markdown document to coedit it.");
        return;
      }
      coeditingRegistry.enter(ed.document.uri);
      coeditingRegistry.syncContext(ed);
    }),
    vscode.commands.registerCommand("cowriting.stopCoediting", () => {
      const ed = vscode.window.activeTextEditor;
      if (!ed) return;
      coeditingRegistry.exit(ed.document.uri);
      coeditingRegistry.syncContext(ed);
    }),
    vscode.window.onDidChangeActiveTextEditor((ed) => coeditingRegistry.syncContext(ed)),
  );
  coeditingRegistry.syncContext(vscode.window.activeTextEditor);

  // --- Baseline router (native-surfaces migration, spec §6.4, INV-7) — workspace-
  // INDEPENDENT --- The two-pane vscode.diff VIEW was removed in #34 (F10's
  // rendered preview is the single review surface); only the baseline data
  // layer survives, consumed by F7/F10. It tracks a baseline for ANY diffable
  // doc (file or untitled), so it is constructed regardless of whether a folder
  // is open. A SNAPSHOT baseline lives in VS Code's per-extension GLOBAL
  // storage (always present), never the repo (INV-19); a git-tracked doc's HEAD
  // baseline is never persisted (INV-7). Baselines are established only for
  // documents the CoeditingRegistry has entered — see the registry wiring
  // inside DiffViewController's constructor.
  const gitBaseline = new GitBaselineAdapter();
  context.subscriptions.push(gitBaseline);
  const baselineStorageDir = context.globalStorageUri?.fsPath;
  const baselineStore = baselineStorageDir ? new BaselineStore(baselineStorageDir) : null;
  const diffViewController = new DiffViewController(baselineStore, gitBaseline, coeditingRegistry);
  context.subscriptions.push(diffViewController);

  // Task 1 hook: expose the resolved baseline mode ("head"/"snapshot") to the
  // registry's context-key sync, and re-sync `cowriting.baselineMode` whenever
  // a baseline is (re)captured (entry, head-refresh, pin) — the "Mark Changes
  // as Reviewed" menu entry (snapshot-only, Task 3) is gated on that key.
  coeditingRegistry.baselineModeOf = (uri) => diffViewController.modeOf(uri.toString());
  context.subscriptions.push(
    diffViewController.onDidChangeBaseline(() => coeditingRegistry.syncContext(vscode.window.activeTextEditor)),
  );

  // --- Task 3: the native diff surface (spec §6.4/§5, INV-13) — QuickDiff
  // gutter bars, the cowriting-baseline: content provider, "Review Changes",
  // and the status-bar change count. Constructed after diffViewController
  // (consumes getBaseline/modeOf/onDidChangeBaseline) and the registry
  // (consumes isCoediting/onDidChange), gated on INV-10. ---
  const scmSurfaceController = new ScmSurfaceController(coeditingRegistry, diffViewController);
  context.subscriptions.push(scmSurfaceController);

  // F8: the out-of-workspace/untitled authoring sidecar — same GLOBAL storage
  // home as the F6 baseline, keyed by sha256(uri) (INV-19/24). Constructed
  // workspace-independently; the router falls back to it for any non-in-folder
  // doc. When globalStorageUri is unavailable, file writes throw (authoring
  // degrades to errors-on-write, the F6-equivalent edge) but untitled in-memory
  // still works — PUC-5.
  const globalSidecarStore = new GlobalSidecarStore(baselineStorageDir ?? "");

  // --- F8: authoring on ANY document (in-folder, out-of-folder, untitled) ---
  // The router routes per-document: in-workspace file: → the committable repo
  // `.threads/` sidecar (CoauthorStore, INV-2); out-of-folder file: + untitled:
  // → the global-storage sidecar (GlobalSidecarStore). Constructed even with NO
  // folder open (everything then routes global) — the F6 #19 precedent, now
  // extended to authoring (F2 threads, F3 attribution, F4 propose/accept).
  const root = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
  const coauthorStore = root ? new CoauthorStore(root) : null;
  const sidecarRouter = new SidecarRouter(coauthorStore, globalSidecarStore, root);
  // F5 (INV-16): one shared guard — newer-major sidecars are read-only, one
  // warning per doc across the three co-owning controllers.
  const versionGuard = new VersionGuard(sidecarRouter);
  const threadController = new ThreadController(sidecarRouter, root, versionGuard, coeditingRegistry);
  context.subscriptions.push(threadController);

  // --- F3: live attribution (Feature #6) ---
  const attributionController = new AttributionController(sidecarRouter, root, versionGuard, coeditingRegistry);
  context.subscriptions.push(attributionController);

  // --- F4: propose/accept (Feature #12) — constructed before the preview so F10
  // can route ✓/✗ through it ---
  const proposalController = new ProposalController(
    sidecarRouter,
    attributionController,
    root,
    versionGuard,
    coeditingRegistry,
  );
  context.subscriptions.push(proposalController);

  // --- F11/F12 (native-surfaces migration, spec §6.10): the edit flow — the
  // `cowriting.editDocument` command, the instruction-prompt/progress-wrapped
  // "ask Claude" gesture (INV-10 gate), and the turn→proposal(s) cut
  // (`runEditAndPropose`, INV-39/40). Constructed BEFORE the review preview (which
  // delegates to it) and reachable from the thread controller too (Task 6). ---
  const editFlow = new EditFlow(proposalController, attributionController, liveProgressUi, coeditingRegistry);
  context.subscriptions.push(editFlow);

  // --- F7/F10: the review preview is the single interactive review surface ---
  // Workspace-INDEPENDENT (works on any markdown doc, reuses the F6 baseline,
  // INV-20). Constructed AFTER attribution (reads F3 spans), proposals (routes
  // F4 accept/reject from the webview ✓/✗), and editFlow (delegates the webview's
  // askClaude toolbar intent to it).
  const trackChangesPreviewController = new TrackChangesPreviewController(
    diffViewController,
    context.extensionUri,
    attributionController,
    proposalController,
    editFlow,
  );
  context.subscriptions.push(trackChangesPreviewController);

  // --- F12 (#64): the editor surface — optimistic-apply proposals into the buffer,
  // decorate the diff, and provide Accept ▾/Reject ▾ CodeLens (INV-48/49/52/53). ---
  const editorProposalController = new EditorProposalController(
    proposalController,
    diffViewController,
    attributionController,
    coeditingRegistry,
  );
  context.subscriptions.push(editorProposalController);

  // #46 (INV-42): accept every pending proposal on the active doc in one gesture
  // (also reachable from the preview toolbar's "Accept all" button, which routes
  // through its own webview-facing acceptAll). Reuses the batched F4 seam +
  // reports applied-vs-skipped (native-surfaces migration: routes directly to
  // ProposalController, no preview-controller indirection).
  context.subscriptions.push(
    vscode.commands.registerCommand("cowriting.acceptAllProposals", async () => {
      const doc = vscode.window.activeTextEditor?.document;
      if (!doc || doc.languageId !== "markdown") {
        void vscode.window.showWarningMessage("Cowriting: open a Markdown document to accept its proposals.");
        return;
      }
      const { applied, skipped } = await proposalController.acceptAllProposals(doc);
      if (applied === 0 && skipped === 0) return;
      const skipNote = skipped > 0 ? `, ${skipped} skipped (target text changed — undo or reject)` : "";
      void vscode.window.showInformationMessage(
        `Cowriting: accepted ${applied} proposal${applied === 1 ? "" : "s"}${skipNote}.`,
      );
    }),
  );

  // #64 (INV-53): reject every pending proposal on the active doc in one gesture
  // (native-surfaces migration: routes directly to ProposalController).
  context.subscriptions.push(
    vscode.commands.registerCommand("cowriting.rejectAllProposals", async () => {
      const doc = vscode.window.activeTextEditor?.document;
      if (!doc || doc.languageId !== "markdown") {
        void vscode.window.showWarningMessage("Cowriting: open a Markdown document to reject its proposals.");
        return;
      }
      const { reverted } = await proposalController.rejectAll(doc);
      if (reverted > 0) {
        void vscode.window.showInformationMessage(
          `Cowriting: rejected ${reverted} proposal${reverted === 1 ? "" : "s"}.`,
        );
      }
    }),
  );

  // NOTE (native-surfaces migration, INV-7/INV-18 retirement): the shipped
  // machine-landing baseline advance (#48) — wiring
  // attributionController.onDidApplyAgentEdit → diffViewController.advance —
  // was removed here. A landed Claude edit now stays a visible change-since-
  // baseline until the file is committed (head mode) or reviewed via
  // "Mark Changes as Reviewed" (snapshot mode).

  // One SHARED sidecar watcher for both controllers; self-writes are suppressed
  // centrally in the repo store (only repo `.threads/` sidecars are watched —
  // global artifacts live outside the workspace). Harmless when no folder is open.
  const watcher = vscode.workspace.createFileSystemWatcher("**/.threads/**/*.json");
  const onSidecar = (uri: vscode.Uri) => {
    if (sidecarRouter.consumeSelfWrite(uri.fsPath)) return;
    threadController.handleExternalSidecarChange(uri);
    attributionController.handleExternalSidecarChange(uri);
    proposalController.handleExternalSidecarChange(uri);
  };
  watcher.onDidChange(onSidecar);
  watcher.onDidCreate(onSidecar);
  context.subscriptions.push(watcher);

  // The seam as a command (INV-9): the only machine-edit ingress, hidden from
  // the palette — for the host E2E harness and future SDK turn plumbing.
  context.subscriptions.push(
    vscode.commands.registerCommand(
      "cowriting.applyAgentEdit",
      (args: {
        uri: string; start: number; end: number; newText: string;
        model?: string; sessionId?: string; turnId?: string;
      }) => {
        const doc = vscode.workspace.textDocuments.find((d) => d.uri.toString() === args.uri);
        if (!doc) return Promise.resolve(false);
        const range = new vscode.Range(doc.positionAt(args.start), doc.positionAt(args.end));
        const provenance = {
          kind: "agent" as const,
          id: "claude",
          agent: { sdk: "@cline/sdk", model: args.model ?? "sonnet", sessionId: args.sessionId ?? "" },
        };
        return attributionController.applyAgentEdit(doc, range, args.newText, provenance, { turnId: args.turnId });
      },
    ),
  );

  // The propose ingress as a command (spec §6.4): records a pending proposal,
  // NEVER touches the document (INV-10) — for the host E2E harness.
  context.subscriptions.push(
    vscode.commands.registerCommand(
      "cowriting.proposeAgentEdit",
      (args: {
        uri: string; start: number; end: number; newText: string;
        model?: string; sessionId?: string; turnId?: string; instruction?: string;
      }) => {
        const doc = vscode.workspace.textDocuments.find((d) => d.uri.toString() === args.uri);
        if (!doc) return Promise.resolve(undefined);
        const fp = buildFingerprint(doc.getText(), { start: args.start, end: args.end });
        const provenance = {
          kind: "agent" as const,
          id: "claude",
          agent: { sdk: "@cline/sdk", model: args.model ?? "sonnet", sessionId: args.sessionId ?? "" },
        };
        return proposalController.propose(doc, fp, args.newText, provenance, {
          turnId: args.turnId,
          instruction: args.instruction,
        });
      },
    ),
  );

  // F3 SLICE-5 → F4 SLICE-4: the live turn — selection + instruction → one
  // claude-code SDK turn (liveTurn.ts, INV-8) → a PENDING PROPOSAL (F4,
  // INV-10); the applyAgentEdit seam (INV-9) now fires only on accept.
  context.subscriptions.push(
    vscode.commands.registerCommand("cowriting.editSelection", async () => {
      const editor = vscode.window.activeTextEditor;
      // F8: authoring works on any file: or untitled: doc (the router decides
      // where its artifact is stored). Each failure still names its real reason
      // (no editor / no selection / a non-{file,untitled} read-only view) — not
      // always "select some text" (#24's per-condition messaging).
      const reason = selectionRejection({
        hasEditor: !!editor,
        selectionEmpty: editor?.selection.isEmpty ?? true,
        scheme: editor?.document.uri.scheme ?? "",
      });
      if (reason) {
        void vscode.window.showWarningMessage(reason);
        return;
      }
      if (!editor) return; // unreachable once reason is null, but narrows the type
      const document = editor.document;
      // INV-10: a non-entered doc gets the gate warning, not a turn.
      if (!coeditingRegistry.isCoediting(document.uri)) {
        void vscode.window.showWarningMessage(NOT_COEDITING_WARNING);
        return;
      }
      const selection = editor.selection; // non-empty (selectionRejection guaranteed it)
      // Capture the selection text + anchor BEFORE prompting — the inline prompt
      // moves the cursor to the document top (where its box anchors), which would
      // otherwise collapse the selection we act on (spec §6.5 PUC-1: anchor
      // captured pre-turn so mid-turn edits can't skew it).
      const selectedText = document.getText(selection);
      const fp = buildFingerprint(document.getText(), {
        start: document.offsetAt(selection.start),
        end: document.offsetAt(selection.end),
      });
      // The instruction prompt is the multi-line split-below webview box (shared
      // with the document case, via EditFlow); the document above keeps the
      // selection highlighted while it's open. selectedText/fp were captured
      // above, so moving focus to the box doesn't affect what we edit.
      const instruction = await editFlow.askEditInstruction("Ask Claude to Edit This Selection");
      if (!instruction) return;
      const turnId = `turn-${Date.now().toString(36)}`;
      try {
        await vscode.window.withProgress(
          {
            location: vscode.ProgressLocation.Notification,
            title: "Cowriting: asking Claude…",
            cancellable: true,
          },
          async (progress, token) => {
            const { runEditTurn } = await import("./liveTurn");
            const ui = liveProgressUi.begin(instruction, progress, token);
            let turn;
            try {
              turn = await runEditTurn(instruction, selectedText, {
                onProgress: ui.onProgress,
                signal: ui.signal,
              });
            } catch (err) {
              // #60 (INV-47): a user cancel surfaces as "cancelled", not a failure.
              if (token.isCancellationRequested) {
                void vscode.window.showInformationMessage("Cowriting: Claude edit cancelled.");
                return;
              }
              throw err;
            }
            if (turn.replacement === "") {
              void vscode.window.showWarningMessage(
                "Cowriting: Claude returned an empty replacement — nothing was proposed.",
              );
              return;
            }
            if (turn.replacement === selectedText) {
              void vscode.window.showInformationMessage(
                "Cowriting: Claude proposed no change to the selection.",
              );
              return;
            }
            // F4 (INV-10): the turn ends in a PROPOSAL, not a buffer mutation.
            // The seam now fires only on accept (ProposalController, INV-9).
            const id = await proposalController.propose(
              document,
              fp,
              turn.replacement,
              {
                kind: "agent",
                id: "claude",
                agent: { sdk: "@cline/sdk", model: turn.model, sessionId: turn.sessionId },
              },
              { turnId, instruction },
            );
            if (id) {
              void vscode.window.showInformationMessage(
                "Cowriting: Claude proposed an edit — review the diff at the highlighted range (✓ accept / ✗ reject).",
              );
            }
          },
        );
      } catch (err) {
        const message = err instanceof Error ? err.message : String(err);
        void vscode.window.showErrorMessage(`Cowriting: Claude edit failed — ${message}`);
      }
    }),
  );

  // The single user-facing "Ask Claude to Edit" gesture (one command, one
  // keybinding, one menu entry). It routes to the selection flow (editSelection)
  // or the whole-document flow (editDocument) by selection/context — see
  // routeEdit. The two underlying commands stay registered for the host E2E
  // harness and the internal seams, but are hidden from the palette.
  context.subscriptions.push(
    vscode.commands.registerCommand("cowriting.edit", async (uri?: vscode.Uri) => {
      const editor = vscode.window.activeTextEditor;
      const route = routeEdit({
        hasUri: !!uri,
        uriMatchesActiveEditor: !!uri && editor?.document.uri.toString() === uri.toString(),
        hasActiveEditor: !!editor,
        selectionEmpty: editor?.selection.isEmpty ?? true,
      });
      if (route === "selection") {
        await vscode.commands.executeCommand("cowriting.editSelection");
      } else {
        await vscode.commands.executeCommand("cowriting.editDocument", uri);
      }
    }),
  );

  // Render threads + attributions for already-open editors, and on future opens.
  // INV-10: gated on the registry too — belt-and-suspenders with the per-controller
  // gates (renderAll/loadAll already early-return), but keeps the intent explicit
  // at the call site and avoids the no-op calls for a non-entered doc.
  const renderIfOpen = (doc: vscode.TextDocument) => {
    if (isAuthorable(doc.uri.scheme) && coeditingRegistry.isCoediting(doc.uri)) {
      threadController.renderAll(doc);
      attributionController.loadAll(doc);
      proposalController.renderAll(doc);
    }
  };
  vscode.workspace.textDocuments.forEach(renderIfOpen);
  context.subscriptions.push(vscode.workspace.onDidOpenTextDocument(renderIfOpen));

  return {
    threadController,
    attributionController,
    proposalController,
    versionGuard,
    diffViewController,
    trackChangesPreviewController,
    editFlow,
    sidecarRouter,
    liveProgressUi,
    editorProposalController,
    coeditingRegistry,
    scmSurfaceController,
  };
}

export function deactivate(): void {
  // Disposables registered on the context handle cleanup.
}