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

// GET - Load all settings for superadmin
export async function GET() {
  try {
    const user = await getCurrentUser()
    if (!user || user.role !== 'SUPERADMIN') {
      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
    }

    // Load all system settings
    const systemSettings = await prisma.systemSetting.findMany()
    
    // Load game database config
    const gameDbConfig = await prisma.gameDatabaseConfig.findFirst()

    // Convert settings array to object
    const settings: Record<string, string> = {}
    for (const setting of systemSettings) {
      // Mask sensitive values
      if (setting.isEncrypted || setting.key.toLowerCase().includes('secret') || setting.key.toLowerCase().includes('password')) {
        settings[setting.key] = setting.value ? '••••••••' : ''
      } else {
        settings[setting.key] = setting.value
      }
    }

    // Add game DB config (mask password)
    if (gameDbConfig) {
      settings.gameDbHost = gameDbConfig.host
      settings.gameDbPort = gameDbConfig.port.toString()
      settings.gameDbName = gameDbConfig.database
      settings.gameDbUser = gameDbConfig.user
      settings.gameDbPassword = gameDbConfig.password ? '••••••••' : ''
      // Convert enum to lowercase for UI
      settings.gameDbFramework = gameDbConfig.framework.toLowerCase()
    }

    // Add UCP API key for superadmin
    const apiKeySetting = await prisma.systemSetting.findUnique({
      where: { key: 'ucpApiKey' }
    })
    settings.ucpApiKey = apiKeySetting?.value || ''

    // Load branding settings from BrandingSetting table
    const branding = await prisma.brandingSetting.findFirst()
    if (branding) {
      settings.primaryColor = branding.primaryColor || '#3B82F6'
      settings.secondaryColor = branding.secondaryColor || '#1E40AF'
      settings.logoUrl = branding.logoUrl || ''
      settings.backgroundUrl = branding.backgroundUrl || ''
      settings.panelName = branding.panelName || 'SKG UCP'
      settings.themeStyle = branding.themeStyle || 'dark'
    }

    return NextResponse.json({ settings })
  } catch (error) {
    console.error('[Settings] Error loading settings:', error)
    return NextResponse.json({ error: 'Failed to load settings' }, { status: 500 })
  }
}

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

    const { key, value, category } = await request.json()

    if (!key) {
      return NextResponse.json({ error: 'Key is required' }, { status: 400 })
    }

    // Special handling for game database config
    if (key.startsWith('gameDb')) {
      const gameDbConfig = await prisma.gameDatabaseConfig.findFirst()
      if (gameDbConfig) {
        const fieldMap: Record<string, string> = {
          gameDbHost: 'host',
          gameDbPort: 'port',
          gameDbName: 'database',
          gameDbUser: 'user',
          gameDbPassword: 'password',
          gameDbFramework: 'framework',
        }
        const field = fieldMap[key]
        if (field) {
          let updateValue: string | number = value
          if (key === 'gameDbPort') {
            updateValue = parseInt(value)
          } else if (key === 'gameDbFramework') {
            // Convert lowercase to uppercase for enum
            updateValue = value === 'qbcore' ? 'QBCORE' : value === 'esx' ? 'ESX' : 'ESX'
          }
          await prisma.gameDatabaseConfig.update({
            where: { id: gameDbConfig.id },
            data: { [field]: updateValue }
          })
        }
      }
    } else {
      // Update or create system setting
      await prisma.systemSetting.upsert({
        where: { key },
        update: { 
          value,
          category: category || 'general',
        },
        create: {
          key,
          value,
          category: category || 'general',
          isEncrypted: key.toLowerCase().includes('secret') || key.toLowerCase().includes('password'),
        }
      })
      
      // If it's a branding setting, also update the BrandingSetting table
      if (category === 'branding' || ['primaryColor', 'secondaryColor', 'logoUrl', 'backgroundUrl', 'panelName', 'themeStyle'].includes(key)) {
        const brandingFieldMap: Record<string, string> = {
          primaryColor: 'primaryColor',
          secondaryColor: 'secondaryColor',
          logoUrl: 'logoUrl',
          backgroundUrl: 'backgroundUrl',
          panelName: 'panelName',
          themeStyle: 'themeStyle',
        }
        
        const brandingField = brandingFieldMap[key]
        if (brandingField) {
          // Get or create branding settings
          let branding = await prisma.brandingSetting.findFirst()
          
          if (branding) {
            await prisma.brandingSetting.update({
              where: { id: branding.id },
              data: { [brandingField]: value }
            })
          } else {
            await prisma.brandingSetting.create({
              data: {
                panelName: key === 'panelName' ? value : 'SKG UCP',
                primaryColor: key === 'primaryColor' ? value : '#3B82F6',
                secondaryColor: key === 'secondaryColor' ? value : '#1E40AF',
                logoUrl: key === 'logoUrl' ? value : null,
                backgroundUrl: key === 'backgroundUrl' ? value : null,
                themeStyle: key === 'themeStyle' ? value : 'dark',
              }
            })
          }
        }
      }
    }

    return NextResponse.json({ success: true })
  } catch (error) {
    console.error('[Settings] Error updating setting:', error)
    return NextResponse.json({ error: 'Failed to update setting' }, { status: 500 })
  }
}