import { getDb } from '../client'
import { providerModels } from '../schema'
import { eq, and } from 'drizzle-orm'
import type { ModelRecord } from '@/lib/engine/model-registry/types'

/**
 * ProviderModel Repository。
 *
 * 负责 provider_models 表的读写。设计约定：
 * - 每次刷新时整组替换某个 (provider_id, user_id) 下的记录。
 * - capabilities / aliases 以 JSON 字符串存储。
 * - id 生成规则：provider_id:user_id:model_id，保证唯一性。
 */

function makeId(providerId: string, userId: string, modelId: string): string {
  return `${providerId}:${userId}:${modelId}`
}

export interface PersistedProviderModel {
  id: string
  providerId: string
  userId: string
  modelId: string
  label: string
  capabilities: Record<string, unknown>
  aliases: string[]
  source: 'seed' | 'dynamic'
  status: 'available' | 'unavailable'
  fetchedAt: string
  createdAt: string
  updatedAt: string
}

function mapRow(row: typeof providerModels.$inferSelect): PersistedProviderModel {
  return {
    id: row.id,
    providerId: row.providerId,
    userId: row.userId,
    modelId: row.modelId,
    label: row.label,
    capabilities: safeJsonParse(row.capabilities, {}),
    aliases: safeJsonParse(row.aliases, []),
    source: row.source as 'seed' | 'dynamic',
    status: row.status as 'available' | 'unavailable',
    fetchedAt: row.fetchedAt,
    createdAt: row.createdAt,
    updatedAt: row.updatedAt,
  }
}

function safeJsonParse<T>(value: string, fallback: T): T {
  try {
    return JSON.parse(value) as T
  } catch {
    return fallback
  }
}

export const providerModelRepo = {
  /** 整组替换某个 provider + user 下的模型记录 */
  replaceProviderModels(providerId: string, userId: string, records: ModelRecord[]) {
    const db = getDb()
    db.transaction((tx) => {
      tx.delete(providerModels)
        .where(and(eq(providerModels.providerId, providerId), eq(providerModels.userId, userId)))
        .run()

    if (records.length === 0) return

    const now = new Date().toISOString()
    tx.insert(providerModels)
        .values(
          records.map((r) => ({
            id: makeId(providerId, userId, r.id),
            providerId,
            userId,
            modelId: r.id,
            label: r.label,
            capabilities: JSON.stringify(r.capabilities || {}),
            aliases: JSON.stringify(r.aliases || []),
            source: r.source,
            status: r.status || 'available',
            fetchedAt: now,
            createdAt: now,
            updatedAt: now,
          })),
        )
        .run()
    })
  },

  /** 列出某用户全部模型记录 */
  listByUser(userId: string): PersistedProviderModel[] {
    const rows = getDb()
      .select()
      .from(providerModels)
      .where(eq(providerModels.userId, userId))
      .all()
    return rows.map(mapRow)
  },

  /** 列出某个 provider 的模型记录 */
  listByProvider(providerId: string, userId: string): PersistedProviderModel[] {
    const rows = getDb()
      .select()
      .from(providerModels)
      .where(and(eq(providerModels.providerId, providerId), eq(providerModels.userId, userId)))
      .all()
    return rows.map(mapRow)
  },

  /** 删除某个 provider 的全部记录（删除 provider 时调用） */
  deleteByProvider(providerId: string, userId: string) {
    getDb()
      .delete(providerModels)
      .where(and(eq(providerModels.providerId, providerId), eq(providerModels.userId, userId)))
      .run()
  },
}