/**
 * Ask Mode Extension
 *
 * Read-only Q&A mode for safe codebase exploration.
 * Use /ask to enter ask mode and /agent to return to normal agent mode.
 *
 * Features:
 * - /ask command to enter read-only Q&A mode
 * - /agent command to return to full tool access
 * - --ask flag to start in ask mode
 * - Bash restricted to allowlisted read-only commands
 * - Injects hidden system instructions during ask mode
 * - Footer status indicator matching plan mode style
 */

import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
import type { TextContent } from "@mariozechner/pi-ai";
import { isSafeCommand } from "./utils.js";

// Tools
const ASK_MODE_TOOLS = ["read", "bash", "grep", "find", "ls"];
const NORMAL_MODE_TOOLS = ["read", "bash", "edit", "write"];

export default function askModeExtension(pi: ExtensionAPI): void {
	let askModeEnabled = false;

	pi.registerFlag("ask", {
		description: "Start in ask mode (read-only Q&A)",
		type: "boolean",
		default: false,
	});

	function updateStatus(ctx: ExtensionContext): void {
		if (askModeEnabled) {
			ctx.ui.setStatus("ask-mode", ctx.ui.theme.fg("warning", "⏸ ask"));
		} else {
			ctx.ui.setStatus("ask-mode", undefined);
		}
	}

	function persistState(): void {
		pi.appendEntry("ask-mode", {
			enabled: askModeEnabled,
		});
	}

	function enableAskMode(ctx: ExtensionContext): void {
		askModeEnabled = true;
		pi.setActiveTools(ASK_MODE_TOOLS);
		ctx.ui.notify(`Ask mode enabled. Tools: ${ASK_MODE_TOOLS.join(", ")}`);
		updateStatus(ctx);
		persistState();
	}

	function disableAskMode(ctx: ExtensionContext): void {
		askModeEnabled = false;
		pi.setActiveTools(NORMAL_MODE_TOOLS);
		ctx.ui.notify("Ask mode disabled. Full access restored.");
		updateStatus(ctx);
		persistState();
	}

	pi.registerCommand("ask", {
		description: "Enter ask mode (read-only Q&A)",
		handler: async (_args, ctx) => {
			if (askModeEnabled) {
				ctx.ui.notify("Already in ask mode", "info");
				return;
			}
			enableAskMode(ctx);
		},
	});

	pi.registerCommand("agent", {
		description: "Return to normal agent mode (full tool access)",
		handler: async (_args, ctx) => {
			if (!askModeEnabled) {
				ctx.ui.notify("Already in agent mode", "info");
				return;
			}
			disableAskMode(ctx);
		},
	});

	// Block destructive bash commands in ask mode
	pi.on("tool_call", async (event) => {
		if (!askModeEnabled || event.toolName !== "bash") return;

		const command = event.input.command as string;
		if (!isSafeCommand(command)) {
			return {
				block: true,
				reason: `Ask mode: command blocked (not allowlisted). Use /agent to exit ask mode first.\nCommand: ${command}`,
			};
		}
	});

	// Filter out stale ask mode context when not in ask mode
	pi.on("context", async (event) => {
		if (askModeEnabled) return;

		return {
			messages: event.messages.filter((m) => {
				const msg = m as { customType?: string; role?: string; content?: unknown };
				if (msg.customType === "ask-mode-context") return false;
				if (msg.role !== "user") return true;

				const content = msg.content;
				if (typeof content === "string") {
					return !content.includes("[ASK MODE ACTIVE]");
				}
				if (Array.isArray(content)) {
					return !content.some(
						(c) => c.type === "text" && (c as TextContent).text?.includes("[ASK MODE ACTIVE]"),
					);
				}
				return true;
			}),
		};
	});

	// Inject ask mode context before agent starts
	pi.on("before_agent_start", async () => {
		if (!askModeEnabled) return;

		return {
			message: {
				customType: "ask-mode-context",
				content: `[ASK MODE ACTIVE]
You are in ask mode — a read-only Q&A mode for safe codebase exploration.

Restrictions:
- You can only use: read, bash, grep, find, ls
- You CANNOT use: edit, write (file modifications are disabled)
- Bash is restricted to an allowlist of read-only commands

Answer the user's question about the codebase or files.
Do NOT propose or perform any edits.
If the user wants to make changes, suggest switching to agent mode with /agent.`,
				display: false,
			},
		};
	});

	// Restore state on session start/resume
	pi.on("session_start", async (_event, ctx) => {
		if (pi.getFlag("ask") === true) {
			askModeEnabled = true;
		}

		const entries = ctx.sessionManager.getEntries();
		const askModeEntry = entries
			.filter((e) => e.type === "custom" && e.customType === "ask-mode")
			.pop() as { data?: { enabled: boolean } } | undefined;

		if (askModeEntry?.data) {
			askModeEnabled = askModeEntry.data.enabled ?? askModeEnabled;
		}

		if (askModeEnabled) {
			pi.setActiveTools(ASK_MODE_TOOLS);
		}
		updateStatus(ctx);
	});
}

/**
 * Pure utility functions for ask mode.
 * Extracted for testability.
 */

// Destructive commands blocked in ask mode
const DESTRUCTIVE_PATTERNS = [
	/\brm\b/i,
	/\brmdir\b/i,
	/\bmv\b/i,
	/\bcp\b/i,
	/\bmkdir\b/i,
	/\btouch\b/i,
	/\bchmod\b/i,
	/\bchown\b/i,
	/\bchgrp\b/i,
	/\bln\b/i,
	/\btee\b/i,
	/\btruncate\b/i,
	/\bdd\b/i,
	/\bshred\b/i,
	/(^|[^<])>(?!>)/,
	/>>/,
	/\bnpm\s+(install|uninstall|update|ci|link|publish)/i,
	/\byarn\s+(add|remove|install|publish)/i,
	/\bpnpm\s+(add|remove|install|publish)/i,
	/\bpip\s+(install|uninstall)/i,
	/\bapt(-get)?\s+(install|remove|purge|update|upgrade)/i,
	/\bbrew\s+(install|uninstall|upgrade)/i,
	/\bgit\s+(add|commit|push|pull|merge|rebase|reset|checkout|branch\s+-[dD]|stash|cherry-pick|revert|tag|init|clone)/i,
	/\bsudo\b/i,
	/\bsu\b/i,
	/\bkill\b/i,
	/\bpkill\b/i,
	/\bkillall\b/i,
	/\breboot\b/i,
	/\bshutdown\b/i,
	/\bsystemctl\s+(start|stop|restart|enable|disable)/i,
	/\bservice\s+\S+\s+(start|stop|restart)/i,
	/\b(vim?|nano|emacs|code|subl)\b/i,
];

// Safe read-only commands allowed in ask mode
const SAFE_PATTERNS = [
	/^\s*cat\b/,
	/^\s*head\b/,
	/^\s*tail\b/,
	/^\s*less\b/,
	/^\s*more\b/,
	/^\s*grep\b/,
	/^\s*find\b/,
	/^\s*ls\b/,
	/^\s*pwd\b/,
	/^\s*echo\b/,
	/^\s*printf\b/,
	/^\s*wc\b/,
	/^\s*sort\b/,
	/^\s*uniq\b/,
	/^\s*diff\b/,
	/^\s*file\b/,
	/^\s*stat\b/,
	/^\s*du\b/,
	/^\s*df\b/,
	/^\s*tree\b/,
	/^\s*which\b/,
	/^\s*whereis\b/,
	/^\s*type\b/,
	/^\s*env\b/,
	/^\s*printenv\b/,
	/^\s*uname\b/,
	/^\s*whoami\b/,
	/^\s*id\b/,
	/^\s*date\b/,
	/^\s*cal\b/,
	/^\s*uptime\b/,
	/^\s*ps\b/,
	/^\s*top\b/,
	/^\s*htop\b/,
	/^\s*free\b/,
	/^\s*git\s+(status|log|diff|show|branch|remote|config\s+--get)/i,
	/^\s*git\s+ls-/i,
	/^\s*npm\s+(list|ls|view|info|search|outdated|audit)/i,
	/^\s*yarn\s+(list|info|why|audit)/i,
	/^\s*node\s+--version/i,
	/^\s*python\s+--version/i,
	/^\s*curl\s/i,
	/^\s*wget\s+-O\s*-/i,
	/^\s*jq\b/,
	/^\s*sed\s+-n/i,
	/^\s*awk\b/,
	/^\s*rg\b/,
	/^\s*fd\b/,
	/^\s*bat\b/,
	/^\s*eza\b/,
];

export function isSafeCommand(command: string): boolean {
	const isDestructive = DESTRUCTIVE_PATTERNS.some((p) => p.test(command));
	const isSafe = SAFE_PATTERNS.some((p) => p.test(command));
	return !isDestructive && isSafe;
}