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 { TrackChangesPreviewController } from "./trackChangesPreview";
import { LiveProgressUi } from "./liveProgressUi";
import { InlineAskController } from "./inlineAsk";
import { EditorProposalController } from "./editorProposalController";
import { isAuthorable, routeEdit, selectionRejection } from "./workspacePath";

const CHANNEL_NAME = "Cowriting (Cline SDK)";

export interface CowritingApi {
  threadController: ThreadController;
  attributionController: AttributionController;
  proposalController: ProposalController;
  versionGuard: VersionGuard;
  diffViewController: DiffViewController;
  trackChangesPreviewController: TrackChangesPreviewController;
  sidecarRouter: SidecarRouter;
  liveProgressUi: LiveProgressUi;
  inlineAsk: InlineAskController;
  editorProposalController: EditorProposalController;
}

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);

  // The inline "Ask Claude to Edit" prompt — rendered at the selection/cursor via
  // the Comments API rather than the top-center QuickInput (see inlineAsk.ts).
  // Shared by both Ask-Claude entry points (editSelection + the preview's askClaude).
  const inlineAsk = new InlineAskController(context.subscriptions);
  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}`);
      }
    }),
  );

  // --- F6: baseline data layer (Features #17 + #19) — workspace-INDEPENDENT ---
  // The two-pane vscode.diff VIEW was removed in #34 (F10's rendered preview is
  // the single review surface); only the baseline store 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. Baseline lives in VS
  // Code's per-extension GLOBAL storage (always present), never the repo
  // (INV-19). The machine-landing advance is wired below. The controller
  // self-wires baseline capture on open.
  const baselineStorageDir = context.globalStorageUri?.fsPath;
  const baselineStore = baselineStorageDir ? new BaselineStore(baselineStorageDir) : null;
  const diffViewController = new DiffViewController(baselineStore);
  context.subscriptions.push(diffViewController);

  // 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);
  context.subscriptions.push(threadController);

  // --- F3: live attribution (Feature #6) ---
  const attributionController = new AttributionController(sidecarRouter, root, versionGuard);
  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);
  context.subscriptions.push(proposalController);

  // --- 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) and proposals (routes
  // F4 accept/reject from the webview ✓/✗).
  const trackChangesPreviewController = new TrackChangesPreviewController(
    diffViewController,
    context.extensionUri,
    attributionController,
    proposalController,
    liveProgressUi,
    inlineAsk,
  );
  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);
  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). Reuses the
  // batched F4 seam + reports applied-vs-skipped.
  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;
      }
      await trackChangesPreviewController.acceptAll(doc);
    }),
  );

  // --- F6 machine-landing wiring — now for ANY authorable doc ---
  // The seam's single machine-landing signal advances the F6 baseline (INV-18);
  // the seam can now fire on out-of-folder files too, so wire it unconditionally.
  context.subscriptions.push(
    attributionController.onDidApplyAgentEdit((e) => diffViewController.advance(e.document)),
  );

  // 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;
      const selection = editor.selection; // non-empty (selectionRejection guaranteed it)
      // The instruction prompt opens INLINE at the selection (inlineAsk), not the
      // top-center QuickInput — anchored to the text Claude will edit.
      const instruction = await inlineAsk.prompt(document.uri, selection);
      if (!instruction) return;
      const selectedText = document.getText(selection);
      // Capture the anchor BEFORE the turn (spec §6.5 PUC-1): mid-turn edits
      // can't skew it — the proposal renders wherever the target re-resolves.
      const fp = buildFingerprint(document.getText(), {
        start: document.offsetAt(selection.start),
        end: document.offsetAt(selection.end),
      });
      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.
  const renderIfOpen = (doc: vscode.TextDocument) => {
    if (isAuthorable(doc.uri.scheme)) {
      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,
    sidecarRouter,
    liveProgressUi,
    inlineAsk,
    editorProposalController,
  };
}

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