#!/usr/bin/env node
'use strict';

const fs = require('fs');
const os = require('os');
const path = require('path');
const readline = require('readline');

const { ensureConfig } = require('../config');
const { createState } = require('../core/state');
const { buildSystemPrompt } = require('../core/context');
const { streamChat } = require('../model/client');
const { executeTool } = require('../tools/dispatcher');
const { openCommandMenu } = require('../ui/command_menu');
const { handleCommand } = require('./commands');
const { Spinner, truncateThinking } = require('../ui/spinner');
const { renderBanner } = require('../ui/banner');
const { buildStartLine, buildFinalLine, startToolDisplay, formatResultLines, printResultLines } = require('../ui/tool_display');
const { createConversation, updateConversation } = require('../storage/conversation_store');
const { applyUsage, normalizeTokenUsage } = require('../utils/token_usage');
const { gray, cyan, green, red } = require('../utils/colors');
const { createIndentedWriter } = require('../ui/indented_writer');
const { createStatusBar } = require('../ui/status_bar');

const WORKSPACE = process.cwd();
const WORKSPACE_NAME = path.basename(WORKSPACE);
const USERNAME = os.userInfo().username || 'user';
const PROMPT = `${USERNAME}@${WORKSPACE_NAME} % `;
const MENU_PAGE_SIZE = 6;

const config = ensureConfig();
const state = createState(config, WORKSPACE);
state.conversation = createConversation(WORKSPACE, {
  model_key: state.modelKey,
  model_id: state.modelId,
  thinking_mode: state.thinkingMode,
  allow_mode: state.allowMode,
  token_usage: state.tokenUsage,
  cwd: WORKSPACE,
});

const systemPrompt = fs.readFileSync(path.join(__dirname, '../../prompts/system.txt'), 'utf8');
const tools = JSON.parse(fs.readFileSync(path.join(__dirname, '../../doc/tools.json'), 'utf8'));

renderBanner({
  modelKey: state.modelKey,
  workspace: WORKSPACE,
  conversationId: state.conversation?.id,
});
console.log('');
console.log('');

let rl = null;
let statusBar = null;
let isRunning = false;
let escPendingCancel = false;
let activeStreamController = null;
let activeToolController = null;
let commandMenuActive = false;
let menuSearchTerm = '';
let menuLastSearchTerm = '';
let menuJustClosedAt = 0;
let menuInjectedCommand = null;
let menuAbortController = null;
let menuJustClosedInjected = false;

readline.emitKeypressEvents(process.stdin);
if (process.stdin.isTTY) process.stdin.setRawMode(true);

initReadline();

statusBar = createStatusBar({
  getTokens: () => normalizeTokenUsage(state.tokenUsage).total || 0,
  maxTokens: '256k',
});
statusBar.render();

process.stdin.on('keypress', (str, key) => {
  if (commandMenuActive) {
    if (key && key.name === 'backspace' && menuSearchTerm === '') {
      if (menuAbortController && !menuAbortController.signal.aborted) {
        menuAbortController.abort();
      }
    }
    return;
  }
  if (key && key.name === 'escape' && isRunning) {
    escPendingCancel = true;
    if (activeStreamController && typeof activeStreamController.abort === 'function') {
      activeStreamController.abort();
    }
    if (activeToolController && typeof activeToolController.abort === 'function') {
      activeToolController.abort();
    }
    return;
  }
  if (str === '/' && (rl.line === '' || rl.line === '/')) {
    commandMenuActive = true;
    if (rl) {
      rl.pause();
      rl.line = '';
      rl.cursor = 0;
      readline.clearLine(process.stdout, 0);
      readline.cursorTo(process.stdout, 0);
    }
    menuSearchTerm = '';
    menuAbortController = new AbortController();
    void openCommandMenu({
      rl,
      prompt: PROMPT,
      pageSize: MENU_PAGE_SIZE,
      colorEnabled: process.stdout.isTTY,
      resetAnsi: '\x1b[0m',
      onInput: (input) => {
        menuSearchTerm = input || '';
      },
      abortSignal: menuAbortController.signal,
    })
      .then((result) => {
        if (result && result.chosen && !result.cancelled) {
          menuInjectedCommand = result.chosen;
        }
      })
      .finally(() => {
        commandMenuActive = false;
        menuAbortController = null;
        menuJustClosedAt = menuInjectedCommand ? Date.now() : 0;
        menuJustClosedInjected = !!menuInjectedCommand;
        menuLastSearchTerm = menuSearchTerm;
        drainStdin();
        rl.line = '';
        rl.cursor = 0;
        menuSearchTerm = '';
        if (process.stdout.isTTY) {
          readline.clearScreenDown(process.stdout);
        }
        // Clear possible echoes from the base readline line (current + previous line).
        if (process.stdout.isTTY) {
          readline.clearLine(process.stdout, 0);
          readline.cursorTo(process.stdout, 0);
          readline.moveCursor(process.stdout, 0, -1);
          readline.clearLine(process.stdout, 0);
          readline.cursorTo(process.stdout, 0);
        } else {
          readline.clearLine(process.stdout, 0);
          readline.cursorTo(process.stdout, 0);
        }
        promptWithStatus(true);
        if (menuInjectedCommand) {
          const injected = menuInjectedCommand;
          menuInjectedCommand = null;
          setImmediate(() => injectLine(injected));
        }
      });
  }
});

function initReadline() {
  if (rl) {
    try {
      rl.removeAllListeners();
    } catch (_) {}
  }
  rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    terminal: true,
  });

  process.stdin.resume();
  rl.setPrompt(PROMPT);
  promptWithStatus();

  rl.on('line', async (line) => {
    if (rl) {
      rl.line = '';
      rl.cursor = 0;
    }
    if (commandMenuActive) {
      return;
    }
    const input = line.trim();
    if (menuJustClosedAt) {
      if (!menuJustClosedInjected) {
        const tooOld = Date.now() - menuJustClosedAt > 800;
        const normalizedMenu = String(menuLastSearchTerm).trim().replace(/^\/+/, '');
        const normalizedInput = input.replace(/^\/+/, '');
        if (!tooOld && (!normalizedMenu ? input === '' : normalizedInput === normalizedMenu)) {
          menuJustClosedAt = 0;
          menuLastSearchTerm = '';
          if (process.stdout.isTTY) {
            readline.moveCursor(process.stdout, 0, -1);
            readline.clearLine(process.stdout, 0);
            readline.cursorTo(process.stdout, 0);
          }
          promptWithStatus();
          return;
        }
      }
      menuJustClosedAt = 0;
      menuLastSearchTerm = '';
      menuJustClosedInjected = false;
    }
    if (!input) {
      promptWithStatus();
      return;
    }

    if (input.startsWith('/')) {
      const result = await handleCommand(input, { rl, state, config, workspace: WORKSPACE, statusBar });
      if (result && result.exit) return;
      promptWithStatus();
      return;
    }

    console.log('');
    const userWriter = createIndentedWriter('   ');
    userWriter.writeLine(`${cyan('用户：')}${line}`);
    state.messages.push({ role: 'user', content: line });
    persistConversation();
    await runAssistantLoop();
    promptWithStatus();
  });

  rl.on('close', () => {
    if (statusBar) statusBar.destroy();
    process.stdout.write('\n');
    process.exit(0);
  });
}

function drainStdin() {
  if (!process.stdin.isTTY) return;
  process.stdin.pause();
  while (process.stdin.read() !== null) {}
  process.stdin.resume();
}

function injectLine(text) {
  if (!rl) return;
  rl.write(text);
  rl.write('\n');
}

function persistConversation() {
  if (!state.conversation) return;
  state.conversation = updateConversation(WORKSPACE, state.conversation, state.messages, {
    model_key: state.modelKey,
    model_id: state.modelId,
    thinking_mode: state.thinkingMode,
    allow_mode: state.allowMode,
    token_usage: state.tokenUsage,
    cwd: WORKSPACE,
  });
}

function promptWithStatus(force = false) {
  if (!rl) return;
  if (process.stdout.isTTY) {
    const rows = process.stdout.rows || 24;
    if (rows >= 3) {
      readline.cursorTo(process.stdout, 0, rows - 3);
      readline.clearLine(process.stdout, 0);
    }
  }
  rl.prompt(force);
  if (statusBar) statusBar.render();
}

function buildApiMessages() {
  const system = buildSystemPrompt(systemPrompt, { workspace: WORKSPACE, allowMode: state.allowMode });
  const messages = [{ role: 'system', content: system }];
  for (const msg of state.messages) {
    const m = { role: msg.role };
    if (msg.role === 'tool') {
      m.tool_call_id = msg.tool_call_id;
      m.content = msg.content;
    } else if (msg.role === 'assistant' && Array.isArray(msg.tool_calls)) {
      m.content = msg.content || null;
      m.tool_calls = msg.tool_calls;
      if (Object.prototype.hasOwnProperty.call(msg, 'reasoning_content')) {
        m.reasoning_content = msg.reasoning_content;
      } else if (state.thinkingMode) {
        m.reasoning_content = '';
      }
    } else {
      m.content = msg.content;
      if (msg.role === 'assistant' && Object.prototype.hasOwnProperty.call(msg, 'reasoning_content')) {
        m.reasoning_content = msg.reasoning_content;
      }
    }
    messages.push(m);
  }
  return messages;
}

function printCancelLine() {
  console.log('');
  process.stdout.write(`  ${red('已取消本次响应')}\n\n`);
}

function stopSpinnerForCancel(spinner, thinkingActive, showThinkingLabel, thinkingMode) {
  if (!spinner) return;
  if (thinkingMode && (thinkingActive || showThinkingLabel)) {
    spinner.stop('∙ 停止思考');
  } else {
    spinner.stopSilent();
  }
}

async function runAssistantLoop() {
  let continueLoop = true;
  let firstLoop = true;
  const hideCursor = () => process.stdout.write('\x1b[?25l');
  const showCursor = () => process.stdout.write('\x1b[?25h');
  isRunning = true;
  escPendingCancel = false;
  if (statusBar) statusBar.setMode('running');
  try {
    while (continueLoop) {
    hideCursor();
    const spinner = new Spinner(' ', firstLoop ? 1 : 0);
    firstLoop = false;
    let thinkingBuffer = '';
    let fullThinkingBuffer = '';
    let thinkingActive = false;
    let showThinkingLabel = false;
    let gotAnswer = false;
    let assistantContent = '';
    let toolCalls = {};
    let usageTotal = null;
    let usagePrompt = null;
    let usageCompletion = null;
    let firstContent = true;
    let assistantWriter = null;
    let cancelled = false;

    const thinkingDelay = setTimeout(() => {
      if (state.thinkingMode) showThinkingLabel = true;
    }, 400);

    spinner.start(() => {
      if (!state.thinkingMode) return '';
      if (!showThinkingLabel) return '';
      return { label: ' 思考中...', thinking: thinkingBuffer, colorThinking: true };
    });

    const messages = buildApiMessages();
    const streamController = new AbortController();
    activeStreamController = streamController;
    try {
      for await (const chunk of streamChat({ config, messages, tools, thinkingMode: state.thinkingMode, abortSignal: streamController.signal })) {
        const choice = chunk.choices && chunk.choices[0];
        if (!choice) continue;
        const usage = (choice && (choice.usage || choice.delta?.usage)) || chunk.usage;
        if (usage) {
          if (Number.isFinite(usage.prompt_tokens)) usagePrompt = usage.prompt_tokens;
          if (Number.isFinite(usage.completion_tokens)) usageCompletion = usage.completion_tokens;
          if (Number.isFinite(usage.total_tokens)) usageTotal = usage.total_tokens;
        }
        const delta = choice.delta || {};

        if (delta.reasoning_content || delta.reasoning_details) {
          thinkingActive = true;
          showThinkingLabel = true;
          const rc = delta.reasoning_content || (Array.isArray(delta.reasoning_details) ? delta.reasoning_details.map((d) => d.text || '').join('') : '');
          fullThinkingBuffer += rc;
          thinkingBuffer = truncateThinking(fullThinkingBuffer);
        }

        if (delta.tool_calls) {
          delta.tool_calls.forEach((tc) => {
            const idx = tc.index;
            if (!toolCalls[idx]) toolCalls[idx] = { id: tc.id, type: tc.type, function: { name: '', arguments: '' } };
            if (tc.function?.name) toolCalls[idx].function.name = tc.function.name;
            if (tc.function?.arguments) toolCalls[idx].function.arguments += tc.function.arguments;
          });
        }

        if (delta.content) {
          if (!gotAnswer) {
            clearTimeout(thinkingDelay);
            if (state.thinkingMode) {
              spinner.stop(thinkingActive ? '○ 思考完成' : '○');
            } else {
              spinner.stopSilent();
            }
            console.log('');
            assistantWriter = createIndentedWriter('   ');
            assistantWriter.write(`${green('Eagent：')}`);
            gotAnswer = true;
          }
          if (!gotAnswer) return;
          if (!assistantWriter) assistantWriter = createIndentedWriter('   ');
          assistantWriter.write(delta.content);
          assistantContent += delta.content;
        }

        if (choice.finish_reason) {
          if (choice.finish_reason === 'tool_calls') {
            continueLoop = true;
          }
        }
      }
    } catch (err) {
      if (err && (err.code === 'aborted' || err.name === 'AbortError' || escPendingCancel)) {
        cancelled = true;
      } else {
      clearTimeout(thinkingDelay);
      if (state.thinkingMode) {
        spinner.stop('○');
      } else {
        spinner.stopSilent();
      }
      showCursor();
      console.log(`错误: ${err.message || err}`);
      return;
      }
    }
    activeStreamController = null;

    clearTimeout(thinkingDelay);
    if (cancelled) {
      stopSpinnerForCancel(spinner, thinkingActive, showThinkingLabel, state.thinkingMode);
      showCursor();
      printCancelLine();
      return;
    }
    if (!gotAnswer) {
      if (state.thinkingMode) {
        spinner.stop(thinkingActive ? '○ 思考完成' : '○');
      } else {
        spinner.stopSilent();
      }
    } else {
      process.stdout.write('\n\n');
    }
    showCursor();

    if (usageTotal !== null || usagePrompt !== null || usageCompletion !== null) {
      state.tokenUsage = applyUsage(normalizeTokenUsage(state.tokenUsage), {
        prompt_tokens: usagePrompt,
        completion_tokens: usageCompletion,
        total_tokens: usageTotal,
      });
    }

    const toolCallList = Object.keys(toolCalls)
      .map((k) => Number(k))
      .sort((a, b) => a - b)
      .map((k) => toolCalls[k]);
    if (toolCallList.length) {
      const assistantMsg = {
        role: 'assistant',
        content: assistantContent || null,
        tool_calls: toolCallList,
      };
      if (state.thinkingMode) assistantMsg.reasoning_content = fullThinkingBuffer || '';
      state.messages.push(assistantMsg);
      persistConversation();

      for (const call of toolCallList) {
        let args = {};
        try { args = JSON.parse(call.function.arguments || '{}'); } catch (_) {}
        const startLine = buildStartLine(call.function.name, args);
        const finalLine = buildFinalLine(call.function.name, args);
        const indicator = startToolDisplay(startLine);
        const toolController = new AbortController();
        activeToolController = toolController;
        const toolResult = await executeTool({
          workspace: WORKSPACE,
          config,
          allowMode: state.allowMode,
          toolCall: call,
          abortSignal: toolController.signal,
        });
        activeToolController = null;
        indicator.stop(finalLine);
        const resultLines = formatResultLines(call.function.name, args, toolResult.raw || { success: toolResult.success, error: toolResult.error });
        printResultLines(resultLines);

        const toolMsg = {
          role: 'tool',
          tool_call_id: call.id,
          content: toolResult.tool_content || toolResult.formatted,
          tool_raw: toolResult.raw,
        };
        state.messages.push(toolMsg);
        persistConversation();
        if (escPendingCancel || (toolResult.raw && toolResult.raw.cancelled)) {
          return;
        }
      }
      continueLoop = true;
      hideCursor();
      continue;
    }

    if (assistantContent) {
      const msg = { role: 'assistant', content: assistantContent };
      if (state.thinkingMode) msg.reasoning_content = fullThinkingBuffer || '';
      state.messages.push(msg);
      persistConversation();
    }
    continueLoop = false;
    }
  } finally {
    showCursor();
    isRunning = false;
    escPendingCancel = false;
    activeStreamController = null;
    activeToolController = null;
    if (statusBar) statusBar.setMode('input');
  }
}