/**
 * CmdCode V0.5 - 用户认证与工作区管理
 * 
 * 功能：
 *   1. 注册/登录 → 远程PHP API + MySQL
 *   2. Token本地加密缓存 → 下次启动自动登录
 *   3. 断点续传 → 工作区快照保存/恢复
 *   4. 用户专属文件夹 → 隔离+1GB配额
 */
import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs'
import { join } from 'node:path'
import { homedir } from 'node:os'
import { encrypt, decrypt } from './crypto-util.js'

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

const API_BASE = 'https://cmdcode.cn/xiaoc/cmdcode_api.php'
const CMD_DIR = join(homedir(), '.cmdcode')
const USER_CACHE_FILE = join(CMD_DIR, 'user.enc')
const WORKSPACE_BASE = join(CMD_DIR, 'workspaces')
// 配额计算：admin 1GB，普通用户100MB
const SUPER_USERS = ['admin', 'root', 'administrator']
function getUserQuotaMb(username: string): number {
  return SUPER_USERS.includes(username) ? 1024 : 100
}

export { getUserQuotaMb }

// ═══════════════════════════════════════
// 类型
// ═══════════════════════════════════════

export interface UserInfo {
  username: string
  token: string
  expiresAt: string
  workspaceDir: string
}

export interface QuotaInfo {
  usedMb: number
  quotaMb: number
  remainingMb: number
  usagePercent: number
}

export interface SaveSnapshotResult {
  success: boolean
  message: string
}

/** 用户自定义模型配置 */
export interface UserModel {
  id: string
  name: string
  model: string
  baseUrl: string
  apiKey: string
  note1?: string
  note2?: string
  createdAt: string
  isDefault: boolean
}

// ═══════════════════════════════════════
// 远程API调用
// ═══════════════════════════════════════

async function apiCall(action: string, data?: Record<string, string>, token?: string): Promise<any> {
  const url = `${API_BASE}?action=${action}`
  const headers: Record<string, string> = {
    'Content-Type': 'application/json',
  }
  if (token) {
    headers['Authorization'] = `Bearer ${token}`
  }

  const response = await fetch(url, {
    method: 'POST',
    headers,
    body: data ? JSON.stringify(data) : undefined,
    signal: AbortSignal.timeout(10_000), // 10秒超时
  })

  return await response.json()
}

// ═══════════════════════════════════════
// 用户注册
// ═══════════════════════════════════════

export async function register(username: string, password: string): Promise<UserInfo> {
  const result = await apiCall('register', { username, password })

  if (result.error) {
    throw new Error(result.error)
  }

  const userInfo: UserInfo = {
    username: result.username,
    token: result.token,
    expiresAt: result.expires_at,
    workspaceDir: join(WORKSPACE_BASE, result.username),
  }

  // 创建用户专属文件夹
  if (!existsSync(userInfo.workspaceDir)) {
    mkdirSync(userInfo.workspaceDir, { recursive: true })
  }

  // 本地加密缓存token
  saveUserCache(userInfo)

  return userInfo
}

// ═══════════════════════════════════════
// 用户登录
// ═══════════════════════════════════════

export async function login(username: string, password: string): Promise<UserInfo> {
  const result = await apiCall('login', { username, password })

  if (result.error) {
    throw new Error(result.error)
  }

  const userInfo: UserInfo = {
    username: result.username,
    token: result.token,
    expiresAt: result.expires_at,
    workspaceDir: join(WORKSPACE_BASE, result.username),
  }

  // 创建用户专属文件夹
  if (!existsSync(userInfo.workspaceDir)) {
    mkdirSync(userInfo.workspaceDir, { recursive: true })
  }

  // 本地加密缓存token
  saveUserCache(userInfo)

  return userInfo
}

// ═══════════════════════════════════════
// 断点续传：保存工作区快照
// ═══════════════════════════════════════

export async function saveWorkspaceSnapshot(
  userInfo: UserInfo,
  snapshot: string
): Promise<SaveSnapshotResult> {
  const result = await apiCall('save', { snapshot }, userInfo.token)

  if (result.error) {
    return { success: false, message: result.error }
  }

  return { success: true, message: result.message }
}

// ═══════════════════════════════════════
// 断点续传：恢复工作区快照
// ═══════════════════════════════════════

export async function restoreWorkspaceSnapshot(userInfo: UserInfo): Promise<string | null> {
  const result = await apiCall('restore', undefined, userInfo.token)

  if (result.error) {
    return null
  }

  return result.snapshot || null
}

// ═══════════════════════════════════════
// 配额查询
// ═══════════════════════════════════════

export async function getQuota(userInfo: UserInfo): Promise<QuotaInfo> {
  const result = await apiCall('quota', undefined, userInfo.token)

  if (result.error) {
    return { usedMb: 0, quotaMb: getUserQuotaMb(userInfo.username), remainingMb: getUserQuotaMb(userInfo.username), usagePercent: 0 }
  }

  return {
    usedMb: result.used_mb,
    quotaMb: result.quota_mb,
    remainingMb: result.remaining_mb,
    usagePercent: result.usage_percent,
  }
}

// ═══════════════════════════════════════
// 更新远程配额
// ═══════════════════════════════════════

export async function updateRemoteQuota(userInfo: UserInfo, usedMb: number): Promise<void> {
  await apiCall('update_quota', { used_mb: String(usedMb) }, userInfo.token)
}

// ═══════════════════════════════════════
// 本地Token缓存（加密存储）
// ═══════════════════════════════════════

function saveUserCache(userInfo: UserInfo): void {
  if (!existsSync(CMD_DIR)) mkdirSync(CMD_DIR, { recursive: true })
  const data = {
    username: userInfo.username,
    token: userInfo.token,
    expiresAt: userInfo.expiresAt,
  }
  writeFileSync(USER_CACHE_FILE, encrypt(data), 'utf-8')
  try { require('node:fs').chmodSync(USER_CACHE_FILE, 0o600) } catch { /* ignore */ }
}

export function loadUserCache(): UserInfo | null {
  if (!existsSync(USER_CACHE_FILE)) return null
  try {
    const data = decrypt<{ username: string; token: string; expiresAt: string }>(
      readFileSync(USER_CACHE_FILE, 'utf-8')
    )
    return {
      username: data.username,
      token: data.token,
      expiresAt: data.expiresAt,
      workspaceDir: join(WORKSPACE_BASE, data.username),
    }
  } catch {
    return null
  }
}

export function clearUserCache(): void {
  if (existsSync(USER_CACHE_FILE)) {
    require('node:fs').unlinkSync(USER_CACHE_FILE)
  }
}

// ═══════════════════════════════════════
// Token有效性验证
// ═══════════════════════════════════════

export async function validateToken(userInfo: UserInfo): Promise<boolean> {
  try {
    const result = await apiCall('quota', undefined, userInfo.token)
    return result.success === true
  } catch {
    return false
  }
}

/** 仅凭 token 字符串验证有效性（无需 UserInfo，用于 Web 多用户场景） */
export async function verifyAuthToken(token: string): Promise<UserInfo | null> {
  try {
    const result = await apiCall('quota', undefined, token)
    if (result.success === true && result.username) {
      return {
        username: result.username,
        token,
        expiresAt: result.expires_at || '',
        workspaceDir: getWorkspaceDir(result.username),
      }
    }
    return null
  } catch {
    return null
  }
}

// ═══════════════════════════════════════
// 获取用户工作区路径
// ═══════════════════════════════════════

export function getWorkspaceDir(username: string): string {
  return join(WORKSPACE_BASE, username)
}