import { Request, Response } from 'express';
import { asyncHandler } from '../../utils/asyncHandler';
import { UniResponse } from '../../lib/UniResponse';
import { HelpAndFeedbackRepository } from './index.repository';
import path from 'path';
import fs from 'fs';
import { PDFGenerationService } from '../../services/pdf-generation.service';
import { NotificationUtils } from '../../utils/NotificationUtils';
import { humanizeClientError } from '../../utils/humanReadableError';

export class HelpAndFeedbackController {
  // ========== CREATE CONTACT ================
  public static createContact = asyncHandler(async (req: Request, res: Response) => {
    const {
      name,
      email,
      message,
      phone,
      subject,
      contact_priority,
      contact_status,
      scan_id,
      qrcode_id,
      userId,
    } = req.body;

    const contactData = {
      name,
      email,
      message,
      phone,
      subject,
      contact_status,
      contact_priority: contact_priority?.toLowerCase(),
      scan_id,
      qrcode_id,
      user_id: userId as any,
    };

    const contact = await HelpAndFeedbackRepository.createContact(contactData);

    const response = UniResponse.Success('Contact created successfully', contact, 201);
    return res.status(response.code).json(response);
  });

  // ========== GET ALL CONTACTS ================
  public static getAllContacts = asyncHandler(async (req: Request, res: Response) => {
    const page = parseInt(req.query.page as string) || 1;
    const limit = parseInt(req.query.limit as string) || 10;
    const { status, priority, search } = req.query;

    // Build filter object
    const filter: any = {};
    if (status) filter.contact_status = status;
    if (priority) filter.contact_priority = priority;
    if (search) {
      filter.$or = [
        { name: { $regex: search, $options: 'i' } },
        { email: { $regex: search, $options: 'i' } },
        { subject: { $regex: search, $options: 'i' } },
        { message: { $regex: search, $options: 'i' } },
      ];
    }

    const result = await HelpAndFeedbackRepository.getAllContacts(page, limit, filter);

    const response = UniResponse.Success(
      'Contacts retrieved successfully',
      result,
      200
    );
    return res.status(response.code).json(response);
  });

  // ========== GET CONTACT BY ID ================
  public static getContactById = asyncHandler(async (req: Request, res: Response) => {
    const { id } = req.params;

    const contact = await HelpAndFeedbackRepository.getContactById(id as any);

    if (!contact) {
      const response = UniResponse.Error('Contact not found', null, 404);
      return res.status(response.code).json(response);
    }

    const response = UniResponse.Success(
      'Contact retrieved successfully',
      contact,
      200
    );
    return res.status(response.code).json(response);
  });

  // ========== UPDATE CONTACT ================
  public static updateContact = asyncHandler(async (req: Request, res: Response) => {
    const { id } = req.params;
    const updateData = req.body;

    // Don't allow updating of certain fields that should be managed separately
    delete updateData._id;
    delete updateData.createdAt;
    delete updateData.updatedAt;

    const contact = await HelpAndFeedbackRepository.updateContact(
      id as any,
      updateData
    );

    if (!contact) {
      const response = UniResponse.Error('Contact not found', null, 404);
      return res.status(response.code).json(response);
    }

    const response = UniResponse.Success('Contact updated successfully', contact, 200);
    return res.status(response.code).json(response);
  });

  // ========== DELETE CONTACT ================
  public static deleteContact = asyncHandler(async (req: Request, res: Response) => {
    const { id } = req.params;

    const isDeleted = await HelpAndFeedbackRepository.deleteContact(id as any);

    if (!isDeleted) {
      const response = UniResponse.Error('Contact not found', null, 404);
      return res.status(response.code).json(response);
    }

    const response = UniResponse.Success('Contact deleted successfully', null, 200);
    return res.status(response.code).json(response);
  });

  // ========== UPDATE CONTACT STATUS ================
  public static updateContactStatus = asyncHandler(
    async (req: Request, res: Response) => {
      const { id } = req.params;
      const { status } = req.body;

      // Validate status
      if (!['pending', 'resolved', 'closed'].includes(status)) {
        const response = UniResponse.Error(
          'Invalid status. Must be one of: pending, resolved, closed',
          null,
          400
        );
        return res.status(response.code).json(response);
      }

      const contact = await HelpAndFeedbackRepository.updateContactStatus(
        id as any,
        status
      );

      if (!contact) {
        const response = UniResponse.Error('Contact not found', null, 404);
        return res.status(response.code).json(response);
      }

      // Send push notification if user_id is available
      const contactAny = contact as any;
      if (contactAny.user_id) {
        try {
          // Get user_id - it might be populated (object) or just an ID (string/ObjectId)
          let userId: string | undefined;

          if (Array.isArray(contactAny.user_id)) {
            // Handle case where user_id is an array (shouldn't happen but just in case)
            userId =
              contactAny.user_id[0]?._id?.toString() ||
              contactAny.user_id[0]?.toString();
          } else if (
            typeof contactAny.user_id === 'object' &&
            contactAny.user_id !== null
          ) {
            // If populated, it's an object with _id property
            const populatedUser = contactAny.user_id;
            userId = populatedUser._id?.toString() || populatedUser.toString();
          } else {
            // If not populated, it's an ObjectId
            userId = String(contactAny.user_id);
          }

          if (userId) {
            // Create status-specific messages
            const statusMessages: Record<string, { title: string; body: string }> = {
              pending: {
                title: 'Contact Status Updated',
                body: `Your contact "${contactAny.subject || 'request'}" status has been updated to pending.`,
              },
              resolved: {
                title: 'Contact Resolved',
                body: `Great news! Your contact "${contactAny.subject || 'request'}" has been resolved.`,
              },
              closed: {
                title: 'Contact Closed',
                body: `Your contact "${contactAny.subject || 'request'}" has been closed.`,
              },
            };

            const message = statusMessages[status] || statusMessages.pending;

            // Send push notification (non-blocking)
            NotificationUtils.sendPushNotification(userId, {
              title: message.title,
              body: message.body,
              data: {
                contactId: contactAny._id?.toString() || id,
                status: status,
                type: 'contact_status_update',
              },
            }).catch(error => {
              // Log error but don't fail the request
              console.error(
                'Failed to send push notification for contact status update:',
                error
              );
            });
          }
        } catch (error) {
          // Log error but don't fail the request
          console.error(
            'Error processing push notification for contact status update:',
            error
          );
        }
      }

      const response = UniResponse.Success(
        'Contact status updated successfully',
        contact,
        200
      );
      return res.status(response.code).json(response);
    }
  );

  // ========== UPDATE CONTACT PRIORITY ================
  public static updateContactPriority = asyncHandler(
    async (req: Request, res: Response) => {
      const { id } = req.params;
      const { priority } = req.body;

      // Validate priority
      if (!['high', 'medium', 'low'].includes(priority)) {
        const response = UniResponse.Error(
          'Invalid priority. Must be one of: high, medium, low',
          null,
          400
        );
        return res.status(response.code).json(response);
      }

      const contact = await HelpAndFeedbackRepository.updateContactPriority(
        id as any,
        priority
      );

      if (!contact) {
        const response = UniResponse.Error('Contact not found', null, 404);
        return res.status(response.code).json(response);
      }

      const response = UniResponse.Success(
        'Contact priority updated successfully',
        contact,
        200
      );
      return res.status(response.code).json(response);
    }
  );

  // =========== EXPORT PDF REPORT ======================
  public static pdfReport = asyncHandler(async (req: Request, res: Response) => {
    const startTime = Date.now();
    console.log(
      '==================== Starting PDF report generation... ===================='
    );

    // 1. Fetch Contact Data - Fetch All Contacts
    // Using a large limit to simulate "all" for now, or passing empty filter
    const result = await HelpAndFeedbackRepository.getAllContacts(1, 100000, {});
    const contacts = result.contacts;

    if (!contacts || contacts.length === 0) {
      const response = UniResponse.Error('No contacts found to export', null, 404);
      return res.status(response.code).json(response);
    }

    try {
      // Generate PDF using jsPDF
      const pdfBuffer = await PDFGenerationService.generateContactsReport(contacts);

      // Create uploads directory if it doesn't exist
      // Use root-level uploads directory for both production and development
      const uploadDir = path.join(process.cwd(), 'uploads');
      if (!fs.existsSync(uploadDir)) {
        fs.mkdirSync(uploadDir, { recursive: true });
      }

      // Save PDF to file
      const filename = `contacts-export.pdf`;
      const filePath = path.join(uploadDir, filename);
      fs.writeFileSync(filePath, pdfBuffer);

      const endTime = Date.now();
      const durationMs = endTime - startTime;
      const durationSeconds = durationMs / 1000; // Convert milliseconds to seconds
      console.log(
        `==================== PDF generation completed in ${durationSeconds.toFixed(2)} seconds ====================`
      );

      // 5. Construct Download URL
      // Use req.get('host') to include port number when needed
      const protocol = req.protocol;
      const host = req.get('host');
      const downloadUrl = `${protocol}://${host}/uploads/${filename}`;

      const response = UniResponse.Success(
        'PDF Report generated successfully',
        {
          downloadUrl,
          generationTime: durationSeconds.toFixed(2) + 's',
        },
        200
      );
      return res.status(response.code).json(response);
    } catch (error: any) {
      console.error('PDF generation error:', error);
      const response = UniResponse.Error(
        humanizeClientError(
          error,
          'We could not generate your PDF report. Please try again.'
        ),
        null,
        500
      );
      return res.status(response.code).json(response);
    }
  });
}
