import { type ProcessRunner, runChecked, runProcess } from "./process.ts";
import type {
	ChangedFile,
	LinkedIssue,
	PullRequestSnapshot,
	PullRequestTarget,
} from "./types.ts";
import { PACKAGE_VERSION } from "./version.ts";

const REVIEW_MARKER_PREFIX = "<!-- pi-code-review@";
const LINKED_ISSUE_CONCURRENCY = 4;

interface GitHubContext {
	cwd: string;
	runner?: ProcessRunner;
	signal?: AbortSignal;
}

export interface ResolvedPullRequest {
	repositoryRoot: string;
	snapshot: PullRequestSnapshot;
}

interface LinkedIssueReference {
	number: number;
	url: string;
	owner: string;
	repo: string;
}

function isRecord(value: unknown): value is Record<string, unknown> {
	return typeof value === "object" && value !== null && !Array.isArray(value);
}

function stringField(record: Record<string, unknown>, key: string): string {
	const value = record[key];
	if (typeof value !== "string")
		throw new Error(`gh response is missing string field ${key}`);
	return value;
}

function numberField(record: Record<string, unknown>, key: string): number {
	const value = record[key];
	if (typeof value !== "number")
		throw new Error(`gh response is missing number field ${key}`);
	return value;
}

function parseJson(
	stdout: string,
	description: string,
): Record<string, unknown> {
	let value: unknown;
	try {
		value = JSON.parse(stdout);
	} catch {
		throw new Error(`gh returned invalid JSON for ${description}`);
	}
	if (!isRecord(value))
		throw new Error(`gh returned invalid ${description} data`);
	return value;
}

async function gh(
	context: GitHubContext,
	args: string[],
	input?: string,
): Promise<string> {
	const result = await runChecked(context.runner ?? runProcess, {
		command: "gh",
		args,
		cwd: context.cwd,
		input,
		signal: context.signal,
	});
	return result.stdout;
}

function targetArgument(target: PullRequestTarget): string[] {
	if (target.kind === "current") return [];
	if (target.kind === "number") return [String(target.number)];
	return [target.url];
}

function parseFiles(value: unknown): ChangedFile[] {
	if (!Array.isArray(value))
		throw new Error("gh response is missing changed files");
	return value.map((item) => {
		if (!isRecord(item)) throw new Error("gh returned an invalid changed file");
		const previousPath = item.previousFilename;
		const statusValue = item.changeType ?? item.status;
		if (typeof statusValue !== "string")
			throw new Error("gh response is missing changed file changeType");
		return {
			path: stringField(item, "path"),
			status: statusValue,
			additions: numberField(item, "additions"),
			deletions: numberField(item, "deletions"),
			...(typeof previousPath === "string" ? { previousPath } : {}),
		};
	});
}

function referenceRecord(
	value: unknown,
	path: string,
): Record<string, unknown> {
	if (!isRecord(value))
		throw new Error(`gh response is missing object ${path}`);
	return value;
}

function referenceString(
	record: Record<string, unknown>,
	key: string,
	path: string,
): string {
	const value = record[key];
	if (typeof value !== "string")
		throw new Error(`gh response is missing string field ${path}`);
	return value;
}

function referenceNumber(
	record: Record<string, unknown>,
	key: string,
	path: string,
): number {
	const value = record[key];
	if (typeof value !== "number")
		throw new Error(`gh response is missing number field ${path}`);
	return value;
}

function parseIssueReferences(value: unknown): LinkedIssueReference[] {
	if (value === undefined) return [];
	if (!Array.isArray(value))
		throw new Error("gh returned invalid linked issues");
	return value.map((item, index) => {
		const path = `closingIssuesReferences[${index}]`;
		const reference = referenceRecord(item, path);
		const repository = referenceRecord(
			reference.repository,
			`${path}.repository`,
		);
		const owner = referenceRecord(repository.owner, `${path}.repository.owner`);
		return {
			number: referenceNumber(reference, "number", `${path}.number`),
			url: referenceString(reference, "url", `${path}.url`),
			owner: referenceString(owner, "login", `${path}.repository.owner.login`),
			repo: referenceString(repository, "name", `${path}.repository.name`),
		};
	});
}

async function hydrateLinkedIssue(
	reference: LinkedIssueReference,
	context: GitHubContext,
): Promise<LinkedIssue> {
	const identity = `${reference.owner}/${reference.repo}#${reference.number}`;
	try {
		const raw = await gh(context, [
			"issue",
			"view",
			String(reference.number),
			"--repo",
			`${reference.owner}/${reference.repo}`,
			"--json",
			"number,title,body,url",
		]);
		const issue = parseJson(raw, `linked issue ${identity}`);
		return {
			number: numberField(issue, "number"),
			title: stringField(issue, "title"),
			body: typeof issue.body === "string" ? issue.body : "",
			url: stringField(issue, "url"),
		};
	} catch (error) {
		const detail = error instanceof Error ? error.message : String(error);
		throw new Error(`Unable to load linked issue ${identity}: ${detail}`);
	}
}

async function hydrateLinkedIssues(
	references: LinkedIssueReference[],
	context: GitHubContext,
): Promise<LinkedIssue[]> {
	const issues = new Array<LinkedIssue>(references.length);
	let nextIndex = 0;
	const worker = async () => {
		while (nextIndex < references.length) {
			const index = nextIndex;
			nextIndex += 1;
			const reference = references[index];
			if (reference)
				issues[index] = await hydrateLinkedIssue(reference, context);
		}
	};
	await Promise.all(
		Array.from(
			{ length: Math.min(LINKED_ISSUE_CONCURRENCY, references.length) },
			worker,
		),
	);
	return issues;
}

function extractBodies(value: unknown): Array<{ body: string; url?: string }> {
	if (!Array.isArray(value)) return [];
	return value.flatMap((item) => {
		if (!isRecord(item) || typeof item.body !== "string") return [];
		return [
			{
				body: item.body,
				...(typeof item.url === "string" ? { url: item.url } : {}),
			},
		];
	});
}

function findExistingReview(
	headSha: string,
	comments: unknown,
	reviews: unknown,
): string | undefined {
	const marker = ` head:${headSha} -->`;
	const match = [...extractBodies(comments), ...extractBodies(reviews)].find(
		(entry) =>
			entry.body.includes(REVIEW_MARKER_PREFIX) && entry.body.includes(marker),
	);
	return match ? (match.url ?? "existing GitHub review") : undefined;
}

async function resolveNameWithOwner(
	context: GitHubContext,
): Promise<{ owner: string; repo: string }> {
	const raw = await gh(context, ["repo", "view", "--json", "nameWithOwner"]);
	const data = parseJson(raw, "repository");
	const nameWithOwner = stringField(data, "nameWithOwner");
	const [owner, repo, extra] = nameWithOwner.split("/");
	if (!owner || !repo || extra)
		throw new Error(`Invalid GitHub repository identity: ${nameWithOwner}`);
	return { owner, repo };
}

export async function resolvePullRequest(
	target: PullRequestTarget,
	context: GitHubContext,
): Promise<ResolvedPullRequest> {
	await gh(context, ["auth", "status"]);
	const runner = context.runner ?? runProcess;
	const rootResult = await runChecked(runner, {
		command: "git",
		args: ["rev-parse", "--show-toplevel"],
		cwd: context.cwd,
		signal: context.signal,
	});
	const repositoryRoot = rootResult.stdout.trim();
	if (!repositoryRoot) throw new Error("Unable to resolve the repository root");

	const localIdentity = await resolveNameWithOwner(context);
	if (
		target.kind === "url" &&
		(localIdentity.owner.toLowerCase() !== target.owner.toLowerCase() ||
			localIdentity.repo.toLowerCase() !== target.repo.toLowerCase())
	) {
		throw new Error(
			`PR URL targets ${target.owner}/${target.repo}, but the current checkout is ${localIdentity.owner}/${localIdentity.repo}`,
		);
	}
	const identity = localIdentity;
	const fields = [
		"number",
		"url",
		"state",
		"isDraft",
		"author",
		"title",
		"body",
		"baseRefOid",
		"headRefOid",
		"files",
		"closingIssuesReferences",
		"comments",
		"reviews",
	].join(",");
	const raw = await gh(context, [
		"pr",
		"view",
		...targetArgument(target),
		"--json",
		fields,
	]);
	const data = parseJson(raw, "pull request");
	const author = data.author;
	if (!isRecord(author))
		throw new Error("gh response is missing pull request author");
	const isDraft = data.isDraft;
	if (typeof isDraft !== "boolean")
		throw new Error("gh response is missing draft state");
	const headSha = stringField(data, "headRefOid");
	const state = stringField(data, "state");
	const shouldLoadReviewContext = state === "OPEN" && !isDraft;
	const linkedIssues = shouldLoadReviewContext
		? await hydrateLinkedIssues(
				parseIssueReferences(data.closingIssuesReferences),
				context,
			)
		: [];
	const diff = shouldLoadReviewContext
		? await gh(context, ["pr", "diff", ...targetArgument(target)])
		: "";

	return {
		repositoryRoot,
		snapshot: {
			owner: identity.owner,
			repo: identity.repo,
			number: numberField(data, "number"),
			url: stringField(data, "url"),
			state,
			isDraft,
			author: stringField(author, "login"),
			title: stringField(data, "title"),
			body: typeof data.body === "string" ? data.body : "",
			baseSha: stringField(data, "baseRefOid"),
			headSha,
			files: parseFiles(data.files),
			diff,
			linkedIssues,
			existingReviewUrl: findExistingReview(
				headSha,
				data.comments,
				data.reviews,
			),
		},
	};
}

export async function verifyLocalCheckout(
	repositoryRoot: string,
	headSha: string,
	runner: ProcessRunner = runProcess,
	signal?: AbortSignal,
): Promise<void> {
	const head = await runChecked(runner, {
		command: "git",
		args: ["rev-parse", "HEAD"],
		cwd: repositoryRoot,
		signal,
	});
	if (head.stdout.trim() !== headSha) {
		throw new Error(
			`Local HEAD ${head.stdout.trim()} does not match PR head ${headSha}. Check out the PR head before review.`,
		);
	}
	const status = await runChecked(runner, {
		command: "git",
		args: ["status", "--porcelain", "--untracked-files=no"],
		cwd: repositoryRoot,
		signal,
	});
	if (status.stdout.trim()) {
		throw new Error(
			"Tracked worktree changes would make review context differ from the PR head",
		);
	}
}

export interface ReviewCommentPayload {
	path: string;
	line: number;
	side: "LEFT" | "RIGHT";
	start_line?: number;
	start_side?: "LEFT" | "RIGHT";
	body: string;
}

export interface ReviewPayload {
	commit_id: string;
	event: "COMMENT";
	body: string;
	comments: ReviewCommentPayload[];
}

export async function publishReview(
	owner: string,
	repo: string,
	pullNumber: number,
	payload: ReviewPayload,
	context: GitHubContext,
): Promise<void> {
	await gh(
		context,
		[
			"api",
			"--method",
			"POST",
			`repos/${owner}/${repo}/pulls/${pullNumber}/reviews`,
			"--input",
			"-",
		],
		JSON.stringify(payload),
	);
}

export function reviewMarker(headSha: string): string {
	return `${REVIEW_MARKER_PREFIX}${PACKAGE_VERSION} head:${headSha} -->`;
}