import { NextResponse } from 'next/server'
import { prisma } from '@/lib/db'
import { getGameDbPool } from '@/lib/game-db'
import { getCurrentUser } from '@/lib/auth'

export async function POST(request: Request) {
  try {
    const user = await getCurrentUser()
    if (!user || user.role !== 'SUPERADMIN') {
      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
    }

    const { type, config } = await request.json()
    
    const results: { check: string; status: 'success' | 'error' | 'warning'; message: string }[] = []

    switch (type) {
      case 'all':
        // Check UCP Database
        try {
          await prisma.$queryRaw`SELECT 1`
          results.push({ check: 'ucpDatabase', status: 'success', message: 'UCP Datenbank verbunden' })
        } catch {
          results.push({ check: 'ucpDatabase', status: 'error', message: 'UCP Datenbank nicht erreichbar' })
        }

        // Check Game Database
        try {
          const gameDb = await getGameDbPool()
          if (!gameDb) {
            results.push({ check: 'gameDatabase', status: 'error', message: 'Game Datenbank nicht konfiguriert' })
          } else {
            // Auto-detect framework by checking which table exists
            let framework = 'unknown'
            let playerCount = 0
            
            // Try QBCore first (players table)
            try {
              const [qbRows] = await gameDb.query('SELECT COUNT(*) as count FROM players')
              playerCount = (qbRows as any[])[0]?.count || 0
              framework = 'QBCore'
            } catch {
              // Try ESX (users table)
              try {
                const [esxRows] = await gameDb.query('SELECT COUNT(*) as count FROM users')
                playerCount = (esxRows as any[])[0]?.count || 0
                framework = 'ESX'
              } catch {
                // Neither table exists
                framework = 'unknown'
              }
            }
            
            if (framework !== 'unknown') {
              results.push({ check: 'gameDatabase', status: 'success', message: `Game Datenbank verbunden - ${framework} (${playerCount} Spieler)` })
            } else {
              results.push({ check: 'gameDatabase', status: 'warning', message: 'Game Datenbank verbunden, aber kein Framework erkannt (keine users/players Tabelle)' })
            }
          }
        } catch (error) {
          results.push({ check: 'gameDatabase', status: 'error', message: `Game Datenbank Fehler: ${error instanceof Error ? error.message : 'Unbekannt'}` })
        }

        // Check Discord OAuth
        const discordClientId = await prisma.systemSetting.findUnique({ where: { key: 'discordClientId' } })
        const discordClientSecret = await prisma.systemSetting.findUnique({ where: { key: 'discordClientSecret' } })
        if (discordClientId?.value && discordClientSecret?.value) {
          results.push({ check: 'discordOAuth', status: 'success', message: 'Discord OAuth konfiguriert' })
        } else {
          results.push({ check: 'discordOAuth', status: 'error', message: 'Discord OAuth nicht konfiguriert' })
        }

        // Check Webhook
        const webhookUrl = await prisma.systemSetting.findUnique({ where: { key: 'discordWebhookUrl' } })
        if (webhookUrl?.value) {
          results.push({ check: 'webhook', status: 'success', message: 'Discord Webhook konfiguriert' })
        } else {
          results.push({ check: 'webhook', status: 'warning', message: 'Discord Webhook nicht konfiguriert (optional)' })
        }

        // Check API Key
        const apiKey = await prisma.systemSetting.findUnique({ where: { key: 'ucpApiKey' } })
        if (apiKey?.value) {
          results.push({ check: 'apiKey', status: 'success', message: 'UCP API Key vorhanden' })
        } else {
          results.push({ check: 'apiKey', status: 'warning', message: 'UCP API Key nicht gesetzt' })
        }

        break

      case 'gameDatabase':
        // Test specific game database connection
        try {
          const gameDb = await getGameDbPool()
          if (!gameDb) {
            results.push({ check: 'connection', status: 'error', message: 'Game Datenbank nicht konfiguriert' })
            break
          }
          
          await gameDb.query('SELECT 1')
          
          // Detect framework
          let framework = 'unknown'
          try {
            await gameDb.query('SELECT 1 FROM users LIMIT 1')
            framework = 'ESX'
          } catch {
            try {
              await gameDb.query('SELECT 1 FROM players LIMIT 1')
              framework = 'QBCore'
            } catch {
              framework = 'unknown'
            }
          }
          
          results.push({ check: 'connection', status: 'success', message: `Verbindung erfolgreich (${framework} erkannt)` })
        } catch (error) {
          results.push({ check: 'connection', status: 'error', message: error instanceof Error ? error.message : 'Verbindung fehlgeschlagen' })
        }
        break

      case 'discord':
        // Validate Discord credentials format
        if (config?.clientId && /^\d{17,19}$/.test(config.clientId)) {
          results.push({ check: 'clientId', status: 'success', message: 'Client ID Format korrekt' })
        } else {
          results.push({ check: 'clientId', status: 'error', message: 'Client ID Format ungültig (17-19 Ziffern)' })
        }
        
        if (config?.clientSecret && config.clientSecret.length >= 20) {
          results.push({ check: 'clientSecret', status: 'success', message: 'Client Secret Format korrekt' })
        } else {
          results.push({ check: 'clientSecret', status: 'error', message: 'Client Secret zu kurz' })
        }
        break

      case 'webhook':
        if (config?.webhookUrl) {
          try {
            // Test webhook by sending a test message
            const response = await fetch(config.webhookUrl, {
              method: 'POST',
              headers: { 'Content-Type': 'application/json' },
              body: JSON.stringify({
                embeds: [{
                  title: 'SKG UCP - Webhook Test',
                  description: 'Dieser Webhook funktioniert korrekt!',
                  color: 0x3B82F6,
                  timestamp: new Date().toISOString(),
                }]
              })
            })
            
            if (response.ok) {
              results.push({ check: 'webhook', status: 'success', message: 'Webhook Test erfolgreich gesendet' })
            } else {
              results.push({ check: 'webhook', status: 'error', message: `Webhook Fehler: ${response.status}` })
            }
          } catch (error) {
            results.push({ check: 'webhook', status: 'error', message: 'Webhook nicht erreichbar' })
          }
        }
        break
    }

    return NextResponse.json({ results })
  } catch (error) {
    console.error('[Settings] Validation error:', error)
    return NextResponse.json({ error: 'Validation failed' }, { status: 500 })
  }
}