/**
 * SendGrid Email Service Integration
 * Handles email campaign delivery and tracking
 */

import sgMail from '@sendgrid/mail';

export interface EmailCampaignPayload {
  campaignId: string;
  subject: string;
  htmlContent: string;
  recipients: string[];
  fromEmail?: string;
  fromName?: string;
  replyTo?: string;
  trackingEnabled?: boolean;
  trackingClicksEnabled?: boolean;
}

export interface SendGridEmailResponse {
  success: boolean;
  messageId?: string;
  error?: string;
  timestamp: number;
}

/**
 * Initialize SendGrid with API key
 */
export function initializeSendGrid(apiKey: string) {
  if (!apiKey) {
    console.warn('[SendGrid] No API key provided. Email functionality disabled.');
    return false;
  }

  try {
    sgMail.setApiKey(apiKey);
    console.log('[SendGrid] Initialized successfully');
    return true;
  } catch (error) {
    console.error('[SendGrid] Initialization failed:', error);
    return false;
  }
}

/**
 * Send email campaign to recipients
 */
export async function sendEmailCampaign(
  payload: EmailCampaignPayload
): Promise<SendGridEmailResponse> {
  try {
    const fromEmail = payload.fromEmail || 'noreply@playcoinkrazy.com';
    const fromName = payload.fromName || 'CoinKrazy';

    const msg = {
      to: payload.recipients,
      from: {
        email: fromEmail,
        name: fromName,
      },
      replyTo: payload.replyTo || fromEmail,
      subject: payload.subject,
      html: payload.htmlContent,
      trackingSettings: {
        clickTracking: {
          enable: payload.trackingClicksEnabled !== false,
        },
        openTracking: {
          enable: payload.trackingEnabled !== false,
        },
      },
      customArgs: {
        campaignId: payload.campaignId,
      },
    };

    const response = await sgMail.sendMultiple(msg as any);

    console.log(`[SendGrid] Campaign ${payload.campaignId} sent to ${payload.recipients.length} recipients`);

    return {
      success: true,
      messageId: response[0]?.headers?.['x-message-id'],
      timestamp: Date.now(),
    };
  } catch (error: any) {
    console.error('[SendGrid] Failed to send campaign:', error);

    return {
      success: false,
      error: error.message || 'Unknown error',
      timestamp: Date.now(),
    };
  }
}

/**
 * Send single email
 */
export async function sendEmail(
  to: string,
  subject: string,
  htmlContent: string,
  fromEmail?: string,
  fromName?: string
): Promise<SendGridEmailResponse> {
  try {
    const msg = {
      to,
      from: {
        email: fromEmail || 'noreply@playcoinkrazy.com',
        name: fromName || 'CoinKrazy',
      },
      subject,
      html: htmlContent,
    };

    const response = await sgMail.send(msg as any);

    console.log(`[SendGrid] Email sent to ${to}`);

    return {
      success: true,
      messageId: response[0]?.headers?.['x-message-id'],
      timestamp: Date.now(),
    };
  } catch (error: any) {
    console.error('[SendGrid] Failed to send email:', error);

    return {
      success: false,
      error: error.message || 'Unknown error',
      timestamp: Date.now(),
    };
  }
}

/**
 * Send transactional email (password reset, verification, etc.)
 */
export async function sendTransactionalEmail(
  to: string,
  templateId: string,
  dynamicData: Record<string, any>
): Promise<SendGridEmailResponse> {
  try {
    const msg = {
      to,
      from: {
        email: 'noreply@playcoinkrazy.com',
        name: 'CoinKrazy',
      },
      templateId,
      dynamicTemplateData: dynamicData,
    };

    const response = await sgMail.send(msg as any);

    console.log(`[SendGrid] Transactional email sent to ${to} using template ${templateId}`);

    return {
      success: true,
      messageId: response[0]?.headers?.['x-message-id'],
      timestamp: Date.now(),
    };
  } catch (error: any) {
    console.error('[SendGrid] Failed to send transactional email:', error);

    return {
      success: false,
      error: error.message || 'Unknown error',
      timestamp: Date.now(),
    };
  }
}

/**
 * Validate email address
 */
export function validateEmail(email: string): boolean {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(email);
}

/**
 * Validate email list
 */
export function validateEmailList(emails: string[]): {
  valid: string[];
  invalid: string[];
} {
  const valid: string[] = [];
  const invalid: string[] = [];

  emails.forEach((email) => {
    if (validateEmail(email)) {
      valid.push(email);
    } else {
      invalid.push(email);
    }
  });

  return { valid, invalid };
}