import * as readline from 'node:readline';
import type { ManagedSession } from '../../session/index.js';
import type { ModelClient, TokenUsage } from '../../models/types.js';
import type { ModelRouter, ModelTier } from '../../models/router.js';
import type { NativeAgent } from '../../backends/native/agent.js';
import { parseCommand, getHelpText, resolveModelAlias, getCommandCompletions, getCommandTooltip, type Command } from './commands.js';
import { renderMarkdown } from './markdown.js';
import type { ModelConfig } from '../../config/schema.js';
import { OllamaClient, LlamaCppClient } from '../../models/index.js';
import { createClientFromConfig } from '../../daemon/index.js';
import { loginGitHub } from '../../auth/index.js';
import type { PairingManager } from '../../channels/pairing.js';
import { getColoredBanner } from './banner.js';

export { parseCommand, type Command };

// ANSI color codes
const colors = {
  reset: '\x1b[0m',
  bold: '\x1b[1m',
  dim: '\x1b[2m',
  blue: '\x1b[34m',
  orange: '\x1b[38;5;208m',
  gray: '\x1b[90m',
  bgDark: '\x1b[48;5;234m',
};

export function formatPrompt(state: 'default' | 'thinking'): string {
  if (state === 'thinking') {
    return `${colors.orange}flynn...${colors.reset} `;
  }
  return `${colors.orange}${colors.bold}flynn>${colors.reset} `;
}

export interface MinimalTuiConfig {
  session: ManagedSession;
  modelClient: ModelClient;
  modelRouter?: ModelRouter;
  systemPrompt: string;
  agent?: NativeAgent;
  onFullscreen?: () => void;
  onTransfer?: (target: string) => void;
  localProviders?: Record<string, ModelConfig>;
  currentLocalProvider?: string;
  pairingManager?: PairingManager;
}

export class MinimalTui {
  private rl: readline.Interface | null = null;
  private running = false;
  private totalUsage: TokenUsage = { inputTokens: 0, outputTokens: 0 };
  private currentHint = '';
  private lastLine = '';

  constructor(private config: MinimalTuiConfig) {}

  private showHint(line: string): void {
    if (!line.startsWith('/')) {
      this.clearHint();
      return;
    }

    const completions = getCommandCompletions(line);
    const tooltip = getCommandTooltip(line);
    
    let hint = '';
    
    if (completions.length === 1 && completions[0] !== line) {
      // Show the remaining part of the completion as a hint
      hint = completions[0].slice(line.length);
    }
    
    // Add tooltip if available
    if (tooltip) {
      hint += `  ${colors.gray}— ${tooltip}${colors.reset}`;
    } else if (completions.length > 1) {
      hint += `  ${colors.gray}[${completions.length} options, Tab to complete]${colors.reset}`;
    }
    
    if (hint && hint !== this.currentHint) {
      this.clearHint();
      this.currentHint = hint;
      // Save cursor, write dim hint, restore cursor
      process.stdout.write(`\x1b[s${colors.dim}${hint}${colors.reset}\x1b[u`);
    } else if (!hint) {
      this.clearHint();
    }
  }

  private clearHint(): void {
    if (this.currentHint) {
      // Clear from cursor to end of line
      process.stdout.write('\x1b[K');
      this.currentHint = '';
    }
  }

  async start(): Promise<void> {
    this.running = true;

    this.rl = readline.createInterface({
      input: process.stdin,
      output: process.stdout,
      completer: (line: string) => {
        const completions = getCommandCompletions(line);
        return [completions, line];
      },
    });

    // Listen for line changes to show hints
    process.stdin.on('keypress', () => {
      // Small delay to let readline update the line
      setImmediate(() => {
        if (this.rl) {
          const line = (this.rl as readline.Interface & { line?: string }).line || '';
          if (line !== this.lastLine) {
            this.lastLine = line;
            this.showHint(line);
          }
        }
      });
    });

    // Enable keypress events
    if (process.stdin.isTTY) {
      readline.emitKeypressEvents(process.stdin);
    }

    console.log(getColoredBanner());
    console.log(`\n${colors.orange}${colors.bold}Flynn TUI${colors.reset} ${colors.dim}(minimal mode)${colors.reset}`);
    console.log(`${colors.gray}Type /help for commands, /fullscreen for panel mode${colors.reset}\n`);

    await this.promptLoop();
  }

  private async promptLoop(): Promise<void> {
    while (this.running && this.rl) {
      this.lastLine = '';
      this.currentHint = '';
      const input = await this.prompt(formatPrompt('default'));
      this.clearHint();
      const command = parseCommand(input);

      if (!command) {
        continue;
      }

      await this.handleCommand(command);
    }
  }

  private prompt(promptText: string): Promise<string> {
    return new Promise((resolve) => {
      if (!this.rl) {
        resolve('');
        return;
      }
      const onClose = () => resolve('');
      this.rl.once('close', onClose);
      this.rl.question(promptText, (answer) => {
        this.rl?.removeListener('close', onClose);
        resolve(answer);
      });
    });
  }

  private async handleCommand(command: Command): Promise<void> {
    switch (command.type) {
      case 'quit':
        this.stop();
        break;

      case 'reset':
        this.config.session.clear();
        this.totalUsage = { inputTokens: 0, outputTokens: 0 };
        console.log(`${colors.gray}Session cleared.${colors.reset}\n`);
        break;

      case 'help':
        console.log(getHelpText() + '\n');
        break;

      case 'status':
        this.printStatus();
        break;

      case 'fullscreen':
        this.config.onFullscreen?.();
        break;

      case 'model':
        this.handleModelCommand(command.name, command.providerModel);
        break;

      case 'backend':
        this.handleBackendCommand(command.provider);
        break;

      case 'login':
        await this.handleLoginCommand(command.provider);
        break;

      case 'pair':
        this.handlePairCommand(command.action, command.args);
        break;

      case 'transfer':
        this.config.onTransfer?.(command.target);
        break;

      case 'message':
        await this.handleMessage(command.content);
        break;
    }
  }

  private handleModelCommand(name?: string, providerModel?: string): void {
    const router = this.config.modelRouter;
    if (!router) {
      console.log(`${colors.gray}Model switching not available.${colors.reset}\n`);
      return;
    }

    // /model <tier> <provider/model> — change a tier's provider and model
    if (name && providerModel) {
      const tier = resolveModelAlias(name);
      const slashIdx = providerModel.indexOf('/');
      if (slashIdx === -1) {
        console.log(`${colors.gray}Invalid format. Use provider/model (e.g. anthropic/claude-sonnet-4)${colors.reset}\n`);
        return;
      }
      const provider = providerModel.slice(0, slashIdx);
      const model = providerModel.slice(slashIdx + 1);

      try {
        const client = createClientFromConfig({ provider: provider as 'anthropic', model });
        router.setClient(tier, client, providerModel);
        console.log(`${colors.gray}Set ${tier} to:${colors.reset} ${providerModel}\n`);
      } catch (error) {
        const message = error instanceof Error ? error.message : String(error);
        console.log(`${colors.gray}Failed to create client:${colors.reset} ${message}\n`);
      }
      return;
    }

    // /model — show all tiers with labels
    if (!name) {
      const current = router.getTier();
      const available = router.getAvailableTiers();
      const labels = router.getAllLabels();
      console.log(`${colors.gray}Active tier:${colors.reset} ${current}`);
      for (const tier of available) {
        const label = labels[tier] ?? 'unknown';
        const marker = tier === current ? ' ←' : '';
        console.log(`  ${tier}: ${label}${marker}`);
      }
      console.log();
      return;
    }

    // /model <tier> — switch active tier
    const tier = resolveModelAlias(name);
    if (router.setTier(tier)) {
      // Also update the agent tier so chatWithRouter uses the correct client
      if (this.config.agent) {
        this.config.agent.setModelTier(tier);
      }
      console.log(`${colors.gray}Switched to model:${colors.reset} ${tier}\n`);
    } else {
      console.log(`${colors.gray}Model not available:${colors.reset} ${name}\n`);
    }
  }

  private handleBackendCommand(provider?: string): void {
    const router = this.config.modelRouter;
    if (!router) {
      console.log('Backend switching not available.\n');
      return;
    }

    if (!provider) {
      const current = router.getLocalProviderName() ?? this.config.currentLocalProvider ?? 'unknown';
      const available = this.getAvailableBackends();
      console.log(`Current local backend: ${current}`);
      console.log(`Available: ${available.join(', ')}\n`);
      return;
    }

    const providerConfig = this.config.localProviders?.[provider];
    if (!providerConfig) {
      const available = this.getAvailableBackends();
      console.log(`Backend '${provider}' not configured.`);
      console.log(`Available: ${available.join(', ')}\n`);
      return;
    }

    const client = this.createLocalClient(providerConfig);
    if (!client) {
      console.log(`Failed to create client for '${provider}'.\n`);
      return;
    }

    router.setLocalClient(client, provider);
    console.log(`Switched to backend: ${provider}\n`);
  }

  private async handleLoginCommand(provider?: string): Promise<void> {
    const target = provider ?? 'github';
    if (target !== 'github') {
      console.log(`${colors.gray}Unknown login provider:${colors.reset} ${target}. Only 'github' is supported.\n`);
      return;
    }

    console.log(`${colors.gray}Starting GitHub OAuth device flow...${colors.reset}`);

    try {
      await loginGitHub((userCode, verificationUri) => {
        console.log('');
        console.log(`${colors.gray}Please visit:${colors.reset} ${verificationUri}`);
        console.log(`${colors.gray}and enter code:${colors.reset} ${userCode}`);
        console.log('');
        console.log(`${colors.gray}Waiting for authorization...${colors.reset}`);
      });

      console.log(`${colors.gray}GitHub authentication successful! Token stored.${colors.reset}\n`);
    } catch (error) {
      const message = error instanceof Error ? error.message : String(error);
      console.log(`${colors.gray}GitHub login failed:${colors.reset} ${message}\n`);
    }
  }

  private handlePairCommand(action?: 'generate' | 'list' | 'revoke', args?: string): void {
    const pm = this.config.pairingManager;
    if (!pm) {
      console.log(`${colors.gray}Pairing not enabled. Set pairing.enabled: true in config.${colors.reset}\n`);
      return;
    }

    switch (action) {
      case 'generate': {
        const code = pm.generateCode(args);
        const pending = pm.listPendingCodes().find(p => p.code === code);
        const expiresIn = pending ? Math.round((pending.expiresAt - Date.now()) / 1000) : '?';
        console.log(`${colors.bold}Pairing code: ${code}${colors.reset}`);
        console.log(`${colors.gray}Expires in ${expiresIn}s${args ? ` (label: ${args})` : ''}${colors.reset}\n`);
        break;
      }

      case 'revoke': {
        if (!args) {
          console.log(`${colors.gray}Usage: /pair revoke <channel> <senderId>${colors.reset}\n`);
          return;
        }
        const parts = args.split(/\s+/);
        if (parts.length < 2) {
          console.log(`${colors.gray}Usage: /pair revoke <channel> <senderId>${colors.reset}\n`);
          return;
        }
        const [channel, senderId] = parts;
        const revoked = pm.revokeApproval(channel, senderId);
        if (revoked) {
          console.log(`${colors.bold}Revoked approval for ${channel}:${senderId}${colors.reset}\n`);
        } else {
          console.log(`${colors.gray}No approval found for ${channel}:${senderId}${colors.reset}\n`);
        }
        break;
      }

      case 'list':
      default: {
        const pending = pm.listPendingCodes();
        const approved = pm.listApproved();

        if (pending.length === 0 && approved.length === 0) {
          console.log(`${colors.gray}No pending codes or approved senders.${colors.reset}\n`);
          return;
        }

        if (pending.length > 0) {
          console.log(`${colors.bold}Pending codes:${colors.reset}`);
          for (const p of pending) {
            const expiresIn = Math.round((p.expiresAt - Date.now()) / 1000);
            console.log(`  ${p.code}  expires in ${expiresIn}s${p.label ? `  (${p.label})` : ''}`);
          }
        }

        if (approved.length > 0) {
          console.log(`${colors.bold}Approved senders:${colors.reset}`);
          for (const a of approved) {
            const date = new Date(a.approvedAt).toISOString().slice(0, 16).replace('T', ' ');
            console.log(`  ${a.channel}:${a.senderId}  since ${date}  (code: ${a.codeUsed})`);
          }
        }
        console.log('');
        break;
      }
    }
  }

  private getAvailableBackends(): string[] {
    const backends: string[] = [];
    if (this.config.currentLocalProvider) {
      backends.push(this.config.currentLocalProvider);
    }
    if (this.config.localProviders) {
      backends.push(...Object.keys(this.config.localProviders));
    }
    return [...new Set(backends)];
  }

  private createLocalClient(config: ModelConfig): ModelClient | null {
    if (config.provider === 'ollama') {
      return new OllamaClient({
        model: config.model,
        host: config.endpoint,
      });
    }
    if (config.provider === 'llamacpp') {
      return new LlamaCppClient({
        endpoint: config.endpoint ?? 'http://localhost:8080',
        model: config.model,
        authToken: config.auth_token,
      });
    }
    return null;
  }

  private printStatus(): void {
    console.log(`${colors.gray}Session:${colors.reset} ${this.config.session.id}`);
    console.log(`${colors.gray}Messages:${colors.reset} ${this.config.session.getHistory().length}`);
    console.log(`${colors.gray}Tokens:${colors.reset} ${this.totalUsage.inputTokens} in / ${this.totalUsage.outputTokens} out\n`);
  }

  private async handleMessage(content: string): Promise<void> {
    // Print Flynn label before response
    process.stdout.write(`\n${colors.orange}${colors.bold}Flynn:${colors.reset}\n`);

    try {
      // Use agent if available (supports tool loop)
      if (this.config.agent) {
        const response = await this.config.agent.process(content);
        const rendered = renderMarkdown(response);
        console.log(rendered);
        console.log();
        return;
      }

      // Fallback: direct model client (no tool support)
      this.config.session.addMessage({ role: 'user', content });

      // Try streaming if available
      if (this.config.modelClient.chatStream) {
        let fullContent = '';

        for await (const event of this.config.modelClient.chatStream({
          messages: this.config.session.getHistory(),
          system: this.config.systemPrompt,
        })) {
          if (event.type === 'content' && event.content) {
            process.stdout.write(event.content);
            fullContent += event.content;
          }
          if (event.type === 'fallback_warning' && event.fallbackReason) {
            console.warn(`\n⚠ Using fallback model`);
          }
          if (event.type === 'done' && event.usage) {
            this.totalUsage.inputTokens += event.usage.inputTokens;
            this.totalUsage.outputTokens += event.usage.outputTokens;
          }
          if (event.type === 'error') {
            throw event.error ?? new Error('Stream error');
          }
        }

        console.log('\n');

        this.config.session.addMessage({ role: 'assistant', content: fullContent });
      } else {
        // Fallback to non-streaming
        const response = await this.config.modelClient.chat({
          messages: this.config.session.getHistory(),
          system: this.config.systemPrompt,
        });

        const rendered = renderMarkdown(response.content);
        console.log(rendered);
        console.log();

        this.totalUsage.inputTokens += response.usage.inputTokens;
        this.totalUsage.outputTokens += response.usage.outputTokens;

        this.config.session.addMessage({ role: 'assistant', content: response.content });
      }
    } catch (error) {
      console.error('Error:', error instanceof Error ? error.message : error);
      console.log();
    }
  }

  stop(preserveStdin = false): void {
    this.running = false;
    if (this.rl) {
      if (preserveStdin) {
        // Remove readline listeners but don't close stdin
        this.rl.removeAllListeners();
        process.stdin.removeAllListeners('keypress');
        // Pause stdin so readline releases it
        process.stdin.pause();
      }
      this.rl.close();
      this.rl = null;
    }
    // Clean up keypress listener
    process.stdin.removeAllListeners('keypress');
  }
}