import { Request, Response } from 'express';
import jwt = require('jsonwebtoken');
import { prisma } from '../config/database';

const JWT_SECRET = process.env['JWT_SECRET'] || 'dev-secret';
const SUPER_ADMIN_EMAIL = process.env['SUPER_ADMIN_EMAIL'] || 'superadmin@visity.com';
const SUPER_ADMIN_PASSWORD = process.env['SUPER_ADMIN_PASSWORD'] || 'SuperAdmin@123';

export async function superAdminLogin(req: Request, res: Response): Promise<void> {
  try {
    const { email, password } = req.body;

    if (!email || !password) {
      res.status(400).json({ error: 'Email and password are required' });
      return;
    }

    if (email !== SUPER_ADMIN_EMAIL || password !== SUPER_ADMIN_PASSWORD) {
      res.status(401).json({ error: 'Invalid credentials' });
      return;
    }

    const token = jwt.sign(
      { role: 'super_admin', email },
      JWT_SECRET,
      { expiresIn: '7d' }
    );

    res.json({ token, email });
  } catch (error) {
    console.error('superAdminLogin error:', error);
    res.status(500).json({ error: 'Login failed' });
  }
}

export async function listAllowedEmails(_req: Request, res: Response): Promise<void> {
  try {
    const emails = await prisma.allowedEmail.findMany({
      orderBy: { createdAt: 'desc' },
    });
    res.json(emails);
  } catch (error) {
    console.error('listAllowedEmails error:', error);
    res.status(500).json({ error: 'Failed to list allowed emails' });
  }
}

export async function addAllowedEmail(req: Request, res: Response): Promise<void> {
  try {
    const { email, note } = req.body;
    if (!email || typeof email !== 'string') {
      res.status(400).json({ error: 'Valid email is required' });
      return;
    }
    const normalized = email.trim().toLowerCase();

    const existing = await prisma.allowedEmail.findUnique({ where: { email: normalized } });
    if (existing) {
      res.status(409).json({ error: 'Email already in allowlist' });
      return;
    }

    const created = await prisma.allowedEmail.create({
      data: { email: normalized, note: note || null },
    });
    res.status(201).json(created);
  } catch (error) {
    console.error('addAllowedEmail error:', error);
    res.status(500).json({ error: 'Failed to add allowed email' });
  }
}

export async function updateAllowedEmail(req: Request, res: Response): Promise<void> {
  try {
    const { id } = req.params;
    const { isActive, note } = req.body;
    const updated = await prisma.allowedEmail.update({
      where: { id },
      data: {
        ...(typeof isActive === 'boolean' ? { isActive } : {}),
        ...(typeof note === 'string' ? { note } : {}),
      },
    });
    res.json(updated);
  } catch (error) {
    console.error('updateAllowedEmail error:', error);
    res.status(500).json({ error: 'Failed to update allowed email' });
  }
}

export async function deleteAllowedEmail(req: Request, res: Response): Promise<void> {
  try {
    const { id } = req.params;
    await prisma.allowedEmail.delete({ where: { id } });
    res.json({ success: true });
  } catch (error) {
    console.error('deleteAllowedEmail error:', error);
    res.status(500).json({ error: 'Failed to delete allowed email' });
  }
}

export async function listOrganizersWithEvents(_req: Request, res: Response): Promise<void> {
  try {
    const organizers = await prisma.organizer.findMany({
      orderBy: { createdAt: 'desc' },
      include: {
        plan: true,
        events: {
          orderBy: { createdAt: 'desc' },
          include: {
            _count: { select: { attendees: true, scanLogs: true, checkpoints: true } },
          },
        },
        _count: {
          select: { events: true },
        },
      },
    });
    res.json(organizers);
  } catch (error) {
    console.error('listOrganizersWithEvents error:', error);
    res.status(500).json({ error: 'Failed to list organizers' });
  }
}

export async function getOrganizerDetails(req: Request, res: Response): Promise<void> {
  try {
    const { id } = req.params;
    const organizer = await prisma.organizer.findUnique({
      where: { id },
      include: {
        plan: true,
        events: {
          orderBy: { createdAt: 'desc' },
          include: {
            _count: { select: { attendees: true, scanLogs: true, checkpoints: true, categories: true } },
            attendees: {
              take: 100,
              orderBy: { createdAt: 'desc' },
              select: {
                id: true, name: true, email: true, mobile: true, status: true, attendance: true, createdAt: true,
              },
            },
          },
        },
      },
    });
    if (!organizer) {
      res.status(404).json({ error: 'Organizer not found' });
      return;
    }
    res.json(organizer);
  } catch (error) {
    console.error('getOrganizerDetails error:', error);
    res.status(500).json({ error: 'Failed to fetch organizer' });
  }
}

export async function getOverviewStats(_req: Request, res: Response): Promise<void> {
  try {
    const [organizers, events, attendees, allowedEmails] = await Promise.all([
      prisma.organizer.count(),
      prisma.event.count(),
      prisma.attendee.count(),
      prisma.allowedEmail.count({ where: { isActive: true } }),
    ]);
    res.json({ organizers, events, attendees, allowedEmails });
  } catch (error) {
    console.error('getOverviewStats error:', error);
    res.status(500).json({ error: 'Failed to fetch stats' });
  }
}