const Event = require('../Models/Event');
const EventParticipationLog = require('../Models/EventParticipationLog');
const Certificate = require('../Models/Certificate');
const User = require('../Models/User');
const axios = require('axios');
const { storageService } = require('../Services/storageService');

// Certificate Generator API URL (update based on your deployment)
const CERTIFICATE_API_URL = process.env.CERTIFICATE_API_URL || 'http://localhost:8000';

/**
 * Update event certificate settings
 * Host can enable/disable certificates and configure settings
 */
async function updateCertificateSettings(req, res) {
  try {
    const { eventId } = req.params;
    const userId = req.user.id;
    const {
      certificateEnabled,
      certificateType,
      awardText,
      leftSignatory,
      rightSignatory,
      selectedTemplateId, // Template ID assigned by Admin/Verifier
      previewConfig,
    } = req.body;

    // Find event and verify host permission
    const event = await Event.findById(eventId);
    if (!event) {
      return res.status(404).json({ error: 'Event not found.' });
    }

    const isHost = event.hostUserId.toString() === userId;
    if (!isHost) {
      return res.status(403).json({
        error: 'Only the event host can update certificate settings.',
      });
    }

    // Update certificate settings
    if (certificateEnabled !== undefined) {
      event.features = event.features || {};
      event.features.certificateEnabled = certificateEnabled;
    }

    if (!event.certificateSettings) {
      event.certificateSettings = {};
    }

    if (certificateType) {
      event.certificateSettings.certificateType = certificateType;
    }
    if (awardText !== undefined) {
      event.certificateSettings.awardText = awardText;
    }
    if (leftSignatory) {
      event.certificateSettings.leftSignatory = leftSignatory;
    }
    if (rightSignatory) {
      event.certificateSettings.rightSignatory = rightSignatory;
    }
    if (selectedTemplateId) {
      event.certificateSettings.selectedTemplateId = selectedTemplateId;
    }
    if (previewConfig !== undefined) {
      event.certificateSettings.previewConfig = previewConfig;
    }

    await event.save();

    res.json({
      message: 'Certificate settings updated successfully.',
      certificateEnabled: event.features.certificateEnabled,
      certificateSettings: event.certificateSettings,
    });
  } catch (err) {
    console.error('Error updating certificate settings:', err);
    res.status(500).json({ error: 'Server error updating certificate settings.' });
  }
}

/**
 * Upload certificate assets (template, logos, signatures)
 * Files are uploaded to cloud storage
 */
async function uploadCertificateAssets(req, res) {
  try {
    const { eventId } = req.params;
    const userId = req.user.id;
    const { assetType } = req.body; // 'template', 'orgLogo', 'leftSignature', 'rightSignature'

    // Verify event and host permission
    const event = await Event.findById(eventId);
    if (!event) {
      return res.status(404).json({ error: 'Event not found.' });
    }

    const isHost = event.hostUserId.toString() === userId;
    if (!isHost) {
      return res.status(403).json({
        error: 'Only the event host can upload certificate assets.',
      });
    }

    // Check if certificates are enabled
    if (!event.features?.certificateEnabled) {
      return res.status(400).json({
        error: 'Certificates are not enabled for this event.',
      });
    }

    // Check if files were uploaded
    if (!req.files || (Array.isArray(req.files) && req.files.length === 0)) {
      return res.status(400).json({ error: 'No files uploaded.' });
    }

    // DISALLOW hosts from uploading templates (requested: Centralized Template Management)
    if (assetType === 'template' && req.user.role !== 'admin' && req.user.role !== 'platformAdmin') {
      return res.status(403).json({ 
        error: 'Only administrators can upload custom certificate templates. Please select from the predefined templates.' 
      });
    }

    const uploadedFiles = [];

    // Initialize certificate assets structure
    if (!event.certificateSettings) {
      event.certificateSettings = {};
    }
    if (!event.certificateSettings.uploadedAssets) {
      event.certificateSettings.uploadedAssets = {};
    }

    // Upload files to cloud storage
    for (const file of req.files) {
      try {
        // Normalize assetType from frontend
        let effectiveAssetType = assetType;
        if (assetType === 'logo') {
          effectiveAssetType = req.body.logo_type === 'right' ? 'rightLogo' : 'orgLogo';
        } else if (assetType === 'signature') {
          effectiveAssetType = req.body.signature_type === 'right' ? 'rightSignature' : 'leftSignature';
        }

        switch (effectiveAssetType) {
          case 'template':
            const templateType = req.body.template_type || 'participation';
            uploadResult = await storageService.uploadCertificateTemplate(
              file.buffer,
              file.originalname,
              eventId,
              templateType,
              file.mimetype
            );
            
            // Store template info
            event.certificateSettings.uploadedAssets.templateUrl = uploadResult.url;
            event.certificateSettings.uploadedAssets.templatePath = uploadResult.path;
            event.certificateSettings.certificateType = templateType;
            break;

          case 'orgLogo':
          case 'leftLogo':
            uploadResult = await storageService.uploadCertificateLogo(
              file.buffer,
              file.originalname,
              eventId,
              'left',
              file.mimetype
            );
            
            // Store org logo info
            event.certificateSettings.uploadedAssets.organizationLogo = uploadResult.url;
            event.certificateSettings.uploadedAssets.orgLogoPath = uploadResult.path;
            break;

          case 'rightLogo':
            uploadResult = await storageService.uploadCertificateLogo(
              file.buffer,
              file.originalname,
              eventId,
              'right',
              file.mimetype
            );
            
            // Store right logo info
            event.certificateSettings.uploadedAssets.rightLogoUrl = uploadResult.url;
            event.certificateSettings.uploadedAssets.rightLogoPath = uploadResult.path;
            break;

          case 'leftSignature':
            uploadResult = await storageService.uploadCertificateSignature(
              file.buffer,
              file.originalname,
              eventId,
              'left',
              file.mimetype
            );
            
            // Store left signature info
            if (!event.certificateSettings.leftSignatory) {
              event.certificateSettings.leftSignatory = {};
            }
            event.certificateSettings.leftSignatory.signatureUrl = uploadResult.url;
            event.certificateSettings.leftSignatory.signaturePath = uploadResult.path;
            break;

          case 'rightSignature':
            uploadResult = await storageService.uploadCertificateSignature(
              file.buffer,
              file.originalname,
              eventId,
              'right',
              file.mimetype
            );
            
            // Store right signature info
            if (!event.certificateSettings.rightSignatory) {
              event.certificateSettings.rightSignatory = {};
            }
            event.certificateSettings.rightSignatory.signatureUrl = uploadResult.url;
            event.certificateSettings.rightSignatory.signaturePath = uploadResult.path;
            break;

          default:
            console.warn(`[Cert] Unknown effective asset type: ${effectiveAssetType}`);
            continue;
        }

        uploadedFiles.push({
          originalName: file.originalname,
          assetType,
          url: uploadResult.url,
          path: uploadResult.path,
        });

      } catch (uploadError) {
        console.error('Error uploading asset:', uploadError.message);
        throw new Error(`Failed to upload ${file.originalname}: ${uploadError.message}`);
      }
    }

    // Save event with updated assets
    await event.save();

    res.json({
      message: 'Assets uploaded successfully to cloud storage.',
      uploadedFiles,
      certificateSettings: event.certificateSettings,
    });
  } catch (err) {
    console.error('Error uploading certificate assets:', err);
    res.status(500).json({ error: err.message || 'Server error uploading assets.' });
  }
}

/**
 * Generate certificates for all attended participants
 * This is triggered by the host after the event
 */
async function generateCertificates(req, res) {
  try {
    const { eventId } = req.params;
    const userId = req.user.id;

    // Verify event and host permission
    const event = await Event.findById(eventId);
    if (!event) {
      return res.status(404).json({ error: 'Event not found.' });
    }

    const isHost = event.hostUserId.toString() === userId;
    if (!isHost) {
      return res.status(403).json({
        error: 'Only the event host can generate certificates.',
      });
    }

    // Check if certificates are enabled
    if (!event.features?.certificateEnabled) {
      return res.status(400).json({
        error: 'Certificates are not enabled for this event.',
      });
    }

    // Check if certificate setup is approved
    if (event.certificateSettings?.verificationStatus !== 'approved') {
      return res.status(400).json({
        error: 'Certificate setup must be approved by a verifier before generation.',
        currentStatus: event.certificateSettings?.verificationStatus || 'not_configured',
      });
    }


    // Check if required assets are uploaded - using uploadedAssets structure
    const uploadedAssets = event.certificateSettings?.uploadedAssets || {};
    const settings = event.certificateSettings || {};
    
    // Template can come from upload OR predefined selection
    const PREDEFINED_TEMPLATES = {
      'classic-blue': 'https://storage.campverse.com/templates/classic-blue.png',
      'modern-purple': 'https://storage.campverse.com/templates/modern-purple.png',
      'elegant-gold': 'https://storage.campverse.com/templates/elegant-gold.png',
      'minimal-dark': 'https://storage.campverse.com/templates/minimal-dark.png',
    };
    const templateUrl = uploadedAssets.templateUrl || PREDEFINED_TEMPLATES[settings.selectedTemplateId];
    
    if (!templateUrl || !uploadedAssets.organizationLogo || 
        !uploadedAssets.leftSignature || !uploadedAssets.rightSignature) {
      return res.status(400).json({
        error: 'All required assets must be uploaded (template/selection, organization logo, and both signatures).',
        uploaded: {
          template: !!templateUrl,
          orgLogo: !!uploadedAssets.organizationLogo,
          leftSignature: !!uploadedAssets.leftSignature,
          rightSignature: !!uploadedAssets.rightSignature,
        },
      });
    }

    // Get all attended participants
    const attendedLogs = await EventParticipationLog.find({
      eventId,
      status: 'attended',
    }).populate('userId', 'name email');

    if (attendedLogs.length === 0) {
      return res.status(400).json({
        error: 'No attended participants found for this event.',
      });
    }

    // Prepare batch generation request - use the corrected variables
    const certificateSettings = event.certificateSettings;
    
    const batchRequest = {
      eventId: eventId,
      eventTitle: event.title,
      templateUrl: templateUrl, // Already resolved above with fallback
      orgLogoUrl: uploadedAssets.organizationLogo,
      leftSignature: {
        url: uploadedAssets.leftSignature,
        name: certificateSettings.leftSignatory?.name || '',
        title: certificateSettings.leftSignatory?.title || '',
      },
      rightSignature: {
        url: uploadedAssets.rightSignature,
        name: certificateSettings.rightSignatory?.name || '',
        title: certificateSettings.rightSignatory?.title || '',
      },
      awardText: certificateSettings.awardText || 'For successfully participating in',
      certificateType: certificateSettings.certificateType || 'participation',
      participants: attendedLogs.map((log) => ({
        userId: log.userId._id.toString(),
        name: log.userId.name,
        email: log.userId.email,
      })),
    };

    // Call ML batch generation endpoint - NOT storing PDFs, just validating generation
    // Certificates will be rendered on-demand when requested
    let generateResponse;
    try {
      // Send a test generation request to validate assets
      generateResponse = await axios.post(
        `${CERTIFICATE_API_URL}/batch-validate`, 
        batchRequest,
        { timeout: 30000 } // 30 second timeout just for validation
      );
    } catch (apiError) {
      console.error('Error validating certificate generation:', apiError.message);
      return res.status(500).json({
        error: 'Failed to validate certificate generation from ML service.',
        details: apiError.message,
      });
    }

    // Create certificate records with metadata only (NO URLs stored)
    // Certificates will be generated on-demand when users request them
    const certificateRecords = [];
    for (const log of attendedLogs) {
      // Check if certificate record already exists
      let certificate = await Certificate.findOne({
        userId: log.userId._id,
        eventId: eventId,
      });

      if (!certificate) {
        certificate = await Certificate.create({
          userId: log.userId._id,
          eventId: eventId,
          type: certificateSettings.certificateType === 'achievement' ? 'winner' : 'participant', // REQUIRED field
          status: 'ready', // Status indicates certificate is ready to be rendered
          issuedAt: new Date(),
          // NO certificateUrl - certificates are rendered on-demand
        });
      } else {
        // Update existing certificate
        certificate.status = 'ready';
        certificate.updatedAt = new Date();
        await certificate.save();
      }

      certificateRecords.push({
        userId: log.userId._id,
        userName: log.userId.name,
        email: log.userId.email,
        status: 'ready',
        renderUrl: `/api/certificate-management/events/${eventId}/render/${log.userId._id}`, // Correct path
      });
    }

    // Update event with generation timestamp
    event.certificateSettings.lastGeneratedAt = new Date();
    event.certificateSettings.certificatesReady = true;
    await event.save();

    res.json({
      message: `Successfully prepared ${certificateRecords.length} certificate(s) for on-demand rendering.`,
      note: 'Certificates are not stored. They will be generated when users download them.',
      certificates: certificateRecords,
      totalGenerated: certificateRecords.length,
      totalParticipants: attendedLogs.length,
    });
  } catch (err) {
    console.error('Error generating certificates:', err);
    res.status(500).json({
      error: 'Server error generating certificates.',
      details: err.message,
    });
  }
}

/**
 * Get certificate status for an event
 * Returns list of participants and their certificate status
 */
async function getCertificateStatus(req, res) {
  try {
    const { eventId } = req.params;
    const userId = req.user.id;

    // Verify event and host permission
    const event = await Event.findById(eventId);
    if (!event) {
      return res.status(404).json({ error: 'Event not found.' });
    }

    const isHost = event.hostUserId.toString() === userId;
    const isCoHost = event.coHosts?.some((id) => id.toString() === userId);

    if (!isHost && !isCoHost) {
      return res.status(403).json({
        error: 'Only host or co-host can view certificate status.',
      });
    }

    // Get all attended participants
    const attendedLogs = await EventParticipationLog.find({
      eventId,
      status: 'attended',
    }).populate('userId', 'name email');

    // Get certificate records
    const certificates = await Certificate.find({ eventId });
    const certificateMap = {};
    certificates.forEach((cert) => {
      certificateMap[cert.userId.toString()] = cert;
    });

    // Build status list
    const statusList = attendedLogs.map((log) => {
      const cert = certificateMap[log.userId._id.toString()];
      return {
        userId: log.userId._id,
        name: log.userId.name,
        email: log.userId.email,
        attendedAt: log.attendanceTimestamp,
        certificateGenerated: !!cert,
        certificateUrl: cert?.certificateUrl,
        certificateStatus: cert?.status,
        generatedAt: cert?.generatedAt,
      };
    });

    res.json({
      eventTitle: event.title,
      certificateEnabled: event.features?.certificateEnabled || false,
      totalAttended: attendedLogs.length,
      certificatesGenerated: certificates.length,
      participants: statusList,
    });
  } catch (err) {
    console.error('Error fetching certificate status:', err);
    res.status(500).json({ error: 'Server error fetching certificate status.' });
  }
}

/**
 * Get user's certificate for a specific event
 */
async function getUserCertificate(req, res) {
  try {
    const { eventId } = req.params;
    const userId = req.user.id;

    // Check if user attended the event
    const log = await EventParticipationLog.findOne({
      eventId,
      userId,
      status: 'attended',
    });

    if (!log) {
      return res.status(404).json({
        error: 'Certificate not available.',
        message: 'You must attend the event to receive a certificate.',
      });
    }

    // Find certificate
    const certificate = await Certificate.findOne({
      eventId,
      userId,
    }).populate('eventId', 'title date');

    if (!certificate) {
      return res.status(404).json({
        error: 'Certificate not generated yet.',
        message: 'The event host has not generated certificates yet.',
      });
    }

    res.json({
      certificate: {
        certificateId: certificate._id,
        eventTitle: certificate.eventId.title,
        eventDate: certificate.eventId.date,
        certificateUrl: certificate.certificateUrl,
        generatedAt: certificate.generatedAt,
        status: certificate.status,
      },
    });
  } catch (err) {
    console.error('Error fetching user certificate:', err);
    res.status(500).json({ error: 'Server error fetching certificate.' });
  }
}

/**
 * Regenerate certificates (if needed)
 */
async function regenerateCertificates(req, res) {
  try {
    const { eventId } = req.params;
    const userId = req.user.id;

    // Verify event and host permission
    const event = await Event.findById(eventId);
    if (!event) {
      return res.status(404).json({ error: 'Event not found.' });
    }

    const isHost = event.hostUserId.toString() === userId;
    if (!isHost) {
      return res.status(403).json({
        error: 'Only the event host can regenerate certificates.',
      });
    }

    // Delete existing certificates
    await Certificate.deleteMany({ eventId });

    // Regenerate
    return generateCertificates(req, res);
  } catch (err) {
    console.error('Error regenerating certificates:', err);
    res.status(500).json({ error: 'Server error regenerating certificates.' });
  }
}

/**
 * Bulk upload participant data via CSV for certificate generation
 */
async function bulkUploadParticipants(req, res) {
  try {
    const { eventId } = req.params;
    const userId = req.user.id;

    // Verify event and host permission
    const event = await Event.findById(eventId);
    if (!event) {
      return res.status(404).json({ error: 'Event not found.' });
    }

    const isHost = event.hostUserId.toString() === userId;
    if (!isHost) {
      return res.status(403).json({
        error: 'Only the event host can upload participant data.',
      });
    }

    // This endpoint expects a CSV file with participant data
    // The CSV should be parsed and used to update/verify participant records
    // Implementation depends on your CSV parsing library

    res.json({
      message: 'Bulk upload functionality - to be implemented with CSV parser.',
    });
  } catch (err) {
    console.error('Error in bulk upload:', err);
    res.status(500).json({ error: 'Server error in bulk upload.' });
  }
}

/**
 * Render certificate on-demand for a specific user
 * Generates the certificate in real-time and streams it to the response
 */
async function renderCertificate(req, res) {
  try {
    const { eventId, userId } = req.params;
    const requestingUserId = req.user.id;

    // Check if user is requesting their own certificate or is the host
    const event = await Event.findById(eventId);
    if (!event) {
      return res.status(404).json({ error: 'Event not found.' });
    }

    const isHost = event.hostUserId.toString() === requestingUserId;
    const isOwnCertificate = userId === requestingUserId;
    const isVerifier = req.user.roles.includes('verifier');
    const isAdmin = req.user.roles.includes('platformAdmin');

    if (!isHost && !isOwnCertificate && !isVerifier && !isAdmin) {
      return res.status(403).json({
        error: 'You can only access your own certificate or certificates from events you host.',
      });
    }

    // Check if certificate is ready
    const certificate = await Certificate.findOne({
      eventId,
      userId,
      status: 'ready',
    });

    if (!certificate) {
      return res.status(404).json({
        error: 'Certificate not available.',
        message: 'Certificate has not been generated yet or you did not attend this event.',
      });
    }

    // Get user details
    const user = await User.findById(userId);
    if (!user) {
      return res.status(404).json({ error: 'User not found.' });
    }

    // Get certificate settings
    const certificateSettings = event.certificateSettings;
    const uploadedAssets = certificateSettings?.uploadedAssets || {};
    
    // Template can come from upload OR predefined selection
    const PREDEFINED_TEMPLATES = {
      'classic-blue': 'https://storage.campverse.com/templates/classic-blue.png',
      'modern-purple': 'https://storage.campverse.com/templates/modern-purple.png',
      'elegant-gold': 'https://storage.campverse.com/templates/elegant-gold.png',
      'minimal-dark': 'https://storage.campverse.com/templates/minimal-dark.png',
    };
    const templateUrl = uploadedAssets.templateUrl || PREDEFINED_TEMPLATES[certificateSettings?.selectedTemplateId];
    
    if (!templateUrl) {
      return res.status(500).json({
        error: 'Certificate template not configured.',
      });
    }

    // Prepare single certificate generation request
    const renderRequest = {
      eventId: eventId,
      eventTitle: event.title,
      templateUrl: templateUrl,
      orgLogoUrl: uploadedAssets.organizationLogo,
      rightLogoUrl: uploadedAssets.rightLogoUrl || 'https://campverse.com/logo.png', // Default CampVerse logo
      leftSignature: {
        url: uploadedAssets.leftSignature,
        name: certificateSettings.leftSignatory?.name || '',
        title: certificateSettings.leftSignatory?.title || '',
      },
      rightSignature: {
        url: uploadedAssets.rightSignature,
        name: certificateSettings.rightSignatory?.name || '',
        title: certificateSettings.rightSignatory?.title || '',
      },
      awardText: certificateSettings.awardText || 'For successfully participating in',
      certificateType: certificateSettings.certificateType || 'participation',
      participant: {
        userId: userId,
        name: user.name,
        email: user.email,
      },
    };

    // Call ML single certificate render endpoint
    try {
      const renderResponse = await axios.post(
        `${CERTIFICATE_API_URL}/render-certificate`,
        renderRequest,
        {
          responseType: 'arraybuffer', // Get PDF as binary data
          timeout: 30000, // 30 second timeout
        }
      );

      // Stream the PDF directly to the response
      res.setHeader('Content-Type', 'application/pdf');
      res.setHeader(
        'Content-Disposition',
        `attachment; filename="${user.name.replace(/[^a-zA-Z0-9]/g, '_')}_Certificate.pdf"`
      );
      res.send(renderResponse.data);
    } catch (apiError) {
      console.error('Error rendering certificate:', apiError.message);
      return res.status(500).json({
        error: 'Failed to render certificate.',
        details: apiError.message,
      });
    }
  } catch (err) {
    console.error('Error in renderCertificate:', err);
    res.status(500).json({
      error: 'Server error rendering certificate.',
      details: err.message,
    });
  }
}

/**
 * Submit certificate configuration for verification
 */
async function submitCertificateConfig(req, res) {
  try {
    const { eventId } = req.params;
    const userId = req.user.id;

    // Find event and verify host permission
    const event = await Event.findById(eventId);
    if (!event) {
      return res.status(404).json({ error: 'Event not found.' });
    }

    const isHost = event.hostUserId.toString() === userId;
    if (!isHost) {
      return res.status(403).json({
        error: 'Only the event host can submit certificate configuration.',
      });
    }

    // Check if certificates are enabled
    if (!event.features?.certificateEnabled) {
      return res.status(400).json({
        error: 'Certificates are not enabled for this event.',
      });
    }

    // Validate if basic settings exist
    const settings = event.certificateSettings;
    if (!settings?.awardText || !settings?.leftSignatory?.name || !settings?.rightSignatory?.name) {
      return res.status(400).json({
        error: 'Please configure Award Text and both Signatories before submitting.',
      });
    }

    // Update status
    event.certificateSettings.verificationStatus = 'pending';
    event.certificateSettings.submittedBy = userId;
    event.certificateSettings.submittedAt = new Date();

    await event.save();

    res.json({
      message: 'Certificate configuration submitted for verification.',
      verificationStatus: 'pending',
    });
  } catch (err) {
    console.error('Error submitting certificate configuration:', err);
    res.status(500).json({ error: 'Server error submitting configuration.' });
  }
}

module.exports = {
  updateCertificateSettings,
  uploadCertificateAssets,
  generateCertificates,
  getCertificateStatus,
  getUserCertificate,
  regenerateCertificates,
  bulkUploadParticipants,
  renderCertificate,
  submitCertificateConfig,
};