import { NextResponse } from 'next/server';
import { prisma } from '@/lib/db';
import { getCurrentAdmin, AdminPermission, hasPermission } from '@/lib/admin-auth';

export const runtime = 'nodejs';

export async function GET(request: Request) {
  try {
    const admin = await getCurrentAdmin(request as any);
    if (!admin || !hasPermission(admin, AdminPermission.SYSTEM_HEALTH)) {
      return NextResponse.json(
        { error: 'Unauthorized' },
        { status: 401 }
      );
    }

    const startTime = Date.now();

    // Database health check
    let dbHealth = 'healthy';
    let dbResponseTime = 0;
    try {
      const dbStart = Date.now();
      await prisma.$queryRaw`SELECT 1`;
      dbResponseTime = Date.now() - dbStart;
    } catch (error) {
      dbHealth = 'unhealthy';
      console.error('Database health check failed:', error);
    }

    // System metrics
    const systemMetrics = {
      database: {
        status: dbHealth,
        responseTime: dbResponseTime,
        connections: {
          // This would require additional monitoring setup in production
          active: 'N/A',
          max: 'N/A'
        }
      },
      application: {
        status: 'healthy',
        uptime: process.uptime(),
        memory: {
          used: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
          total: Math.round(process.memoryUsage().heapTotal / 1024 / 1024),
          rss: Math.round(process.memoryUsage().rss / 1024 / 1024)
        },
        nodeVersion: process.version,
        platform: process.platform,
        arch: process.arch
      }
    };

    // Database statistics
    const dbStats = {
      tables: {
        users: await prisma.user.count(),
        conversations: await prisma.chatConversation.count(),
        messages: await prisma.chatMessage.count(),
        prayerRequests: await prisma.prayerRequest.count(),
        prayers: await prisma.prayer.count(),
        bookmarks: await prisma.bookmark.count(),
        notes: await prisma.note.count()
      },
      recentActivity: {
        last24h: {
          newUsers: await prisma.user.count({
            where: {
              createdAt: {
                gte: new Date(Date.now() - 24 * 60 * 60 * 1000)
              }
            }
          }),
          newConversations: await prisma.chatConversation.count({
            where: {
              createdAt: {
                gte: new Date(Date.now() - 24 * 60 * 60 * 1000)
              }
            }
          }),
          newPrayers: await prisma.prayer.count({
            where: {
              createdAt: {
                gte: new Date(Date.now() - 24 * 60 * 60 * 1000)
              }
            }
          })
        }
      }
    };

    // Security status
    const securityStatus = {
      adminUsers: await prisma.user.count({
        where: { role: 'admin' }
      }),
      suspendedUsers: await prisma.user.count({
        where: { role: 'suspended' }
      }),
      inactivePrayerRequests: await prisma.prayerRequest.count({
        where: { isActive: false }
      }),
      inactiveConversations: await prisma.chatConversation.count({
        where: { isActive: false }
      })
    };

    const totalResponseTime = Date.now() - startTime;

    return NextResponse.json({
      timestamp: new Date().toISOString(),
      status: dbHealth === 'healthy' ? 'healthy' : 'degraded',
      responseTime: totalResponseTime,
      metrics: systemMetrics,
      database: dbStats,
      security: securityStatus
    });

  } catch (error) {
    console.error('System health check error:', error);
    return NextResponse.json(
      {
        error: 'System health check failed',
        status: 'unhealthy',
        timestamp: new Date().toISOString()
      },
      { status: 500 }
    );
  }
}