/** Local custom models. Credentials stay in the main process; legacy config is read only. */
import { app, safeStorage } from 'electron'
import { promises as fs } from 'node:fs'
import { join } from 'node:path'
import { randomUUID } from 'node:crypto'
import type { CustomModelInput, CustomModelProfile, ModelRegistryView, ModelTestResult, ResolvedModel, ModelDiscoveryInput, ModelDiscoveryResult, ModelEndpoint } from '@shared/models'
import { resolveOpenAIEndpoint } from '@shared/openai-endpoint'
import { apiProtocol, endpointCandidates, endpointUrl, inferModelApi, modelEndpoint, modelHeaders, normalizeModelAddress, openAICompletionTokenField } from '@shared/model-endpoint'
import { cachedConnection, cachedGeneration, discoverModelConnection, modelFetch, readModelJson, rememberGeneration } from './model-connection'
import { modelMetadata } from './model-metadata'
import { resolveModelTokenLimits } from '@shared/model-token-limits'
import { getGatewayConfig } from './config'

interface StoredModel extends Omit<CustomModelProfile, 'hasApiKey' | 'keyStorage'> {
  apiKeyEnc?: string
  apiKeyPlain?: string
}
interface StoredRegistry {
  version: 1
  models: StoredModel[]
  selectedModelId: string | null
}

let cache: StoredRegistry | null = null
let loading: Promise<StoredRegistry> | null = null
let writes: Promise<unknown> = Promise.resolve()

function filePath(): string { return join(app.getPath('userData'), 'models.json') }

function readKey(model: StoredModel): { key: string; storage: CustomModelProfile['keyStorage'] } {
  if (model.apiKeyEnc) {
    try { return { key: safeStorage.decryptString(Buffer.from(model.apiKeyEnc, 'base64')), storage: 'encrypted' } }
    catch { return { key: '', storage: 'none' } }
  }
  return model.apiKeyPlain ? { key: model.apiKeyPlain, storage: 'plaintext' } : { key: '', storage: 'none' }
}

function writeKey(model: StoredModel, key: string): void {
  delete model.apiKeyEnc
  delete model.apiKeyPlain
  if (!key) return
  try {
    if (safeStorage.isEncryptionAvailable()) model.apiKeyEnc = safeStorage.encryptString(key).toString('base64')
    else model.apiKeyPlain = key
  } catch { throw new Error('无法安全保存 API Key，请检查系统加密服务') }
}

function viewOf(model: StoredModel): CustomModelProfile {
  const { apiKeyEnc: _encrypted, apiKeyPlain: _plain, ...profile } = model
  const { key, storage } = readKey(model)
  const { error, compaction: _compaction, ...budget } = resolveModelTokenLimits(profile)
  return { ...profile, ...(!error ? budget : {}), supportedEfforts: profile.supportedEfforts?.slice(), hasApiKey: !!key, keyStorage: key ? storage : 'none' }
}

function registryView(registry: StoredRegistry): ModelRegistryView {
  return { models: registry.models.map(viewOf), selectedModelId: registry.selectedModelId }
}

async function persist(registry: StoredRegistry): Promise<void> {
  const file = filePath()
  await fs.mkdir(join(file, '..'), { recursive: true })
  const temporary = `${file}.${randomUUID()}.tmp`
  try {
    await fs.writeFile(temporary, JSON.stringify(registry, null, 2), { encoding: 'utf8', mode: 0o600 })
    await fs.rename(temporary, file)
    cache = registry
  } catch (error) {
    await fs.unlink(temporary).catch(() => undefined)
    throw error
  }
}

async function readRegistry(persistMigration: boolean): Promise<StoredRegistry> {
    let raw: string
    try { raw = await fs.readFile(filePath(), 'utf8') }
    catch (error) {
      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error
      const legacy = await getGatewayConfig()
      const migrated: StoredModel = {
        id: 'legacy-default', name: legacy.model, providerId: 'custom',
        model: legacy.model, baseUrl: legacy.baseUrl, authMode: 'api-key', protocol: 'anthropic',
        supportsToolCall: true, supportsImages: false, supportsReasoning: false,
        temperature: legacy.temperature, maxToolRounds: legacy.maxToolRounds
      }
      writeKey(migrated, legacy.apiKey)
      const initial: StoredRegistry = { version: 1, models: [migrated], selectedModelId: migrated.id }
      if (persistMigration) await persist(initial)
      return initial
    }
    let parsed: Partial<StoredRegistry> & { schemaVersion?: number }
    try { parsed = JSON.parse(raw) as typeof parsed }
    catch { throw new Error('模型配置文件损坏，请保留 models.json 后检查内容') }
    // Accept either version marker without rewriting existing secrets during a read.
    if (!parsed || typeof parsed !== 'object' || (parsed.version ?? parsed.schemaVersion) !== 1 || !Array.isArray(parsed.models)) {
      throw new Error('无法读取此版本的模型配置文件')
    }
    const ids = new Set<string>()
    for (const model of parsed.models) {
      if (!model || typeof model.id !== 'string' || !model.id || ids.has(model.id)
        || typeof model.model !== 'string' || typeof model.baseUrl !== 'string'
        || typeof model.name !== 'string' || typeof model.providerId !== 'string') {
        throw new Error('模型配置内容无效，请保留 models.json 后检查内容')
      }
      ids.add(model.id)
    }
    const selectedModelId = parsed.selectedModelId === null ? null
      : typeof parsed.selectedModelId === 'string' && ids.has(parsed.selectedModelId)
        ? parsed.selectedModelId : parsed.models[0]?.id ?? null
    return { version: 1, models: parsed.models, selectedModelId }
}

async function load(): Promise<StoredRegistry> {
  if (cache) return cache
  if (loading) return loading
  loading = readRegistry(true).then(registry => { cache = registry; return registry })
  try { return await loading }
  finally { loading = null }
}

function mutate(operation: (registry: StoredRegistry) => Promise<ModelRegistryView>): Promise<ModelRegistryView> {
  const next = writes.then(async () => operation(await load()))
  writes = next.catch(() => undefined)
  return next
}

function normalize(input: CustomModelInput, existing?: StoredModel, testing = false): StoredModel {
  if (!input || typeof input !== 'object') throw new Error('模型配置无效')
  const providerId = 'custom'
  const model = typeof input.model === 'string' ? input.model.trim() : ''
  const baseUrl = typeof input.baseUrl === 'string' ? normalizeModelAddress(input.baseUrl) : ''
  if (!providerId) throw new Error('请选择供应商')
  if (!model) throw new Error('请输入模型名称')
  if (!baseUrl) throw new Error('请输入 API 地址')
  let endpoint: URL
  try { endpoint = new URL(baseUrl) } catch { throw new Error('请输入有效的 API 地址') }
  if (!['http:', 'https:'].includes(endpoint.protocol) || endpoint.username || endpoint.password) throw new Error('API 地址必须使用 http 或 https，且不能包含账户密码')
  if (endpoint.search || endpoint.hash) throw new Error('API 地址不能包含查询参数或片段')
  const id = typeof input.id === 'string' ? input.id.trim() : ''
  const name = typeof input.name === 'string' ? input.name.trim() : ''
  if (!id) throw new Error('模型标识不能为空')
  if (!name) throw new Error('请输入模型显示名称')
  if (input.authMode !== undefined && !['api-key', 'none'].includes(input.authMode)) throw new Error('鉴权方式无效')
  const suppliedKey = typeof input.apiKey === 'string' ? input.apiKey.replace(/\s/gu, '') : ''
  if (suppliedKey && !/^[\x21-\x7e]+$/.test(suppliedKey)) throw new Error('API Key 只能包含 ASCII 可打印字符')
  const authMode = input.authMode ?? 'api-key'
  const key = authMode === 'none' || input.clearApiKey ? '' : suppliedKey || (existing ? readKey(existing).key : '')
  if (authMode !== 'none' && !key && (testing || !input.clearApiKey)) throw new Error('请输入 API Key')
  const next: StoredModel = { id, name, providerId, model, baseUrl, authMode }
  if (input.protocol !== undefined && input.protocol !== 'anthropic') throw new Error('首版仅支持 Anthropic 协议')
  next.protocol = 'anthropic'
  if (input.tokenBudgetVersion !== undefined && input.tokenBudgetVersion !== 2) throw new Error('模型上下文配置版本无效')
  if (input.tokenBudgetVersion === 2) next.tokenBudgetVersion = 2
  const configuredEndpoint = input.endpoint ?? (baseUrl === existing?.baseUrl && next.protocol === existing?.protocol && !suppliedKey ? existing.endpoint : undefined)
  if (configuredEndpoint) {
    if (!['openai-completions', 'openai-responses', 'anthropic-messages', 'google-generative-ai'].includes(configuredEndpoint.api)) throw new Error('协商协议无效')
    const root = normalizeModelAddress(configuredEndpoint.baseUrl)
    if (new URL(root).origin !== endpoint.origin || apiProtocol(configuredEndpoint.api) !== 'anthropic') throw new Error('协商地址与填写的域名或协议不一致')
    next.endpoint = { api: configuredEndpoint.api, baseUrl: root, checkedAt: configuredEndpoint.checkedAt,
      ...(['models', 'generation'].includes(configuredEndpoint.verifiedBy ?? '') ? { verifiedBy: configuredEndpoint.verifiedBy } : {}) }
  }
  for (const field of ['supportsToolCall', 'supportsImages', 'supportsReasoning', 'onlyReasoning', 'canDisableThinking', 'useCustomProtocol'] as const) {
    if (typeof input[field] === 'boolean') next[field] = input[field]
  }
  if (next.supportsReasoning) {
    if (typeof input.defaultEffort === 'string') next.defaultEffort = input.defaultEffort
    if (Array.isArray(input.supportedEfforts) && input.supportedEfforts.every(value => typeof value === 'string')) next.supportedEfforts = [...new Set(input.supportedEfforts)]
  } else {
    delete next.onlyReasoning
    delete next.canDisableThinking
  }
  for (const field of ['maxInputTokens', 'maxOutputTokens', 'contextWindowTokens', 'reasoningBudget'] as const) {
    const value = input[field]
    if (value !== undefined) {
      if (!Number.isFinite(value)) throw new Error('Token 数量必须是有效数字')
      if (!Number.isSafeInteger(value) || value < 0) throw new Error('Token 数量必须是非负整数')
      next[field] = Math.trunc(value)
    }
  }
  for (const field of ['temperature', 'maxToolRounds'] as const) {
    const value = input[field] ?? existing?.[field]
    if (value !== undefined) {
      if (!Number.isFinite(value)) throw new Error('模型参数必须是有效数字')
      next[field] = field === 'temperature' ? Math.max(0, Math.min(2, value)) : Math.max(1, Math.min(24, Math.round(value)))
    }
  }
  // Preserve ciphertext when editing without a new key (including on platforms temporarily unable to encrypt).
  if (existing && authMode !== 'none' && !input.clearApiKey && !suppliedKey) {
    next.apiKeyEnc = existing.apiKeyEnc
    next.apiKeyPlain = existing.apiKeyPlain
  } else writeKey(next, key)
  return next
}

export async function listModels(): Promise<ModelRegistryView> {
  await writes
  return registryView(await load())
}

export function saveModel(input: CustomModelInput, overwrite = false): Promise<ModelRegistryView> {
  return mutate(async registry => {
    const previousId = input?.previousId || input?.id
    const existing = registry.models.find(model => model.id === previousId)
    const target = registry.models.find(model => model.id === input?.id?.trim())
    if (target && target.id !== input.previousId && !overwrite) throw new Error('同名模型已存在，请确认是否覆盖')
    const next = normalize(input, existing ?? target)
    const metadata = await modelMetadata(next.model, next.protocol ?? 'auto').catch(() => null)
    if (metadata) {
      next.metadata = metadata; next.price = metadata.price
      if (next.protocol) {
        for (const field of ['supportsToolCall', 'supportsImages', 'supportsReasoning', 'contextWindowTokens', 'maxInputTokens', 'maxOutputTokens'] as const) {
          if (input[field] === undefined) (next as unknown as Record<string, unknown>)[field] = metadata[field]
        }
        if (next.supportsReasoning) {
          for (const field of ['onlyReasoning', 'canDisableThinking', 'defaultEffort', 'supportedEfforts'] as const) if (input[field] === undefined) (next as unknown as Record<string, unknown>)[field] = metadata[field]
          if (input.reasoningBudget === undefined && metadata.reasoningOptions.some(option => option.type === 'budget_tokens')) next.reasoningBudget = 1024
        }
      }
    }
    {
      if (input.maxInputTokens === undefined) next.tokenBudgetVersion = 2
      const { error, compaction: _compaction, ...limits } = resolveModelTokenLimits(next)
      if (error) throw new Error(error)
      Object.assign(next, limits)
    }
    if (next.protocol && !next.endpoint) {
      // Discovery is read-only; servers without a models API still support manual model IDs.
      const connection = await discoverModelConnection(next.baseUrl, next.protocol, readKey(next).key).catch(() => undefined)
      if (connection) next.endpoint = connection.endpoint
    }
    const remaining = registry.models.filter(model => model.id !== previousId && model.id !== next.id)
    const oldIndex = registry.models.findIndex(model => model.id === previousId || model.id === next.id)
    remaining.splice(oldIndex < 0 ? remaining.length : Math.min(oldIndex, remaining.length), 0, next)
    const selectedModelId = !registry.selectedModelId || registry.selectedModelId === previousId ? next.id : registry.selectedModelId
    const updated: StoredRegistry = { version: 1, models: remaining, selectedModelId }
    await persist(updated)
    return registryView(updated)
  })
}

export function deleteModel(id: string): Promise<ModelRegistryView> {
  return mutate(async registry => {
    const models = registry.models.filter(model => model.id !== id)
    const selectedModelId = registry.selectedModelId === id ? models[0]?.id ?? null : registry.selectedModelId
    const updated: StoredRegistry = { version: 1, models, selectedModelId }
    await persist(updated)
    return registryView(updated)
  })
}

export function setSelectedModel(id: string | null): Promise<ModelRegistryView> {
  return mutate(async registry => {
    if (id !== null && !registry.models.some(model => model.id === id)) throw new Error('所选模型不存在')
    const updated: StoredRegistry = { ...registry, selectedModelId: id }
    await persist(updated)
    return registryView(updated)
  })
}

export async function resolveModel(id?: string | null): Promise<ResolvedModel | null> {
  await writes
  const registry = await load()
  const targetId = id === undefined ? registry.selectedModelId : id
  if (!targetId) return null
  const model = registry.models.find(model => model.id === targetId)
  if (!model) throw new Error('所选模型不存在，请重新选择模型')
  const budget = resolveModelTokenLimits(model)
  if (budget.error) throw new Error(budget.error)
  const profile = viewOf(model)
  const legacy = await getGatewayConfig()
  const verified = model.protocol ? cachedGeneration(model.baseUrl, model.protocol, readKey(model).key, model.model) : undefined
  const resolved = verified && verified.checkedAt >= (model.endpoint?.checkedAt ?? 0) ? verified : model.endpoint
    ?? (model.protocol ? cachedConnection(model.baseUrl, model.protocol, readKey(model).key)?.endpoint ?? modelEndpoint(model.baseUrl, inferModelApi(model.baseUrl, model.protocol)) : undefined)
  return {
    profile,
    config: { ...legacy, baseUrl: resolved?.baseUrl ?? model.baseUrl, api: resolved?.api, model: model.model, apiKey: readKey(model).key,
      supportsReasoning: model.supportsReasoning, reasoningBudget: model.reasoningBudget, reasoningOptions: model.metadata?.reasoningOptions,
      temperatureSupported: model.metadata?.temperature,
      authMode: model.authMode, maxOutputTokens: profile.maxOutputTokens,
      temperature: model.temperature ?? legacy.temperature, maxToolRounds: model.maxToolRounds ?? legacy.maxToolRounds }
  }
}

export async function fetchModels(input: ModelDiscoveryInput): Promise<ModelDiscoveryResult> {
  if (!input || typeof input.baseUrl !== 'string' || (input.protocol !== undefined && input.protocol !== 'anthropic')) throw new Error('首版仅支持 Anthropic 协议')
  await writes
  const registry = cache ?? await readRegistry(false), existing = registry.models.find(model => model.id === input.previousId)
  const key = input.authMode === 'none' ? '' : typeof input.apiKey === 'string' && input.apiKey.trim() ? input.apiKey.replace(/\s/gu, '') : existing ? readKey(existing).key : ''
  if (!key && input.authMode !== 'none') throw new Error('请输入 API Key')
  return discoverModelConnection(input.baseUrl, 'anthropic', key, true)
}

/** Test only the user-specified origin, negotiating paths/protocols before reporting success. */
export async function testModel(input: CustomModelInput): Promise<ModelTestResult> {
  const startedAt = Date.now()
  const result = (success: boolean, message: string): ModelTestResult => ({ success, message, durationMs: Date.now() - startedAt })
  let model: StoredModel
  try {
    await writes
    const registry = cache ?? await readRegistry(false)
    model = normalize(input, registry.models.find(item => item.id === (input.previousId || input.id)), true)
  } catch (error) { return result(false, (error as Error).message) }
  const controller = new AbortController()
  const timer = setTimeout(() => controller.abort(), 15_000)
  try {
    const key = readKey(model).key
    const legacy = resolveOpenAIEndpoint(model.baseUrl)
    const known = model.protocol ? model.endpoint ?? cachedConnection(model.baseUrl, model.protocol, key)?.endpoint : undefined
    // Re-testing an OpenAI route follows the current preference, including at a negotiated custom root.
    // Stored routes continue to serve ordinary chat until a new generation probe succeeds.
    const preferred = known && (known.api === 'openai-completions' || known.api === 'openai-responses')
      ? { ...known, api: inferModelApi(model.baseUrl, model.protocol) } : known
    const candidates: ModelEndpoint[] = model.protocol ? [preferred, ...endpointCandidates(model.baseUrl, model.protocol), known].filter((value): value is ModelEndpoint => !!value)
      : [{ ...legacy, checkedAt: 0 }]
    const tried = new Set<string>(); let status = 0
    for (const endpoint of candidates) {
      const url = model.protocol ? endpointUrl(endpoint, 'generate', model.model) : legacy.endpoint
      if (tried.has(url + endpoint.api)) continue
      tried.add(url + endpoint.api)
      const payload = endpoint.api === 'openai-responses' ? { model: model.model, input: 'Reply with OK.', stream: false, max_output_tokens: 16 }
        : endpoint.api === 'anthropic-messages' ? { model: model.model, messages: [{ role: 'user', content: 'Reply with OK.' }], max_tokens: 16 }
          : endpoint.api === 'google-generative-ai' ? { contents: [{ role: 'user', parts: [{ text: 'Reply with OK.' }] }], generationConfig: { maxOutputTokens: 16 } }
            : { model: model.model, messages: [{ role: 'user', content: 'Reply with OK.' }], stream: false, [openAICompletionTokenField(model.model)]: 16 }
      const response = await modelFetch(url, { method: 'POST', signal: controller.signal, headers: modelHeaders(endpoint.api, key), body: JSON.stringify(payload) })
      status = response.status
      if (!response.ok) { await response.body?.cancel(); if ([401, 403, 429].includes(status) && model.protocol !== 'auto') break; continue }
      let parsed: unknown
      try { parsed = await readModelJson(response, 1024 * 1024) } catch { continue }
      const value = parsed as Record<string, unknown> | null
      const valid = endpoint.api === 'openai-responses' ? isResponsesTestResult(parsed) : endpoint.api === 'anthropic-messages'
        ? value?.type === 'message' && Array.isArray(value.content) : endpoint.api === 'google-generative-ai'
          ? Array.isArray(value?.candidates) && value.candidates.length > 0 : Array.isArray(value?.choices) && value.choices.some(choice => choice && (choice.message || typeof choice.text === 'string'))
      if (!valid) continue
      const verified: ModelEndpoint = { api: endpoint.api, baseUrl: endpoint.baseUrl, checkedAt: Date.now(), verifiedBy: 'generation' }
      if (model.protocol) rememberGeneration(model.baseUrl, model.protocol, key, model.model, verified)
      return { ...result(true, '连接测试成功'), endpoint: verified }
    }
    const messages: Record<number, string> = { 401: '鉴权失败，请检查 API Key', 403: '上游拒绝访问，请检查 API Key 和权限', 404: '未找到模型或接口，请检查模型名称和 API 地址', 429: '上游请求频率或额度受限，请稍后重试' }
    return result(false, messages[status] ?? (status >= 400 ? `上游返回 HTTP ${status}` : '上游未返回兼容的对话结果'))
  } catch (error) {
    if (controller.signal.aborted) return result(false, '连接超时，请检查 API 地址或稍后重试')
    return result(false, error instanceof SyntaxError ? '上游未返回有效的 JSON 对话结果' : '无法连接上游，请检查 API 地址和网络')
  } finally { clearTimeout(timer) }
}

/** A short probe may spend its whole output budget on reasoning without producing visible text. */
function isResponsesTestResult(value: unknown): boolean {
  if (!value || typeof value !== 'object' || Array.isArray(value)) return false
  const response = value as Record<string, unknown>
  if (response.error != null || (response.object !== undefined && response.object !== 'response')
    || (response.status !== undefined && response.status !== 'completed' && response.status !== 'incomplete')
    || !Array.isArray(response.output)) return false
  const validOutput = response.output.every(item => {
    if (!item || typeof item !== 'object' || Array.isArray(item)) return false
    const output = item as Record<string, unknown>
    if (output.type === 'reasoning') {
      return Array.isArray(output.summary) && output.summary.every(part => part && typeof part === 'object'
        && part.type === 'summary_text' && typeof part.text === 'string')
    }
    return output.type === 'message' && output.role === 'assistant' && Array.isArray(output.content)
      && output.content.length > 0 && output.content.every(part => part && typeof part === 'object'
        && ((part.type === 'output_text' && typeof part.text === 'string')
          || (part.type === 'refusal' && typeof part.refusal === 'string')))
  })
  if (!validOutput) return false
  if (response.status === 'incomplete') {
    const details = response.incomplete_details
    return !!details && typeof details === 'object' && 'reason' in details
      && (details.reason === 'max_output_tokens' || details.reason === 'content_filter')
  }
  return response.output.length > 0
}