'use server';

import { sendEmail } from '@/lib/mail/mailer';
import { env } from '@/lib/env';
import { render, ContactFormNotification, ConfirmationMessage } from '@mintel/mail';
import React from 'react';
import { getServerAppServices } from '@/lib/services/create-services.server';

export async function sendContactFormAction(formData: FormData) {
  const services = getServerAppServices();
  const logger = services.logger.child({ action: 'sendContactFormAction' });

  // Set analytics context from request headers for high-fidelity server-side tracking
  const { headers } = await import('next/headers');
  const requestHeaders = await headers();

  if ('setServerContext' in services.analytics) {
    (services.analytics as any).setServerContext({
      userAgent: requestHeaders.get('user-agent') || undefined,
      language: requestHeaders.get('accept-language')?.split(',')[0] || undefined,
      referrer: requestHeaders.get('referer') || undefined,
      ip: requestHeaders.get('x-forwarded-for')?.split(',')[0] || undefined,
    });
  }

  // Track attempt
  services.analytics.track('contact-form-attempt');

  const name = formData.get('name') as string;
  const email = formData.get('email') as string;
  const message = formData.get('message') as string;
  const productName = formData.get('productName') as string | null;

  if (!name || !email || !message) {
    logger.warn(
      {
        name: !!name,
        email: !!email,
        message: !!message,
      },
      'Missing required fields in contact form',
    );
    return { success: false, error: 'Missing required fields' };
  }

  logger.info(
    {
      type: productName ? 'product_quote' : 'contact',
      email,
    },
    'Payload CMS saving skipped because it has been removed',
  );

  // 1.5. Simple Fail-Safe Backup to Disk
  // To ensure leads are never lost if email fails or Gotify is down, we append them to a local JSON Lines file.
  try {
    const fs = await import('fs');
    const path = await import('path');
    const backupDir = path.join(process.cwd(), '.data');
    if (!fs.existsSync(backupDir)) fs.mkdirSync(backupDir, { recursive: true });

    const backupFile = path.join(backupDir, 'leads-backup.jsonl');
    const leadData = {
      timestamp: new Date().toISOString(),
      name,
      email,
      productName,
      message,
    };
    fs.appendFileSync(backupFile, JSON.stringify(leadData) + '\n');
    logger.info({ backupFile }, 'Successfully saved lead to local backup file');
  } catch (backupError) {
    logger.error({ error: String(backupError) }, 'Failed to write to local leads backup');
  }

  // 2. Send Emails
  logger.info({ email, productName }, 'Sending branded emails');

  const notificationSubject = productName
    ? `Product Inquiry: ${productName}`
    : 'New Contact Form Submission';
  const confirmationSubject = 'Thank you for your inquiry';
  const isTestSubmission = email === 'testing@mintel.me';

  try {
    // 2a. Send notification to Mintel/Client
    const notificationHtml = await render(
      React.createElement(ContactFormNotification, {
        name,
        email,
        message,
        productName: productName || undefined,
      }),
    );

    if (!isTestSubmission) {
      logger.info({ recipients: env.MAIL_RECIPIENTS }, 'Sending internal notification');
      const notificationResult = await sendEmail({
        replyTo: email,
        subject: notificationSubject,
        html: notificationHtml,
      });

      if (notificationResult.success) {
        logger.info(
          {
            messageId: notificationResult.messageId,
          },
          'Notification email sent successfully',
        );
      } else {
        logger.error(
          {
            error: notificationResult.error,
            subject: notificationSubject,
            recipients: env.MAIL_RECIPIENTS,
          },
          'Notification email DELIVERY FAILED',
        );
        services.errors.captureException(
          new Error(`Notification email failed: ${notificationResult.error}`),
          {
            action: 'sendContactFormAction_notification',
            email,
            recipients: env.MAIL_RECIPIENTS,
          },
        );
      }
    } else {
      logger.info({ email }, 'Skipping notification email for test submission');
    }

    // 2b. Send confirmation to Customer (branded as KLZ Cables)
    const confirmationHtml = await render(
      React.createElement(ConfirmationMessage, {
        name,
        clientName: 'KLZ Cables',
        // brandColor: '#82ed20', // Optional: could be KLZ specific
      }),
    );

    if (!isTestSubmission) {
      logger.info({ to: email }, 'Sending customer confirmation');
      const confirmationResult = await sendEmail({
        to: email,
        subject: confirmationSubject,
        html: confirmationHtml,
      });

      if (confirmationResult.success) {
        logger.info(
          {
            messageId: confirmationResult.messageId,
          },
          'Confirmation email sent successfully',
        );
      } else {
        logger.error(
          {
            error: confirmationResult.error,
            subject: confirmationSubject,
            to: email,
          },
          'Confirmation email DELIVERY FAILED',
        );
        services.errors.captureException(
          new Error(`Confirmation email failed: ${confirmationResult.error}`),
          { action: 'sendContactFormAction_confirmation', email },
        );
      }
    } else {
      logger.info({ email }, 'Skipping confirmation email for test submission');
    }

    // Notify via Gotify (Internal)
    await services.notifications.notify({
      title: `📩 [KLZ] ${notificationSubject}`,
      message: `New message from ${name} (${email}):\n\n${message}`,
      priority: 5,
    });

    // Track success
    services.analytics.track('contact-form-success', {
      is_product_request: !!productName,
    });

    return { success: true };
  } catch (error) {
    const errorMsg = error instanceof Error ? error.message : String(error);
    logger.error(
      {
        error: errorMsg,
        stack: error instanceof Error ? error.stack : undefined,
      },
      'Failed to send branded emails',
    );

    services.errors.captureException(error, { action: 'sendContactFormAction', email });

    await services.notifications.notify({
      title: '🚨 Contact Form Error',
      message: `Failed to send emails for ${name} (${email}). Error: ${errorMsg}`,
      priority: 8,
    });

    return { success: false, error: errorMsg };
  }
}