import { getDb } from '../client'
import { settings, userSettings } from '../schema'
import { eq, and } from 'drizzle-orm'
import { nowExpr } from '../shared/dialect-helpers'

/**
 * Settings Repository。封装两张 key-value 表：
 * - settings：全局 key-value（PK = key）
 * - userSettings：用户级 key-value（PK = user_id + key，覆盖全局同名 key）
 *
 * 语义对齐 src/lib/settings-store.ts：
 * - getEffective：先查用户覆盖，再回退全局
 * - listEffective：全局为底，用户覆盖合并
 * - upsertUserValues：批量 upsert，事务包裹
 */
export const settingsRepo = {
  // ===== 全局 settings =====

  /** 读取全局值 */
  getGlobal(key: string): string | undefined {
    const row = getDb()
      .select({ value: settings.value })
      .from(settings)
      .where(eq(settings.key, key))
      .get()
    return row?.value
  },

  /** 列出全部全局 settings */
  listGlobal(): { key: string; value: string }[] {
    return getDb()
      .select({ key: settings.key, value: settings.value })
      .from(settings)
      .all()
  },

  /** upsert 全局值（PK = key） */
  upsertGlobal(key: string, value: string) {
    getDb()
      .insert(settings)
      .values({ key, value })
      .onConflictDoUpdate({ target: settings.key, set: { value } })
      .run()
  },

  /** 删除全局值 */
  deleteGlobal(key: string) {
    getDb().delete(settings).where(eq(settings.key, key)).run()
  },

  // ===== 用户级 user_settings =====

  /** 读取指定用户的某 key 值 */
  getUserValue(userId: string, key: string): string | undefined {
    const row = getDb()
      .select({ value: userSettings.value })
      .from(userSettings)
      .where(and(eq(userSettings.userId, userId), eq(userSettings.key, key)))
      .get()
    return row?.value
  },

  /** 列出指定用户的全部 settings */
  listUser(userId: string): { key: string; value: string }[] {
    return getDb()
      .select({ key: userSettings.key, value: userSettings.value })
      .from(userSettings)
      .where(eq(userSettings.userId, userId))
      .all()
  },

  /** upsert 单个用户 setting（PK = user_id + key） */
  upsertUserValue(userId: string, key: string, value: string) {
    getDb()
      .insert(userSettings)
      .values({ userId, key, value, updatedAt: nowExpr() })
      .onConflictDoUpdate({
        target: [userSettings.userId, userSettings.key],
        set: { value, updatedAt: nowExpr() },
      })
      .run()
  },

  /**
   * 批量 upsert 用户 settings（对齐 settings-store.upsertUserSettings）。
   * 单事务包裹，确保原子性。
   */
  upsertUserValues(userId: string, values: Record<string, string>) {
    const db = getDb()
    db.transaction((tx) => {
      for (const [key, value] of Object.entries(values)) {
        tx.insert(userSettings)
          .values({ userId, key, value, updatedAt: nowExpr() })
          .onConflictDoUpdate({
            target: [userSettings.userId, userSettings.key],
            set: { value, updatedAt: nowExpr() },
          })
          .run()
      }
    })
  },

  /** 删除指定用户的某 key */
  deleteUserValue(userId: string, key: string) {
    getDb()
      .delete(userSettings)
      .where(and(eq(userSettings.userId, userId), eq(userSettings.key, key)))
      .run()
  },

  /** 删除指定用户的全部 settings（user 删除时调用） */
  deleteAllByUser(userId: string) {
    getDb().delete(userSettings).where(eq(userSettings.userId, userId)).run()
  },

  // ===== 合并视图（对齐 settings-store） =====

  /**
   * 读取生效值：用户覆盖优先，回退全局。
   * userId 省略时只查全局。
   */
  getEffective(key: string, userId?: string): string | undefined {
    if (userId) {
      const userValue = this.getUserValue(userId, key)
      if (userValue !== undefined) return userValue
    }
    return this.getGlobal(key)
  },

  /**
   * 列出合并后的 settings：全局为底，用户覆盖合并。
   * 对齐 settings-store.listSettings。
   */
  listEffective(userId: string): Record<string, string> {
    const merged: Record<string, string> = {}
    for (const row of this.listGlobal()) merged[row.key] = row.value
    for (const row of this.listUser(userId)) merged[row.key] = row.value
    return merged
  },
}