import type { Api } from "@earendil-works/pi-ai";
import type { ExtensionAPI, ProviderModelConfig } from "@earendil-works/pi-coding-agent";
import { getGrokVersion, resolveGrokBinary } from "./binary.js";
import { PermissionBroker } from "./permissions.js";
import { createGrokStream } from "./provider.js";
import { SessionController } from "./session-controller.js";
import type { PermissionUiContext } from "./types.js";

const PROVIDER = "grok-build";
const API: Api = "grok-build-acp";

const MODEL: ProviderModelConfig = {
	id: "grok-4.5",
	name: "Grok 4.5 via official Build ACP",
	api: API,
	reasoning: true,
	thinkingLevelMap: {
		off: "none",
		minimal: "minimal",
		low: "low",
		medium: "medium",
		high: "high",
		xhigh: "xhigh",
		max: "max",
	},
	input: ["text"],
	cost: { input: 2, output: 10, cacheRead: 0.2, cacheWrite: 2 },
	contextWindow: 500_000,
	maxTokens: 128_000,
};

export default function grokBuildExtension(pi: ExtensionAPI): void {
	let cwd = process.cwd();
	let permissionContext: PermissionUiContext | undefined;
	const broker = new PermissionBroker(() => permissionContext);
	const controller = new SessionController(async (method, params, signal) => {
		if (method === "session/request_permission") return broker.handle(params, signal);
		throw new Error(`Unsupported Grok ACP interaction: ${method}`);
	});

	pi.registerProvider(PROVIDER, {
		name: "Grok Build ACP",
		baseUrl: "grok-build://local",
		apiKey: "grok-build",
		api: API,
		models: [MODEL],
		streamSimple: createGrokStream(controller, () => cwd),
	});

	pi.on("session_start", (_event, ctx) => {
		cwd = ctx.cwd;
		permissionContext = undefined;
	});

	pi.on("before_agent_start", (_event, ctx) => {
		permissionContext = ctx.model?.provider === PROVIDER ? ctx : undefined;
	});

	pi.on("agent_settled", () => {
		permissionContext = undefined;
	});

	pi.on("session_shutdown", () => {
		permissionContext = undefined;
		controller.dispose();
	});

	pi.registerCommand("grok-build", {
		description: "Grok Build ACP: /grok-build status | restart",
		handler: async (args, ctx) => {
			const action = args.trim().toLowerCase() || "status";
			if (action === "restart") {
				await controller.restart();
				ctx.ui.notify("Grok Build ACP session restarted.", "info");
				return;
			}
			if (action !== "status") {
				ctx.ui.notify(`Unknown action: ${action}. Use status or restart.`, "warning");
				return;
			}
			try {
				const binary = resolveGrokBinary();
				ctx.ui.notify(
					[
						`provider: ${PROVIDER}/${MODEL.id}`,
						`binary: ${binary}`,
						`version: ${getGrokVersion(binary)}`,
						"ACP permission mode: default (interactive, fail-closed)",
						"always-approve: disabled",
					].join("\n"),
					"info",
				);
			} catch (error) {
				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
			}
		},
	});
}

export { API, MODEL, PROVIDER };