import React from 'react';
import { render } from 'ink';
import '../youtubeAuth.js';
import { App } from './App.jsx';
import { KikuAgent } from '../agentCore.js';
import { LMStudioClient } from '../llmClient.js';
import { toolsSchema } from '../tools.js';
import { config } from '../config.js';
import { COMMAND_DEFINITIONS } from '../commandRegistry.js';
import { C, UI_ICONS, buildCategorizedHelpLines } from '../ui.js';
import { existsSync } from 'node:fs';
import { spawn } from 'node:child_process';
import { PACKAGE_VERSION } from '../version.js';
import { resolveDynamicWindowsAppPaths } from '../appPaths.js';
import { registerBackgroundProcess } from '../processManager.js';

function parseCliArgs() {
  const args = process.argv.slice(2);
  const options = {
    query: null,
    model: 'google/gemma-4-e4b',
    url: null,
    showTools: false,
    showStats: false,
    thinking: 'show',
    verbose: false,
    help: false,
    version: false
  };

  for (let i = 0; i < args.length; i++) {
    const arg = args[i];
    if (arg === '--help' || arg === '-h') options.help = true;
    else if (arg === '--version' || arg === '-V') options.version = true;
    else if (arg === '--tools' || arg === '-t') options.showTools = true;
    else if (arg === '--stats' || arg === '-s') options.showStats = true;
    else if (arg === '--verbose' || arg === '-v') { options.verbose = true; options.thinking = 'show'; }
    else if (arg === '--thinking') options.thinking = args[++i] || 'show';
    else if (arg === '--model' || arg === '-m') options.model = args[++i] || options.model;
    else if (arg === '--url' || arg === '-u') options.url = args[++i];
    else if (arg === '--query' || arg === '-q') options.query = args[++i];
    else if (!arg.startsWith('-') && !options.query) { options.query = args.slice(i).join(' '); break; }
  }
  return options;
}

async function waitForLMStudio(baseUrl, timeoutMs = 30000) {
  const client = new LMStudioClient({ baseUrl });
  const start = Date.now();
  while (Date.now() - start < timeoutMs) {
    const health = await client.checkConnection();
    if (health.connected) return health;
    await new Promise(r => setTimeout(r, 1000));
  }
  return null;
}

async function attemptAutoStartLMStudio(baseUrl, model) {
  const isWin = process.platform === 'win32';
  const isMac = process.platform === 'darwin';

  const candidates = isWin
    ? resolveDynamicWindowsAppPaths('LM Studio', 'LM Studio.exe')
    : isMac
      ? ['/Applications/LM Studio.app/Contents/MacOS/LM Studio']
      : ['lmstudio', '/usr/local/bin/lmstudio', '/opt/lmstudio/bin/lmstudio'];

  const exe = candidates.find(p => {
    if (p.includes('/') || p.includes('\\')) {
      try { return existsSync(p); } catch { return false; }
    }
    return true;
  });

  if (!exe) return null;

  try {
    let port = '1234';
    try { const parsedUrl = new URL(baseUrl); if (parsedUrl.port) port = parsedUrl.port; } catch {}

    const child = spawn(exe, isWin
      ? ['--model', model, '--serve', '--port', port]
      : ['serve', '--model', model, '--port', port],
      { detached: true, stdio: 'ignore', windowsHide: true }
    );
    if (child.pid) {
      registerBackgroundProcess('lmstudio', child, {
        command: exe,
        args: isWin ? ['--model', model, '--serve', '--port', port] : ['serve', '--model', model, '--port', port],
        metadata: { model, port },
      });
    }
    child.unref();

    return await waitForLMStudio(baseUrl, 45000);
  } catch { return null; }
}

function printHelpText() {
  const commands = buildCategorizedHelpLines().join('\n');
  console.log(`\n  ${C.bold}${C.gold}${UI_ICONS.help} Kiku AI Agent — ${COMMAND_DEFINITIONS.length} Commands${C.reset}\n${commands}\n  ${C.dim}Tip: Press [Tab] for auto-completion.${C.reset}\n`);
}

async function printStatsText() {
  const { executeTool } = await import('../tools.js');
  const result = await executeTool('get_system_stats', {});
  const s = result.stats;
  console.log(JSON.stringify(s, null, 2));
}

async function main() {
  const opts = parseCliArgs();

  if (opts.version) { console.log(PACKAGE_VERSION); process.exit(0); }
  if (opts.help) { printHelpText(); process.exit(0); }
  if (opts.showStats) { await printStatsText(); process.exit(0); }

  if (opts.showTools) {
    console.log(`\n  ${C.bold}${C.sakura}Tools (${toolsSchema.length})${C.reset}\n`);
    for (const [i, t] of toolsSchema.entries()) {
      console.log(`  ${C.gold}${String(i + 1).padStart(2)}${C.reset} ${C.cyberCyan}${t.function.name}${C.reset} — ${C.dim}${t.function.description.slice(0, 60)}${C.reset}`);
    }
    process.exit(0);
  }

  const baseUrl = opts.url || config.lmStudio.baseUrl;
  const client = new LMStudioClient({ baseUrl, model: opts.model });
  const health = await client.checkConnection();

  if (!health.connected) {
    console.log(`  ${C.amber}!! LM Studio offline${C.reset}`);
    console.log(`  ${C.dim}• ${health.error}${C.reset}\n`);

    const autoHealth = await attemptAutoStartLMStudio(baseUrl, opts.model || config.lmStudio.model);
    if (autoHealth) {
      console.log(`  ${C.emerald}[OK] LM Studio started.${C.reset}\n`);
    } else {
      console.log(`  ${C.sakura}Setup: Open LM Studio → load google/gemma-4-e4b → Start Server :1234${C.reset}\n`);
      process.exit(1);
    }
  }

  const agent = new KikuAgent({
    baseUrl,
    model: health.activeModel || opts.model,
    thinkingMode: opts.thinking,
  });

  await agent._ready;

  if (opts.query) {
    const { executeTool: execTool } = await import('../tools.js');
    const { sanitizeQuery } = await import('../sanitizer.js');
    const { sanitized } = sanitizeQuery(opts.query);
    const prompt = sanitized || opts.query;

    console.log(`  ${C.bold}${C.gold}QUERY${C.reset} ${prompt}\n`);

    await agent.ask(prompt, {
      onReasoningStart: () => process.stdout.write('  THINKING '),
      onReasoningDelta: (chunk) => process.stdout.write(chunk),
      onReasoningEnd: () => process.stdout.write('\n'),
      onToolStart: (name) => process.stdout.write(`  [RUNNING] ${name}... `),
      onToolResult: () => process.stdout.write(`[OK]\n`),
      onTokenDelta: (chunk) => process.stdout.write(chunk),
      onFinalAnswer: () => {},
      onError: (err) => console.error(`\n  [ERROR] ${err.message}`),
    });
    process.exit(0);
  }

  const helpFn = (sub) => { printHelpText(); };
  const adFn = () => { console.log(`  ${UI_ICONS.sponsor} SPONSOR  DashSecurity — https://dashsecurity.kpltgroup.com/`); };

  const { waitUntilExit } = render(
    <App
      agent={agent}
      client={client}
      baseUrl={baseUrl}
      printHelp={helpFn}
      printAd={adFn}
    />,
    {
      exitOnCtrlC: true,
      patchConsole: false,
    }
  );

  await waitUntilExit;

  try { await agent.endSession(); } catch {}
  console.log('\n  Session archived. Goodbye. (鞠躬 ~ 谢谢!)\n');
}

main().catch(err => {
  console.error(`\n  ${C.red}Fatal: ${err.message}${C.reset}\n`);
  process.exit(1);
});
