import { createError, defineEventHandler, getQuery } from 'h3'
import { db } from '~/drizzle/db'
import { songs, users, votes, userIdentities } from '~/drizzle/schema'
import { CacheService } from '../../../services/cacheService'
import { getUserAvatarUrl } from '../../../utils/user-avatar'

export default defineEventHandler(async (event) => {
  const user = event.context.user
  if (!user || !['ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
    throw createError({
      statusCode: 403,
      message: '需要管理员权限'
    })
  }

  const query = getQuery(event)
  const semester = query.semester as string
  const limit = parseInt(query.limit as string) || 20

  try {
    const cacheService = CacheService.getInstance()
    const cachedStats = await cacheService.getActiveUsersStats(semester, limit)
    if (cachedStats) {
      console.log('[Cache] 活跃用户统计数据缓存命中')
      return cachedStats
    }

    let songWhere = {}
    if (semester && semester !== 'all') {
      songWhere = { semester: semester }
    }

    const allUsers = await db.select().from(users)
    const allSongs = await db.select().from(songs)
    const allVotes = await db.select().from(votes)
    const allIdentities = await db.select().from(userIdentities)

    const identitiesMap = new Map<number, typeof allIdentities>()
    allIdentities.forEach((identity) => {
      if (!identitiesMap.has(identity.userId)) {
        identitiesMap.set(identity.userId, [])
      }
      identitiesMap.get(identity.userId)!.push(identity)
    })

    const activeUsers = allUsers
      .filter((user) => {
        const userSongs = allSongs.filter((song) => {
          if (song.requesterId !== user.id) return false
          if (semester && semester !== 'all' && song.semester !== semester) return false
          return true
        })
        return userSongs.length > 0
      })
      .map((user) => {
        const userSongs = allSongs
          .filter((song) => {
            if (song.requesterId !== user.id) return false
            if (semester && semester !== 'all' && song.semester !== semester) return false
            return true
          })
          .map((song) => ({
            ...song,
            votes: allVotes.filter((vote) => vote.songId === song.id)
          }))

        return {
          ...user,
          songs: userSongs
        }
      })

    if (activeUsers.length === 0) {
      const emptyResult = []
      await cacheService.setActiveUsersStats(semester, limit, emptyResult)
      console.log('[Cache] 活跃用户统计数据已缓存（空结果）')
      return emptyResult
    }

    const userStats = activeUsers.map((user) => {
      const contributions = user.songs.length
      const likes = user.songs.reduce((total, song) => total + song.votes.length, 0)
      const activityScore = Math.round(contributions * 2 + likes * 0.5)
      const userIdentitiesData = identitiesMap.get(user.id) || []
      const avatarUrl = getUserAvatarUrl(
        {
          id: user.id,
          name: user.name,
          username: user.username,
          email: user.email,
          avatarProvider: user.avatarProvider,
          avatarProviderUserId: user.avatarProviderUserId
        },
        userIdentitiesData
      )

      return {
        id: user.id,
        name: user.name || user.username,
        contributions,
        likes,
        activityScore,
        avatarUrl
      }
    })

    const sortedUsers = userStats.sort((a, b) => b.activityScore - a.activityScore).slice(0, limit)

    await cacheService.setActiveUsersStats(semester, limit, sortedUsers)
    console.log('[Cache] 活跃用户统计数据已缓存')

    return sortedUsers
  } catch (error) {
    console.error('[Stats] 获取活跃用户失败:', error)
    return []
  }
})