import { NextResponse } from 'next/server'
import { getSession } from '@/lib/auth'
import { getGameDbConfig, getGameDbPool } from '@/lib/game-db'

export async function GET(request: Request) {
  try {
    const session = await getSession()
    
    if (!session || !['ADMIN', 'SUPERADMIN'].includes(session.role)) {
      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
    }

    const { searchParams } = new URL(request.url)
    const page = parseInt(searchParams.get('page') || '1')
    const limit = parseInt(searchParams.get('limit') || '20')
    const search = searchParams.get('search') || ''
    const offset = (page - 1) * limit

    const config = await getGameDbConfig()
    if (!config) {
      return NextResponse.json({ error: 'Game database not configured' }, { status: 500 })
    }

    const pool = await getGameDbPool()
    if (!pool) {
      return NextResponse.json({ error: 'Failed to connect to game database' }, { status: 500 })
    }

    let players: any[] = []
    let totalCount = 0

    if (config.framework === 'QBCORE') {
      // QBCore Query
      const searchClause = search ? `WHERE citizenid LIKE ? OR name LIKE ? OR JSON_EXTRACT(charinfo, '$.firstname') LIKE ? OR JSON_EXTRACT(charinfo, '$.lastname') LIKE ?` : ''
      const searchParams = search ? [`%${search}%`, `%${search}%`, `%${search}%`, `%${search}%`] : []

      const [countResult] = await pool.query<any[]>(
        `SELECT COUNT(*) as count FROM players ${searchClause}`,
        searchParams
      )
      totalCount = countResult[0]?.count || 0

      const [rows] = await pool.query<any[]>(
        `SELECT 
          citizenid,
          license,
          name,
          money,
          charinfo,
          job,
          gang,
          metadata,
          position,
          discord,
          last_updated
        FROM players
        ${searchClause}
        ORDER BY last_updated DESC
        LIMIT ? OFFSET ?`,
        [...searchParams, limit, offset]
      )

      players = rows.map((row: any) => {
        const charinfo = typeof row.charinfo === 'string' ? JSON.parse(row.charinfo) : row.charinfo || {}
        const money = typeof row.money === 'string' ? JSON.parse(row.money) : row.money || {}
        const job = typeof row.job === 'string' ? JSON.parse(row.job) : row.job || {}
        const gang = typeof row.gang === 'string' ? JSON.parse(row.gang) : row.gang || {}
        const metadata = typeof row.metadata === 'string' ? JSON.parse(row.metadata) : row.metadata || {}

        return {
          id: row.citizenid,
          identifier: row.citizenid,
          license: row.license,
          name: `${charinfo.firstname || ''} ${charinfo.lastname || ''}`.trim() || row.name,
          firstName: charinfo.firstname || '',
          lastName: charinfo.lastname || '',
          dateOfBirth: charinfo.birthdate || '',
          gender: charinfo.gender,
          phone: charinfo.phone,
          money: {
            cash: money.cash || 0,
            bank: money.bank || 0,
            crypto: money.crypto || 0,
          },
          job: {
            name: job.name || 'unemployed',
            label: job.label || 'Arbeitslos',
            grade: job.grade?.level || 0,
            gradeLabel: job.grade?.name || '',
          },
          gang: {
            name: gang.name || 'none',
            label: gang.label || '',
          },
          metadata: {
            hunger: metadata.hunger || 100,
            thirst: metadata.thirst || 100,
            stress: metadata.stress || 0,
            isdead: metadata.isdead || false,
            inlaststand: metadata.inlaststand || false,
            armor: metadata.armor || 0,
            ishandcuffed: metadata.ishandcuffed || false,
            injail: metadata.injail || 0,
          },
          discord: row.discord,
          lastUpdated: row.last_updated,
          framework: 'QBCORE',
        }
      })
    } else {
      // ESX Query
      const searchClause = search ? `WHERE identifier LIKE ? OR firstname LIKE ? OR lastname LIKE ?` : ''
      const searchParams = search ? [`%${search}%`, `%${search}%`, `%${search}%`] : []

      const [countResult] = await pool.query<any[]>(
        `SELECT COUNT(*) as count FROM users ${searchClause}`,
        searchParams
      )
      totalCount = countResult[0]?.count || 0

      const [rows] = await pool.query<any[]>(
        `SELECT 
          identifier,
          accounts,
          job,
          job_grade,
          firstname,
          lastname,
          dateofbirth,
          sex,
          height,
          phone_number,
          position,
          discord,
          COALESCE(last_property, '') as last_property
        FROM users
        ${searchClause}
        ORDER BY identifier
        LIMIT ? OFFSET ?`,
        [...searchParams, limit, offset]
      )

      players = rows.map((row: any) => {
        const accounts = typeof row.accounts === 'string' ? JSON.parse(row.accounts) : row.accounts || {}

        return {
          id: row.identifier,
          identifier: row.identifier,
          license: row.identifier,
          name: `${row.firstname || ''} ${row.lastname || ''}`.trim() || 'Unknown',
          firstName: row.firstname || '',
          lastName: row.lastname || '',
          dateOfBirth: row.dateofbirth || '',
          gender: row.sex === 'm' ? 0 : row.sex === 'f' ? 1 : null,
          phone: row.phone_number,
          money: {
            cash: accounts.money || accounts.cash || 0,
            bank: accounts.bank || 0,
            black: accounts.black_money || 0,
          },
          job: {
            name: row.job || 'unemployed',
            label: row.job || 'Arbeitslos',
            grade: row.job_grade || 0,
            gradeLabel: '',
          },
          gang: null,
          discord: row.discord,
          lastUpdated: null,
          framework: 'ESX',
        }
      })
    }

    return NextResponse.json({
      players,
      pagination: {
        page,
        limit,
        total: totalCount,
        totalPages: Math.ceil(totalCount / limit),
      },
      framework: config.framework,
    })
  } catch (error) {
    console.error('[API] Failed to fetch player accounts:', error)
    return NextResponse.json(
      { error: 'Failed to fetch player accounts' },
      { status: 500 }
    )
  }
}