'use client'

// 用户数据接口
export interface UserData {
  id: string
  email: string
  username: string | null
  avatar: string | null
  bio: string | null
  language: string
  isAdmin: boolean
  versionLimit: number
  subscriptionPlanId: string
  subscribePlan: string
  maxVersionLimit: number
  promptLimit?: number
  creditBalance: number
  createdAt: Date
  updatedAt: Date
}

// 缓存项接口
interface CacheItem<T> {
  data: T
  timestamp: number
  expiresAt: number
}

// 缓存配置
const CACHE_CONFIG = {
  USER_DATA_TTL: 5 * 60 * 1000, // 用户数据缓存5分钟
  SYNC_COOLDOWN: 30 * 1000, // 同步冷却时间30秒
  MAX_CACHE_SIZE: 100, // 最大缓存条目数
} as const

// 全局缓存存储
class UserCache {
  private userDataCache = new Map<string, CacheItem<UserData>>()
  private syncTimestamps = new Map<string, number>()
  private syncPromises = new Map<string, Promise<void>>()

  // 获取缓存的用户数据
  getUserData(userId: string): UserData | null {
    const cached = this.userDataCache.get(userId)
    if (!cached) return null

    // 检查是否过期
    if (Date.now() > cached.expiresAt) {
      this.userDataCache.delete(userId)
      return null
    }

    return cached.data
  }

  // 设置用户数据缓存
  setUserData(userId: string, data: UserData): void {
    // 清理过期缓存
    this.cleanExpiredCache()

    // 如果缓存过大，清理最旧的条目
    if (this.userDataCache.size >= CACHE_CONFIG.MAX_CACHE_SIZE) {
      this.cleanOldestCache()
    }

    const now = Date.now()
    this.userDataCache.set(userId, {
      data,
      timestamp: now,
      expiresAt: now + CACHE_CONFIG.USER_DATA_TTL,
    })
  }

  // 检查是否可以进行同步（冷却时间检查）
  canSync(userId: string): boolean {
    const lastSync = this.syncTimestamps.get(userId)
    if (!lastSync) return true

    return Date.now() - lastSync > CACHE_CONFIG.SYNC_COOLDOWN
  }

  // 记录同步时间
  recordSync(userId: string): void {
    this.syncTimestamps.set(userId, Date.now())
  }

  // 获取或创建同步Promise（防止重复同步）
  getSyncPromise(userId: string, syncFn: () => Promise<void>): Promise<void> {
    const existing = this.syncPromises.get(userId)
    if (existing) return existing

    const promise = syncFn().finally(() => {
      this.syncPromises.delete(userId)
    })

    this.syncPromises.set(userId, promise)
    return promise
  }

  // 清除用户相关的所有缓存
  clearUserCache(userId: string): void {
    this.userDataCache.delete(userId)
    this.syncTimestamps.delete(userId)
    this.syncPromises.delete(userId)
  }

  // 清除所有缓存
  clearAllCache(): void {
    this.userDataCache.clear()
    this.syncTimestamps.clear()
    this.syncPromises.clear()
  }

  // 清理过期缓存
  private cleanExpiredCache(): void {
    const now = Date.now()
    for (const [key, item] of this.userDataCache.entries()) {
      if (now > item.expiresAt) {
        this.userDataCache.delete(key)
      }
    }
  }

  // 清理最旧的缓存条目
  private cleanOldestCache(): void {
    let oldestKey: string | null = null
    let oldestTime = Date.now()

    for (const [key, item] of this.userDataCache.entries()) {
      if (item.timestamp < oldestTime) {
        oldestTime = item.timestamp
        oldestKey = key
      }
    }

    if (oldestKey) {
      this.userDataCache.delete(oldestKey)
    }
  }

  // 获取缓存统计信息（用于调试）
  getCacheStats() {
    return {
      userDataCacheSize: this.userDataCache.size,
      syncTimestampsSize: this.syncTimestamps.size,
      activeSyncPromises: this.syncPromises.size,
    }
  }
}

// 导出全局缓存实例
export const userCache = new UserCache()

// 同步触发条件枚举
export enum SyncTrigger {
  INITIAL_LOAD = 'initial_load',
  SIGN_IN = 'sign_in',
  PROFILE_UPDATE = 'profile_update',
  SUBSCRIPTION_CHANGE = 'subscription_change',
  MANUAL_REFRESH = 'manual_refresh',
}

// 同步选项接口
export interface SyncOptions {
  trigger: SyncTrigger
  force?: boolean // 强制同步，忽略冷却时间
  skipCache?: boolean // 跳过缓存，直接从服务器获取
}

// 判断是否需要同步的函数
export function shouldSync(userId: string, options: SyncOptions): boolean {
  // 强制同步
  if (options.force) return true

  // 跳过缓存的情况
  if (options.skipCache) return true

  // 检查冷却时间
  if (!userCache.canSync(userId)) return false

  // 根据触发条件判断
  switch (options.trigger) {
    case SyncTrigger.INITIAL_LOAD:
      // 初始加载时，如果有缓存就不同步
      return !userCache.getUserData(userId)
    
    case SyncTrigger.SIGN_IN:
      // 登录时总是同步
      return true
    
    case SyncTrigger.PROFILE_UPDATE:
    case SyncTrigger.SUBSCRIPTION_CHANGE:
    case SyncTrigger.MANUAL_REFRESH:
      // 这些情况总是同步
      return true
    
    default:
      return false
  }
}
