/**
 * CmdCode V0.5 - 用户自定义模型配置管理
 * 
 * 功能：
 *   1. 用户可创建多个自定义模型配置
 *   2. 配置加密存储在用户专属目录
 *   3. 支持切换默认模型
 *   4. 启动时自动加载用户默认模型
 */

import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, unlinkSync } from 'node:fs'
import { join } from 'node:path'
import { homedir } from 'node:os'
import { encrypt, decrypt } from './crypto-util.js'
import { testConnection } from './models.js'

// ═══════════════════════════════════════
// 类型定义
// ═══════════════════════════════════════

/** 用户自定义模型配置 */
export interface UserModelConfig {
  id: string           // 配置ID（文件名，不含扩展名）
  name: string         // 模型显示名称
  model: string        // 模型ID（API调用用）
  baseUrl: string      // API地址
  apiKey: string       // API密钥（加密存储）
  note1?: string       // 备注信息一
  note2?: string       // 备注信息二
  createdAt: string    // 创建时间
  updatedAt: string    // 更新时间
  isDefault?: boolean  // 是否为用户默认模型
}

/** 模型列表项（不含敏感信息） */
export interface ModelListItem {
  id: string
  name: string
  model: string
  baseUrl: string
  note1?: string
  note2?: string
  createdAt: string
  isDefault: boolean
}

// ═══════════════════════════════════════
// 配置
// ═══════════════════════════════════════

const CMD_DIR = join(homedir(), '.cmdcode')

/** 获取用户模型配置目录 */
function getUserModelsDir(username: string): string {
  return join(CMD_DIR, 'workspaces', username, 'models')
}

/** 确保目录存在 */
function ensureDir(dir: string): void {
  if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
}

/** 设置文件权限 */
function setPermission(filePath: string): void {
  try { require('node:fs').chmodSync(filePath, 0o600) } catch { /* ignore */ }
}

// ═══════════════════════════════════════
// CRUD 操作
// ═══════════════════════════════════════

/**
 * 创建用户模型配置
 */
export function createUserModel(
  username: string,
  config: Omit<UserModelConfig, 'id' | 'createdAt' | 'updatedAt' | 'isDefault'>
): UserModelConfig {
  const modelsDir = getUserModelsDir(username)
  ensureDir(modelsDir)
  
  // 生成唯一ID
  const timestamp = Date.now().toString(36)
  const random = Math.random().toString(36).slice(2, 6)
  const id = `model_${timestamp}_${random}`
  
  const now = new Date().toISOString()
  const fullConfig: UserModelConfig = {
    ...config,
    id,
    createdAt: now,
    updatedAt: now,
    isDefault: false,
  }
  
  // 检查是否是第一个配置，自动设为默认
  const existing = listUserModels(username)
  if (existing.length === 0) {
    fullConfig.isDefault = true
  }
  
  // 加密存储
  const filePath = join(modelsDir, `${id}.enc`)
  writeFileSync(filePath, encrypt(fullConfig), 'utf-8')
  setPermission(filePath)
  
  return fullConfig
}

/**
 * 读取用户模型配置
 */
export function loadUserModel(username: string, modelId: string): UserModelConfig | null {
  const modelsDir = getUserModelsDir(username)
  const filePath = join(modelsDir, `${modelId}.enc`)
  
  if (!existsSync(filePath)) return null
  
  try {
    return decrypt<UserModelConfig>(readFileSync(filePath, 'utf-8'))
  } catch {
    return null
  }
}

/**
 * 更新用户模型配置
 */
export function updateUserModel(
  username: string,
  modelId: string,
  updates: Partial<Omit<UserModelConfig, 'id' | 'createdAt'>>
): UserModelConfig | null {
  const existing = loadUserModel(username, modelId)
  if (!existing) return null
  
  const updated: UserModelConfig = {
    ...existing,
    ...updates,
    id: modelId,
    createdAt: existing.createdAt,
    updatedAt: new Date().toISOString(),
  }
  
  const modelsDir = getUserModelsDir(username)
  const filePath = join(modelsDir, `${modelId}.enc`)
  writeFileSync(filePath, encrypt(updated), 'utf-8')
  setPermission(filePath)
  
  return updated
}

/**
 * 删除用户模型配置
 */
export function deleteUserModel(username: string, modelId: string): boolean {
  const modelsDir = getUserModelsDir(username)
  const filePath = join(modelsDir, `${modelId}.enc`)
  
  if (!existsSync(filePath)) return false
  
  try {
    unlinkSync(filePath)
    return true
  } catch {
    return false
  }
}

/**
 * 列出用户所有模型配置（不含API Key）
 */
export function listUserModels(username: string): ModelListItem[] {
  const modelsDir = getUserModelsDir(username)
  
  if (!existsSync(modelsDir)) return []
  
  const files = readdirSync(modelsDir)
    .filter(f => f.endsWith('.enc'))
    .sort()
  
  const models: ModelListItem[] = []
  
  for (const f of files) {
    try {
      const config = decrypt<UserModelConfig>(
        readFileSync(join(modelsDir, f), 'utf-8')
      )
      models.push({
        id: config.id,
        name: config.name,
        model: config.model,
        baseUrl: config.baseUrl,
        note1: config.note1,
        note2: config.note2,
        createdAt: config.createdAt,
        isDefault: config.isDefault || false,
      })
    } catch { /* skip broken files */ }
  }
  
  return models
}

/**
 * 获取用户默认模型配置（含API Key）
 */
export function getUserDefaultModel(username: string): UserModelConfig | null {
  const modelsDir = getUserModelsDir(username)
  
  if (!existsSync(modelsDir)) return null
  
  const files = readdirSync(modelsDir).filter(f => f.endsWith('.enc'))
  
  for (const f of files) {
    try {
      const config = decrypt<UserModelConfig>(
        readFileSync(join(modelsDir, f), 'utf-8')
      )
      if (config.isDefault) {
        return config
      }
    } catch { /* skip */ }
  }
  
  // 没有默认的，返回第一个
  if (files.length > 0) {
    try {
      return decrypt<UserModelConfig>(
        readFileSync(join(modelsDir, files[0]), 'utf-8')
      )
    } catch { /* skip */ }
  }
  
  return null
}

/**
 * 设置用户默认模型
 */
export function setUserDefaultModel(username: string, modelId: string): boolean {
  const modelsDir = getUserModelsDir(username)
  
  if (!existsSync(modelsDir)) return false
  
  const files = readdirSync(modelsDir).filter(f => f.endsWith('.enc'))
  let found = false
  
  for (const f of files) {
    try {
      const config = decrypt<UserModelConfig>(
        readFileSync(join(modelsDir, f), 'utf-8')
      )
      
      if (config.id === modelId) {
        config.isDefault = true
        found = true
      } else {
        config.isDefault = false
      }
      
      writeFileSync(join(modelsDir, f), encrypt(config), 'utf-8')
    } catch { /* skip */ }
  }
  
  return found
}

/**
 * 测试模型连接
 */
export async function testUserModelConnection(config: UserModelConfig): Promise<{
  success: boolean
  latencyMs: number
  error?: string
}> {
  return testConnection(config.baseUrl, config.apiKey, config.model)
}

/**
 * 统计用户模型数量
 */
export function countUserModels(username: string): number {
  const modelsDir = getUserModelsDir(username)
  if (!existsSync(modelsDir)) return 0
  return readdirSync(modelsDir).filter(f => f.endsWith('.enc')).length
}