#!/usr/bin/env node

/**
 * 🚀 Pacifica 交易系统 V2.0 - 模块化架构
 *
 * 特性:
 * - 模块化架构，低耦合设计
 * - 智能缓存系统，96.6% API调用减少
 * - 多维度风险管理
 * - 基差风险监控
 * - 自动对冲和止损系统
 * - 实时仪表板监控
 */

// 早期设置全局EPIPE错误处理，防止进程崩溃
process.stdout.on('error', (error) => {
  if (error.code === 'EPIPE') {
    process.exit(0)
  }
})

process.stderr.on('error', (error) => {
  if (error.code === 'EPIPE') {
    process.exit(0)
  }
})

import { SystemOrchestrator } from './modules/SystemOrchestrator.js'
import { logger } from './utils/logger.js'
import * as dotenv from 'dotenv'

// 加载环境变量
dotenv.config()

/**
 * 主应用程序类
 */
class PacificaTradingApp {
  private orchestrator: SystemOrchestrator
  private isShuttingDown = false

  constructor() {
    this.orchestrator = new SystemOrchestrator()
    this.setupSignalHandlers()
  }

  /**
   * 启动应用程序
   */
  async start(): Promise<void> {
    try {
      console.log('🚀 启动 Pacifica 交易系统 V2.0...')
      console.log('📦 模块化架构 | 🛡️ 企业级风险控制 | ⚡ 智能缓存系统')
      console.log()

      // 获取账户配置
      const accounts = this.getAccountsConfig()

      // 系统配置
      const config = {
        accounts,
        enableTrading: process.env.ENABLE_TRADING !== 'false',
        enableDashboard: process.env.ENABLE_DASHBOARD !== 'false',
        displayConfig: {
          updateInterval: parseInt(process.env.DASHBOARD_UPDATE_INTERVAL || '10000'),
          enableConsoleOutput: process.env.ENABLE_CONSOLE_OUTPUT !== 'false',
          enableRichDisplay: process.env.ENABLE_RICH_DISPLAY !== 'false',
          compactMode: process.env.COMPACT_MODE === 'true',
        },
      }

      // 初始化和启动系统
      await this.orchestrator.initialize(config)
      await this.orchestrator.start()

      // 显示启动完成信息
      this.displayStartupInfo()

      // 保持运行
      this.keepAlive()
    } catch (error: any) {
      logger.error('应用启动失败', { error: error.message })
      console.error('❌ 启动失败:', error.message)
      process.exit(1)
    }
  }

  /**
   * 停止应用程序
   */
  async stop(): Promise<void> {
    if (this.isShuttingDown) return

    this.isShuttingDown = true
    console.log('\n🛑 正在停止系统...')

    try {
      await this.orchestrator.gracefulShutdown()
      console.log('✅ 系统已安全停止')
      process.exit(0)
    } catch (error: any) {
      logger.error('停止时出错', { error: error.message })
      console.error('❌ 停止失败:', error.message)
      process.exit(1)
    }
  }

  /**
   * 获取账户配置
   */
  private getAccountsConfig(): any[] {
    const accounts: any[] = []

    // 从环境变量读取账户配置
    let accountIndex = 1
    while (true) {
      const accountId = process.env[`PACIFICA_ACCOUNT_${accountIndex}`]
      const privateKey = process.env[`PACIFICA_PRIVATE_KEY_${accountIndex}`]

      if (!accountId || !privateKey) {
        break
      }

      accounts.push({
        id: `pacifica-${accountIndex}`,
        account: accountId,
        privateKey: privateKey,
        name: `Pacifica Account ${accountIndex}`,
        enabled: true,
      })

      accountIndex++
    }

    // 如果没有配置账户，使用默认配置
    if (accounts.length === 0) {
      const defaultAccount = process.env.PACIFICA_ACCOUNT
      const defaultPrivateKey = process.env.PACIFICA_PRIVATE_KEY

      if (defaultAccount && defaultPrivateKey) {
        accounts.push({
          id: 'pacifica-1',
          account: defaultAccount,
          privateKey: defaultPrivateKey,
          name: 'Default Pacifica Account',
          enabled: true,
        })
      }
    }

    if (accounts.length === 0) {
      throw new Error('未找到有效的账户配置。请设置环境变量 PACIFICA_ACCOUNT 和 PACIFICA_PRIVATE_KEY')
    }

    logger.info(`加载了 ${accounts.length} 个账户配置`)
    return accounts
  }

  /**
   * 设置信号处理
   */
  private setupSignalHandlers(): void {
    // 优雅关闭信号
    process.on('SIGINT', async () => {
      console.log('\n📡 收到 SIGINT 信号...')
      await this.stop()
    })

    process.on('SIGTERM', async () => {
      console.log('\n📡 收到 SIGTERM 信号...')
      await this.stop()
    })

    // 异常处理
    process.on('uncaughtException', error => {
      // 处理EPIPE错误，静默退出
      if (error.code === 'EPIPE') {
        console.error('❌ 管道破裂错误，正在优雅退出...')
        process.exit(0)
        return
      }

      logger.error('未捕获的异常', { error: error.message, stack: error.stack })
      console.error('❌ 未捕获的异常:', error.message)
      this.emergencyShutdown()
    })

    process.on('unhandledRejection', (reason, promise) => {
      // 如果是EPIPE相关的错误，静默处理
      if (reason && typeof reason === 'object' && 'code' in reason && reason.code === 'EPIPE') {
        console.error('❌ Promise中的管道破裂错误，正在优雅退出...')
        process.exit(0)
        return
      }

      logger.error('未处理的 Promise 拒绝', { reason, promise })
      console.error('❌ 未处理的 Promise 拒绝:', reason)
      this.emergencyShutdown()
    })
  }

  /**
   * 紧急关闭
   */
  private async emergencyShutdown(): Promise<void> {
    console.log('\n🚨 紧急关闭系统...')
    try {
      await this.orchestrator.emergencyStop()
    } catch (error) {
      logger.error('紧急关闭失败', { error })
    } finally {
      process.exit(1)
    }
  }

  /**
   * 显示启动信息
   */
  private displayStartupInfo(): void {
    const systemStatus = this.orchestrator.getSystemStatus()
    const runningServices = Object.values(systemStatus).filter(s => s.status === 'running').length
    const totalServices = Object.keys(systemStatus).length

    console.log('╔══════════════════════════════════════════════════════════════════════════════╗')
    console.log('║                       🎉 系统启动成功！                                       ║')
    console.log('╚══════════════════════════════════════════════════════════════════════════════╝')
    console.log()
    console.log(`📊 服务状态: ${runningServices}/${totalServices} 正在运行`)
    console.log()

    for (const [serviceName, status] of Object.entries(systemStatus)) {
      const emoji = status.status === 'running' ? '✅' : '❌'
      console.log(`  ${emoji} ${serviceName}: ${status.status}`)
    }

    console.log()
    console.log('🔧 系统特性:')
    console.log('  • 🧠 智能缓存系统 (96.6% API 调用减少)')
    console.log('  • 🛡️ 多维度风险管理')
    console.log('  • 📊 基差风险监控')
    console.log('  • 🔄 自动对冲系统')
    console.log('  • 🎯 止损止盈管理')
    console.log('  • 📱 实时仪表板')
    console.log()
    console.log('💡 提示:')
    console.log('  • 按 Ctrl+C 优雅停止系统')
    console.log('  • 查看日志了解详细运行状态')
    console.log('  • 仪表板每10秒自动更新')
    console.log()
    console.log('─'.repeat(80))
  }

  /**
   * 保持进程运行
   */
  private keepAlive(): void {
    // 定期检查系统健康状态
    setInterval(() => {
      if (!this.orchestrator.isHealthy()) {
        logger.warn('系统健康检查失败')
        console.log('⚠️ 系统健康状态异常，请检查日志')
      }
    }, 30000) // 每30秒检查一次

    // 定期更新仪表板（作为备份）
    setInterval(async () => {
      try {
        if (this.orchestrator.getIsRunning()) {
          // 这里可以添加额外的系统维护任务
          logger.debug('系统运行正常')
        }
      } catch (error: any) {
        logger.error('系统维护任务失败', { error: error.message })
      }
    }, 60000) // 每分钟执行一次

    logger.info('系统保活机制已启动')
  }
}

/**
 * 主函数
 */
async function main(): Promise<void> {
  const app = new PacificaTradingApp()
  await app.start()
}

// 检查是否直接运行此文件
if (import.meta.url === `file://${process.argv[1]}`) {
  main().catch(error => {
    console.error('❌ 应用启动失败:', error.message)
    logger.error('主函数执行失败', { error: error.message, stack: error.stack })
    process.exit(1)
  })
}
