import winston from 'winston'

/**
 * 云原生日志系统
 * 
 * 核心设计原则：
 * - ✅ 只输出到stdout（不写本地文件）
 * - ✅ JSON格式（便于阿里云SLS解析）
 * - ✅ 结构化日志（包含元数据）
 * - ✅ 统一的日志格式
 * 
 * 日志级别：
 * - error: 错误，需要立即处理
 * - warn: 警告，需要关注
 * - info: 重要信息，正常业务日志
 * - debug: 调试信息，仅开发环境
 * 
 * 环境变量：
 * - LOG_LEVEL: 日志级别（默认：development=debug, production=info）
 * - NODE_ENV: development | production
 * - SERVICE_NAME: 服务名称（默认：aiclinical-backend）
 * 
 * @example
 * ```typescript
 * import { logger } from '@/common/logging'
 * 
 * // 基础日志
 * logger.info('User logged in', { userId: 123 })
 * logger.error('Database query failed', { error: err.message, query: 'SELECT ...' })
 * 
 * // 带上下文的日志
 * const childLogger = logger.child({ module: 'ASL', projectId: 456 })
 * childLogger.info('Screening started', { count: 100 })
 * ```
 */

// 获取日志级别
function getLogLevel(): string {
  if (process.env.LOG_LEVEL) {
    return process.env.LOG_LEVEL
  }
  return process.env.NODE_ENV === 'production' ? 'info' : 'debug'
}

// 获取服务名称
function getServiceName(): string {
  return process.env.SERVICE_NAME || 'aiclinical-backend'
}

// 创建Winston Logger
export const logger = winston.createLogger({
  level: getLogLevel(),
  
  // JSON格式 + 时间戳 + 错误堆栈
  format: winston.format.combine(
    winston.format.timestamp({
      format: 'YYYY-MM-DD HH:mm:ss.SSS'
    }),
    winston.format.errors({ stack: true }),
    winston.format.json()
  ),
  
  // 默认元数据（所有日志都包含）
  defaultMeta: {
    service: getServiceName(),
    env: process.env.NODE_ENV || 'development',
    instance: process.env.HOSTNAME || process.env.COMPUTERNAME || 'unknown',
    pid: process.pid
  },
  
  // ⭐ 云原生：只输出到stdout
  transports: [
    new winston.transports.Console({
      format: process.env.NODE_ENV === 'production'
        ? winston.format.json()  // 生产环境：纯JSON
        : winston.format.combine(  // 开发环境：带颜色的可读格式
            winston.format.colorize(),
            winston.format.printf((info: any) => {
              const { timestamp, level, message, service, ...meta } = info
              const metaStr = Object.keys(meta).length > 0 
                ? '\n  ' + JSON.stringify(meta, null, 2)
                : ''
              return `${timestamp} [${service}] ${level}: ${message}${metaStr}`
            })
          )
    })
  ]
})

/**
 * 创建子logger（带上下文）
 * 
 * @example
 * ```typescript
 * const aslLogger = createChildLogger('ASL', { projectId: 123 })
 * aslLogger.info('Screening started')
 * // 输出：{ ..., module: 'ASL', projectId: 123, message: 'Screening started' }
 * ```
 */
export function createChildLogger(module: string, meta: Record<string, any> = {}) {
  return logger.child({ module, ...meta })
}

/**
 * 记录HTTP请求日志
 * 
 * @example
 * ```typescript
 * logHttpRequest('GET', '/api/projects', 200, 50)
 * ```
 */
export function logHttpRequest(
  method: string,
  url: string,
  statusCode: number,
  duration: number,
  meta: Record<string, any> = {}
) {
  const level = statusCode >= 500 ? 'error' : statusCode >= 400 ? 'warn' : 'info'
  
  logger.log(level, 'HTTP Request', {
    type: 'http',
    method,
    url,
    statusCode,
    duration,
    ...meta
  })
}

/**
 * 记录数据库查询日志
 * 
 * @example
 * ```typescript
 * logDatabaseQuery('SELECT * FROM users WHERE id = $1', 45, { userId: 123 })
 * ```
 */
export function logDatabaseQuery(
  query: string,
  duration: number,
  meta: Record<string, any> = {}
) {
  if (process.env.LOG_LEVEL === 'debug') {
    logger.debug('Database Query', {
      type: 'database',
      query: query.substring(0, 200), // 限制长度
      duration,
      ...meta
    })
  }
}

/**
 * 记录LLM API调用日志
 * 
 * @example
 * ```typescript
 * logLLMCall('deepseek', 'chat', 1500, { model: 'deepseek-chat' })
 * ```
 */
export function logLLMCall(
  provider: string,
  operation: string,
  duration: number,
  meta: Record<string, any> = {}
) {
  logger.info('LLM API Call', {
    type: 'llm',
    provider,
    operation,
    duration,
    ...meta
  })
}

/**
 * 记录异步任务日志
 * 
 * @example
 * ```typescript
 * logAsyncJob('asl:screening', 'started', { jobId: '123', projectId: 456 })
 * ```
 */
export function logAsyncJob(
  jobType: string,
  status: 'started' | 'processing' | 'completed' | 'failed',
  meta: Record<string, any> = {}
) {
  const level = status === 'failed' ? 'error' : 'info'
  
  logger.log(level, 'Async Job', {
    type: 'job',
    jobType,
    status,
    ...meta
  })
}

// 导出默认logger
export default logger

