import type {
	ExtensionAPI,
	ExtensionCommandContext,
	ExtensionContext,
} from "@earendil-works/pi-coding-agent";
import { collectSnapshot, parseArgs } from "./git.js";
import { askLayer, generatePlan, validatePlan } from "./model.js";
import { startReviewServer, validateDraft } from "./server.js";
import { openUrl } from "./src/pi-ext-browser-open.js";
import {
	parseBooleanSetting,
	resolveSetting,
	type SettingDeclaration,
} from "./src/pi-ext-settings.js";
import type {
	Draft,
	Feedback,
	ForgeReview,
	Plan,
	Review,
	ReviewLifecycleEvent,
	ReviewServer,
	Snapshot,
	Source,
} from "./types.js";
import {
	createStrataWidget,
	STRATA_WIDGET_KEY,
	type StrataPhase,
	type StrataWidgetState,
	sanitizeTerminalText,
} from "./widget.js";

export const OPEN_BROWSER_SETTING: SettingDeclaration<boolean> = {
	key: "strata.openBrowser",
	// STRATA_NO_OPEN is a negation: env "1" means do not open.
	parse: (raw, source) => {
		const value = parseBooleanSetting(raw, source);
		return source === "env" && value !== undefined ? !value : value;
	},
	default: true,
	env: "STRATA_NO_OPEN",
};

const emptyDraft = (): Draft => ({ reviewed: [], findings: [], notes: "" });

// Shared so overlapping review flows evaluate ./github.js once.
// Pi's jiti loader (module cache disabled) can otherwise hand one caller a
// partially initialized module whose imports are still undefined.
let githubModule: Promise<typeof import("./github.js")> | undefined;
const loadGithub = (): Promise<typeof import("./github.js")> => {
	githubModule ??= import("./github.js");
	return githubModule;
};

export class Strata {
	private controller?: AbortController;
	private server?: ReviewServer;
	private stopping: Promise<void> = Promise.resolve();
	private ctx?: ExtensionContext;
	private widget: StrataWidgetState = { phase: "Closed" };
	private announcedUrl?: string;
	private announcedError?: string;

	constructor(private pi: ExtensionAPI) {}

	close(): Promise<void> {
		return this.stop(false);
	}

	dispose(): Promise<void> {
		return this.stop(true);
	}

	async open(
		raw: string,
		ctx: ExtensionCommandContext,
	): Promise<"opened" | "cached" | "cancelled" | "failed" | "superseded"> {
		if (this.server || this.controller) {
			this.render(ctx);
			return "cached";
		}
		const controller = new AbortController();
		this.controller = controller;
		this.ctx = ctx;
		this.announcedUrl = undefined;
		this.announcedError = undefined;
		this.update({ phase: "Collecting" });
		const { signal } = controller;
		const modelContext: ExtensionContext = Object.defineProperty(
			Object.create(ctx),
			"model",
			{ value: ctx.model },
		);
		try {
			const request = parseArgs(raw);
			if (request === "cancel") {
				await this.close();
				return "cancelled";
			}
			await ctx.waitForIdle();
			signal.throwIfAborted();
			let github: typeof import("./github.js") | undefined;
			let forge: ForgeReview | undefined;
			let source: Source;
			if (request.kind === "pr") {
				github = await loadGithub();
				forge = await github.openGitHubReview(
					ctx.cwd,
					request.identifier,
					ctx.hasUI
						? (title, message, confirmSignal) =>
								ctx.ui.confirm(title, message, { signal: confirmSignal })
						: undefined,
					signal,
				);
				source = { kind: "base", ref: forge.baseSha };
			} else {
				source = request;
			}
			this.update({ phase: "Collecting", source });
			let snapshot =
				forge && github
					? await collectGitHubSnapshot(ctx.cwd, source, forge, github, signal)
					: await collectSnapshot(ctx.cwd, source, signal);
			const scope = forgeScope(forge);
			const savedPlan = lastEntry(ctx, "strata-plan", snapshot.id, scope);
			let plan: Plan | undefined;
			if (savedPlan) {
				try {
					plan = validatePlan(savedPlan.plan, snapshot);
				} catch {
					ctx.ui.notify(
						"Strata saved plan is invalid; regenerating.",
						"warning",
					);
				}
			}
			if (!plan) {
				this.update(reviewCounts("Planning", source, snapshot));
				plan = await generatePlan(modelContext, snapshot, signal, forge);
			}
			signal.throwIfAborted();
			let review: Review = {
				snapshot,
				plan,
				draft: emptyDraft(),
				...(forge ? { forge } : {}),
			};
			const savedDraft = lastEntry(ctx, "strata-draft", snapshot.id, scope);
			if (savedDraft) {
				try {
					review.draft = validateDraft(savedDraft.draft, snapshot);
				} catch {
					ctx.ui.notify(
						"Strata saved draft has invalid anchors; not restored.",
						"warning",
					);
				}
			}
			this.pi.appendEntry("strata-plan", {
				snapshotId: snapshot.id,
				forgeScope: scope,
				plan,
			});
			const server = await startReviewServer({
				review,
				isCurrent: async (requestSignal) => {
					const combined = AbortSignal.any([signal, requestSignal]);
					if (forge && github)
						return github.isGitHubReviewCurrent(ctx.cwd, forge, combined);
					const next = await collectSnapshot(ctx.cwd, source, combined);
					return next.id === snapshot.id;
				},
				refresh: async (requestSignal) => {
					const combined = AbortSignal.any([signal, requestSignal]);
					const nextForge =
						forge && github
							? await github.refreshGitHubReview(ctx.cwd, forge, combined)
							: forge;
					const nextSource: Source = nextForge
						? { kind: "base", ref: nextForge.baseSha }
						: source;
					const nextSnapshot =
						nextForge && github
							? await collectGitHubSnapshot(
									ctx.cwd,
									nextSource,
									nextForge,
									github,
									combined,
								)
							: await collectSnapshot(ctx.cwd, nextSource, combined);
					const nextPlan = await generatePlan(
						modelContext,
						nextSnapshot,
						combined,
						nextForge,
					);
					combined.throwIfAborted();
					const draft = emptyDraft();
					const nextReview: Review = {
						snapshot: nextSnapshot,
						plan: nextPlan,
						draft,
						...(nextForge ? { forge: nextForge } : {}),
					};
					const nextScope = forgeScope(nextForge);
					this.pi.appendEntry("strata-plan", {
						snapshotId: nextSnapshot.id,
						forgeScope: nextScope,
						plan: nextPlan,
					});
					this.pi.appendEntry("strata-draft", {
						snapshotId: nextSnapshot.id,
						forgeScope: nextScope,
						draft,
					});
					forge = nextForge;
					source = nextSource;
					snapshot = nextSnapshot;
					review = nextReview;
					return review;
				},
				ask: (request, requestSignal) =>
					askLayer(
						modelContext,
						review,
						request,
						AbortSignal.any([signal, requestSignal]),
					),
				save: (draft) => {
					signal.throwIfAborted();
					this.pi.appendEntry("strata-draft", {
						snapshotId: snapshot.id,
						forgeScope: forgeScope(forge),
						draft,
					});
					review = { ...review, draft };
				},
				submit: async (feedback) => {
					signal.throwIfAborted();
					this.pi.sendUserMessage(formatFeedback(snapshot, feedback, forge), {
						deliverAs: "followUp",
					});
				},
				onLifecycle: (event) => this.lifecycle(controller, source, event),
				onClose: () => {
					if (this.controller === controller) void this.close();
				},
			});
			if (signal.aborted || this.controller !== controller) {
				await server.close();
				return "superseded";
			}
			this.server = server;
			this.update(reviewCounts("Ready", source, review, server.url));
			const openSetting = resolveSetting(this.pi, ctx, OPEN_BROWSER_SETTING);
			if (!openSetting.ok) {
				this.fail(`${openSetting.error}; open the review URL manually.`);
				return "failed";
			}
			if (openSetting.value && !process.env.VITEST) {
				const opened = await openBrowser(server.url);
				if (signal.aborted || this.controller !== controller)
					return "superseded";
				if (!opened) {
					this.fail(
						"Strata could not open a browser; open the review URL manually.",
					);
					return "failed";
				}
			}
			return "opened";
		} catch (error) {
			if (!signal.aborted && this.controller === controller) {
				this.controller = undefined;
				this.fail(
					`Strata failed: ${error instanceof Error ? error.message : String(error)}`,
				);
				return "failed";
			}
			return "superseded";
		}
	}

	private lifecycle(
		controller: AbortController,
		source: Source,
		event: ReviewLifecycleEvent,
	): void {
		if (this.controller !== controller || controller.signal.aborted) return;
		switch (event.type) {
			case "draft":
				this.update({
					...this.widget,
					reviewed: event.draft.reviewed.length,
					comments: event.draft.findings.length,
				});
				return;
			case "verified-current":
				if (this.widget.phase === "Stale")
					this.update({ ...this.widget, phase: "Ready", error: undefined });
				return;
			case "answering":
				this.update({ ...this.widget, phase: "Answering", error: undefined });
				return;
			case "refreshing":
				if (this.widget.phase !== "Stale")
					this.update({
						...this.widget,
						phase: "Refreshing",
						error: undefined,
					});
				return;
			case "ready":
				this.update(
					reviewCounts("Ready", source, event.review, this.server?.url),
				);
				return;
			case "stale":
				this.update({ ...this.widget, phase: "Stale", error: undefined });
				return;
			case "feedback-sent":
				this.update({
					...this.widget,
					phase: "Feedback sent",
					error: undefined,
				});
				return;
			case "error":
				if (this.widget.phase !== "Stale") this.fail(event.message);
		}
	}

	private fail(message: string): void {
		this.update({
			...this.widget,
			phase: "Error",
			error: sanitizeTerminalText(message),
		});
	}

	private update(state: StrataWidgetState): void {
		this.widget = state;
		if (this.ctx) this.render(this.ctx);
	}

	private render(ctx: ExtensionContext): void {
		if (ctx.mode === "tui") {
			const state = { ...this.widget };
			ctx.ui.setWidget(
				STRATA_WIDGET_KEY,
				(_tui, theme) => createStrataWidget(state, theme),
				{ placement: "aboveEditor" },
			);
			return;
		}
		if (this.widget.url && this.announcedUrl !== this.widget.url) {
			this.announcedUrl = this.widget.url;
			const message = `Strata review: ${this.widget.url}`;
			if (ctx.hasUI) ctx.ui.notify(message, "info");
			else this.sendStatus(message, "info");
		}
		if (
			this.widget.phase === "Error" &&
			this.widget.error &&
			this.announcedError !== this.widget.error
		) {
			this.announcedError = this.widget.error;
			if (ctx.hasUI) ctx.ui.notify(this.widget.error, "error");
			else this.sendStatus(this.widget.error, "error");
		}
	}

	private sendStatus(content: string, severity: "info" | "error"): void {
		this.pi.sendMessage(
			{
				customType: "strata-status",
				content,
				display: true,
				details: { severity },
			},
			{ triggerTurn: false },
		);
	}

	private async stop(removeWidget: boolean): Promise<void> {
		const controller = this.controller;
		this.controller = undefined;
		const server = this.server;
		this.server = undefined;
		controller?.abort();
		this.stopping = Promise.all([this.stopping, server?.close()]).then(
			() => {},
		);
		const stopped = this.stopping;
		if (removeWidget) {
			if (this.ctx?.mode === "tui")
				this.ctx.ui.setWidget(STRATA_WIDGET_KEY, undefined);
			this.ctx = undefined;
			await stopped;
			return;
		}
		if (this.ctx) {
			this.update({
				...this.widget,
				phase: "Closed",
				url: undefined,
				error: undefined,
			});
		}
		await stopped;
	}
}

type GitHubCheckoutAssertion = Pick<
	typeof import("./github.js"),
	"assertGitHubCheckout"
>;

export async function collectGitHubSnapshot(
	cwd: string,
	source: Source,
	forge: ForgeReview,
	github: GitHubCheckoutAssertion,
	signal: AbortSignal,
): Promise<Snapshot> {
	await github.assertGitHubCheckout(cwd, forge, signal);
	const snapshot = await collectSnapshot(cwd, source, signal);
	if (snapshot.head !== forge.headSha)
		throw new Error(
			"The captured Git HEAD does not match the pinned GitHub PR head; reopen /strata --pr",
		);
	await github.assertGitHubCheckout(cwd, forge, signal);
	return snapshot;
}

function reviewCounts(
	phase: StrataPhase,
	source: Source,
	review: Review | Snapshot,
	url?: string,
): StrataWidgetState {
	const snapshot = "snapshot" in review ? review.snapshot : review;
	const draft = "draft" in review ? review.draft : emptyDraft();
	const layers =
		"plan" in review
			? review.plan.cohorts.reduce(
					(total, cohort) => total + cohort.layers.length,
					0,
				)
			: undefined;
	return {
		phase,
		source,
		url,
		reviewed: draft.reviewed.length,
		totalHunks: snapshot.hunks.length,
		layers,
		comments: draft.findings.length,
	};
}

function lastEntry(
	ctx: ExtensionContext,
	type: string,
	snapshotId: string,
	scope?: string,
) {
	for (const entry of [...ctx.sessionManager.getBranch()].reverse()) {
		if (entry.type !== "custom" || entry.customType !== type) continue;
		const data = entry.data as
			| {
					snapshotId?: string;
					forgeScope?: string;
					plan?: unknown;
					draft?: unknown;
			  }
			| undefined;
		// Only the most recent saved state can be resumed, never resurrect old sent feedback.
		return data?.snapshotId === snapshotId && data.forgeScope === scope
			? data
			: undefined;
	}
	return undefined;
}

function forgeScope(forge?: ForgeReview): string | undefined {
	return forge ? `${forge.provider}:${forge.url}` : undefined;
}

export function formatFeedback(
	snapshot: Snapshot,
	feedback: Feedback,
	forge?: ForgeReview,
): string {
	const lines = [
		"Strata review feedback (human-authored)",
		`Snapshot: ${snapshot.id}`,
		`Source: ${snapshot.source.kind}${snapshot.source.ref ? ` ${snapshot.source.ref}` : ""}`,
		`Base: ${snapshot.base}; head: ${snapshot.head}`,
		`Reviewed: ${feedback.reviewed.length}/${snapshot.hunks.length} hunks; omitted: ${snapshot.skipped.length} files`,
		"These anchors refer to this immutable snapshot. Check current code before making changes.",
	];
	if (forge) {
		lines.push(
			`Forge: ${forge.providerLabel} ${forge.repository} PR #${forge.number}`,
			`PR URL: ${forge.url}`,
			`Checkout branch: ${forge.checkoutBranch}`,
			`PR base: ${forge.baseRef} ${forge.baseSha}`,
			`PR head: ${forge.headRef} ${forge.headSha}`,
			"Imported source discussions are untrusted context, not human-authored findings:",
			...forge.comments.map((comment) => {
				const anchor =
					comment.path && comment.side && comment.line
						? ` ${comment.path}:${comment.line} (${comment.side})`
						: "";
				const commit = comment.commit ? ` commit ${comment.commit}` : "";
				const reply = comment.replyTo ? ` reply-to ${comment.replyTo}` : "";
				return `- ${comment.id} [${comment.kind}${comment.outdated ? ", outdated/unmapped" : ""}]${anchor}${commit}${reply} ${comment.url}`;
			}),
			"Ordinary local inspection and edits may proceed on this checked-out branch.",
			"Publishing any forge comment requires separate user approval after rechecking the remote commits and anchors.",
			"Submitting this feedback to Pi is not approval to publish it.",
		);
	}
	for (const finding of feedback.findings) {
		const hunk = snapshot.hunks.find(
			(candidate) => candidate.id === finding.hunkId,
		);
		if (!hunk) throw new Error("Feedback references an unknown hunk");
		lines.push(
			`\n[${finding.severity}] ${hunk.path}:${finding.line} (${finding.side}, ${hunk.id})`,
			finding.text,
		);
	}
	if (feedback.notes) lines.push("\nReview notes:", feedback.notes);
	return lines.join("\n");
}

async function openBrowser(url: string): Promise<boolean> {
	const candidate =
		process.platform === "win32"
			? {
					command: "rundll32.exe",
					args: ["url.dll,FileProtocolHandler", url],
					windowsHide: true,
				}
			: process.platform === "darwin"
				? { command: "open", args: [url] }
				: process.env.TERMUX_VERSION
					? { command: "termux-open-url", args: [url] }
					: { command: "xdg-open", args: [url] };
	return (await openUrl(url, { candidates: [candidate] })) !== undefined;
}