import * as vscode from 'vscode';
import {
	getCliClient,
	disposeCliClient,
	checkAuth,
	promptLogin,
	disposeAuth,
	detectProject,
	watchProjectConfig,
	disposeProject,
	requireAuth,
} from './core';
import { log, disposeLogger } from './core/logger';
import { registerReadonlyDocumentProvider } from './core/readonlyDocument';
import { registerAgentExplorer } from './features/agentExplorer';
import { registerDataExplorer } from './features/dataExplorer';
import { registerDeploymentExplorer } from './features/deploymentExplorer';
import { registerSandboxExplorer } from './features/sandboxExplorer';
import { disposeSandboxManager } from './core/sandboxManager';
import { registerDevServerCommands } from './features/devServer';
import { registerWorkbenchCommands } from './features/workbench';
import {
	registerChatParticipant,
	registerCliTool,
	registerChatContextProvider,
	registerAgentTools,
} from './features/chat';
import { registerCodeLens } from './features/codeLens';
import { registerCustomAgentCommands } from './features/customAgents';

export async function activate(context: vscode.ExtensionContext): Promise<void> {
	log('Extension activating...');

	watchProjectConfig(context);
	registerReadonlyDocumentProvider(context);

	const project = await detectProject();
	log(`Project: ${project ? project.projectId : 'none'}`);

	const authStatus = await checkAuth();
	log(
		`Auth: ${authStatus.state}${authStatus.user ? ` (${authStatus.user.firstName} ${authStatus.user.lastName})` : ''}`
	);

	if (authStatus.state === 'cli-missing' || authStatus.state === 'unauthenticated') {
		void promptLogin();
	}

	registerAuthCommands(context);
	registerAiCommands(context);
	registerSetupCommands(context);
	registerDeployCommand(context);
	registerOrgRegionCommands(context);

	const walkthroughShown = context.globalState.get('agentuity.walkthroughShown', false);
	if (!walkthroughShown) {
		await context.globalState.update('agentuity.walkthroughShown', true);
		void vscode.commands.executeCommand(
			'workbench.action.openWalkthrough',
			'agentuity.agentuity#gettingStarted',
			false
		);
	}

	const agentProvider = registerAgentExplorer(context);
	const dataProvider = registerDataExplorer(context);
	const deploymentProvider = registerDeploymentExplorer(context);
	const sandboxProvider = registerSandboxExplorer(context);

	registerRefreshCommands(context, {
		agents: agentProvider,
		data: dataProvider,
		deployments: deploymentProvider,
		sandboxes: sandboxProvider,
	});

	context.subscriptions.push({
		dispose: () => {
			agentProvider.dispose();
			dataProvider.dispose();
			deploymentProvider.dispose();
			sandboxProvider.dispose();
		},
	});

	registerDevServerCommands(context);
	registerWorkbenchCommands(context);
	registerChatParticipant(context);
	registerCliTool(context);
	registerChatContextProvider(context);
	registerAgentTools(context);
	registerCustomAgentCommands(context);
	registerCodeLens(context);

	log('Extension activated');
}

function registerAuthCommands(context: vscode.ExtensionContext): void {
	context.subscriptions.push(
		vscode.commands.registerCommand('agentuity.login', () => {
			const terminal = vscode.window.createTerminal('Agentuity Login');
			terminal.sendText('agentuity auth login');
			terminal.show();

			vscode.window
				.showInformationMessage(
					'Complete login in the terminal, then refresh the extension.',
					'Refresh'
				)
				.then((action) => {
					if (action === 'Refresh') {
						void checkAuth();
					}
				});
		})
	);

	context.subscriptions.push(
		vscode.commands.registerCommand('agentuity.logout', async () => {
			const cli = getCliClient();
			const result = await cli.exec(['auth', 'logout']);

			if (result.success) {
				vscode.window.showInformationMessage('Logged out of Agentuity');
				await checkAuth();
			} else {
				vscode.window.showErrorMessage(`Logout failed: ${result.error}`);
			}
		})
	);

	context.subscriptions.push(
		vscode.commands.registerCommand('agentuity.whoami', async () => {
			const cli = getCliClient();
			const result = await cli.whoami();

			if (result.success && result.data) {
				const user = result.data;
				vscode.window.showInformationMessage(
					`Logged in as: ${user.firstName} ${user.lastName}`
				);
			} else {
				vscode.window.showWarningMessage('Not logged in to Agentuity');
			}
		})
	);
}

function registerAiCommands(context: vscode.ExtensionContext): void {
	context.subscriptions.push(
		vscode.commands.registerCommand('agentuity.getAiCapabilities', async () => {
			if (!(await requireAuth())) {
				return undefined;
			}

			const cli = getCliClient();
			const result = await cli.getAiCapabilities();

			if (result.success) {
				return result.data;
			} else {
				vscode.window.showErrorMessage(`Failed to get capabilities: ${result.error}`);
				return undefined;
			}
		})
	);

	context.subscriptions.push(
		vscode.commands.registerCommand('agentuity.getAiSchema', async () => {
			if (!(await requireAuth())) {
				return undefined;
			}

			const cli = getCliClient();
			const result = await cli.getAiSchema();

			if (result.success) {
				return result.data;
			} else {
				vscode.window.showErrorMessage(`Failed to get schema: ${result.error}`);
				return undefined;
			}
		})
	);
}

function registerSetupCommands(context: vscode.ExtensionContext): void {
	context.subscriptions.push(
		vscode.commands.registerCommand('agentuity.installCli', () => {
			void vscode.env.openExternal(
				vscode.Uri.parse('https://agentuity.dev/Get-Started/quickstart')
			);
		})
	);

	context.subscriptions.push(
		vscode.commands.registerCommand('agentuity.createProject', () => {
			const terminal = vscode.window.createTerminal('Agentuity');
			terminal.sendText('agentuity project new');
			terminal.show();
		})
	);
}

function registerDeployCommand(context: vscode.ExtensionContext): void {
	context.subscriptions.push(
		vscode.commands.registerCommand('agentuity.deploy', async () => {
			if (!(await requireAuth())) {
				return;
			}

			const answer = await vscode.window.showWarningMessage(
				'Deploy to Agentuity Cloud?',
				{ modal: true },
				'Deploy'
			);

			if (answer !== 'Deploy') {
				return;
			}

			const terminal = vscode.window.createTerminal('Agentuity Deploy');
			terminal.sendText('agentuity cloud deploy');
			terminal.show();
		})
	);
}

function registerOrgRegionCommands(context: vscode.ExtensionContext): void {
	// Organization picker
	context.subscriptions.push(
		vscode.commands.registerCommand('agentuity.org.select', async () => {
			if (!(await requireAuth())) {
				return;
			}

			const cli = getCliClient();
			const result = await cli.orgList();

			if (!result.success || !result.data || result.data.length === 0) {
				vscode.window.showWarningMessage('No organizations found');
				return;
			}

			const items = result.data.map((org) => ({
				label: org.name,
				description: org.id,
				orgId: org.id,
			}));

			const selected = await vscode.window.showQuickPick(items, {
				placeHolder: 'Select an organization',
				title: 'Switch Organization',
			});

			if (!selected) {
				return;
			}

			const selectResult = await cli.orgSelect(selected.orgId);
			if (selectResult.success) {
				vscode.window.showInformationMessage(`Switched to organization: ${selected.label}`);
				// Refresh all explorers
				void vscode.commands.executeCommand('agentuity.refresh');
			} else {
				vscode.window.showErrorMessage(`Failed to switch organization: ${selectResult.error}`);
			}
		})
	);

	// Region picker
	context.subscriptions.push(
		vscode.commands.registerCommand('agentuity.region.select', async () => {
			if (!(await requireAuth())) {
				return;
			}

			const cli = getCliClient();
			const result = await cli.regionList();

			if (!result.success || !result.data || result.data.length === 0) {
				vscode.window.showWarningMessage('No regions available');
				return;
			}

			const items = result.data.map((region) => ({
				label: region.description,
				description: region.region,
				region: region.region,
			}));

			const selected = await vscode.window.showQuickPick(items, {
				placeHolder: 'Select a region',
				title: 'Switch Region',
			});

			if (!selected) {
				return;
			}

			const selectResult = await cli.regionSelect(selected.region);
			if (selectResult.success) {
				vscode.window.showInformationMessage(`Switched to region: ${selected.label}`);
				// Refresh sandbox explorer since it's region-sensitive
				void vscode.commands.executeCommand('agentuity.sandbox.refresh');
			} else {
				vscode.window.showErrorMessage(`Failed to switch region: ${selectResult.error}`);
			}
		})
	);
}

function registerRefreshCommands(
	context: vscode.ExtensionContext,
	providers: {
		agents: ReturnType<typeof registerAgentExplorer>;
		data: ReturnType<typeof registerDataExplorer>;
		deployments: ReturnType<typeof registerDeploymentExplorer>;
		sandboxes: ReturnType<typeof registerSandboxExplorer>;
	}
): void {
	context.subscriptions.push(
		vscode.commands.registerCommand('agentuity.refresh', async () => {
			await checkAuth();
			await detectProject();
			providers.agents.forceRefresh();
			providers.data.refresh();
			providers.deployments.forceRefresh();
			providers.sandboxes.forceRefresh();
			vscode.window.showInformationMessage('Agentuity refreshed');
		})
	);

	context.subscriptions.push(
		vscode.commands.registerCommand('agentuity.agents.refresh', () => {
			void providers.agents.forceRefresh();
		})
	);

	context.subscriptions.push(
		vscode.commands.registerCommand('agentuity.deployments.refresh', () => {
			void providers.deployments.forceRefresh();
		})
	);

	context.subscriptions.push(
		vscode.commands.registerCommand('agentuity.data.refresh', () => {
			providers.data.refresh();
		})
	);

	context.subscriptions.push(
		vscode.commands.registerCommand('agentuity.sandbox.refresh', () => {
			void providers.sandboxes.forceRefresh();
		})
	);
}

export function deactivate(): void {
	disposeCliClient();
	disposeAuth();
	disposeProject();
	disposeSandboxManager();
	disposeLogger();
}