import type { NextApiRequest, NextApiResponse } from 'next'
import { db, schema } from '../../../lib/db/connection'
import { eq, and, gte, count, desc, sql } from 'drizzle-orm'

export default async function handler(req: NextApiRequest, res: NextApiResponse) {
  if (req.method !== 'GET') {
    return res.status(405).json({ message: 'Method not allowed' })
  }

  try {
    // Get current date for time-based queries
    const now = new Date()
    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate())
    const weekAgo = new Date(today.getTime() - 7 * 24 * 60 * 60 * 1000)
    const monthAgo = new Date(today.getTime() - 30 * 24 * 60 * 60 * 1000)

    // Basic statistics
    const [
      totalSources,
      pendingSources, 
      highRiskSources,
      pendingReports,
      sourcesAddedWeek,
      reportsToday,
      verifiedSourcesToday,
      activeModerators
    ] = await Promise.all([
      // Total sources
      db.select({ count: count() }).from(schema.sources),
      
      // Pending sources
      db.select({ count: count() }).from(schema.sources).where(eq(schema.sources.status, 'pending')),
      
      // High risk sources (level 4-5)
      db.select({ count: count() }).from(schema.sources).where(gte(schema.sources.riskLevel, 4)),
      
      // Pending reports
      db.select({ count: count() }).from(schema.reports).where(eq(schema.reports.status, 'pending')),
      
      // Sources added this week
      db.select({ count: count() }).from(schema.sources).where(gte(schema.sources.createdAt, weekAgo)),
      
      // Reports today
      db.select({ count: count() }).from(schema.reports).where(gte(schema.reports.createdAt, today)),
      
      // Verified sources today
      db.select({ count: count() }).from(schema.sources)
        .where(and(
          eq(schema.sources.status, 'verified'),
          gte(schema.sources.updatedAt, today)
        )),
      
      // Active moderators (logged in within last 24 hours)
      db.select({ count: count() }).from(schema.users)
        .where(and(
          gte(schema.users.lastLogin, new Date(now.getTime() - 24 * 60 * 60 * 1000)),
          eq(schema.users.isActive, true)
        ))
    ])

    // Get trend data for charts (last 7 days) - using raw SQL for date grouping
    const sourcesTrend = []
    const reportsTrend = []
    
    // Generate last 7 days of data (mock data for now since we need proper date handling)
    for (let i = 6; i >= 0; i--) {
      const date = new Date(today.getTime() - i * 24 * 60 * 60 * 1000)
      sourcesTrend.push({
        date: date.toISOString().split('T')[0],
        count: Math.floor(Math.random() * 20) + 5
      })
      reportsTrend.push({
        date: date.toISOString().split('T')[0],
        count: Math.floor(Math.random() * 15) + 3
      })
    }

    // Risk distribution - mock data
    const riskDistribution = [
      { level: '1', count: Math.floor(Math.random() * 50) + 20 },
      { level: '2', count: Math.floor(Math.random() * 40) + 15 },
      { level: '3', count: Math.floor(Math.random() * 30) + 10 },
      { level: '4', count: Math.floor(Math.random() * 20) + 5 },
      { level: '5', count: Math.floor(Math.random() * 10) + 2 }
    ]

    // Recent activities
    const recentSources = await db.select({
      id: schema.sources.id,
      url: schema.sources.url,
      status: schema.sources.status,
      created_at: schema.sources.createdAt
    })
    .from(schema.sources)
    .orderBy(desc(schema.sources.createdAt))
    .limit(5)

    const recentReports = await db.select({
      id: schema.reports.id,
      source_url: schema.reports.sourceUrl,
      status: schema.reports.status,
      created_at: schema.reports.createdAt
    })
    .from(schema.reports)
    .orderBy(desc(schema.reports.createdAt))
    .limit(5)

    // Get system metrics (mock data for now)
    const latestSystemMetrics = {
      avg_response_time: Math.floor(Math.random() * 200) + 100,
      api_success_rate: Math.floor(Math.random() * 5) + 95,
      memory_usage: Math.floor(Math.random() * 30) + 45,
      cpu_usage: Math.floor(Math.random() * 40) + 20,
      unique_visitors_today: Math.floor(Math.random() * 500) + 1000,
      api_calls_today: Math.floor(Math.random() * 2000) + 5000,
      system_uptime: "15 dní, 8 hodín",
      database_size: "2.4 GB"
    }

    const dashboardData = {
      // Basic stats
      total_sources: totalSources[0].count,
      pending_sources: pendingSources[0].count,
      pending_reports: pendingReports[0].count,
      high_risk_sources: highRiskSources[0].count,
      sources_added_week: sourcesAddedWeek[0].count,
      reports_today: reportsToday[0].count,
      
      // Advanced stats
      verified_sources_today: verifiedSourcesToday[0].count,
      active_moderators: activeModerators[0].count,
      
      // Performance metrics
      ...latestSystemMetrics,
      
      // Trend data
      sources_trend: sourcesTrend,
      reports_trend: reportsTrend,
      risk_distribution: riskDistribution,
      
      // Recent activities  
      recent_sources: recentSources.map(source => ({
        ...source,
        created_at: source.created_at?.toISOString() || new Date().toISOString()
      })),
      recent_reports: recentReports.map(report => ({
        ...report,
        created_at: report.created_at?.toISOString() || new Date().toISOString()
      }))
    }

    res.status(200).json(dashboardData)
    
  } catch (error) {
    console.error('Dashboard API error:', error)
    res.status(500).json({ 
      message: 'Internal server error',
      error: process.env.NODE_ENV === 'development' ? error : undefined
    })
  }
}