/**
 * Retention Campaign Service
 * Manages player retention campaigns with email and SMS delivery via Brevo
 */

import { sendBrevoEmail } from './brevoEmailService.ts';
import { sendSMS } from './smsDeliveryService.ts';

export interface RetentionCampaign {
  id: number;
  name: string;
  targetSegment: 'dormant' | 'casual' | 'vip' | 'new' | 'atrisk';
  status: 'draft' | 'scheduled' | 'active' | 'completed' | 'paused';
  startDate: Date;
  endDate: Date;
  targetAudience: number;
  reachedAudience: number;
  conversionRate: number;
  revenue: number;
  message: string;
  offers: string[];
  channels: string[];
}

export interface CampaignSegmentPlayers {
  userId: number;
  email: string;
  phone?: string;
  lastActivityDate: Date;
  lifetimeValue: number;
  preferredChannel: 'email' | 'sms' | 'push';
}

/**
 * Get players matching the target segment
 */
export async function getSegmentPlayers(
  segment: string,
  limit: number = 1000
): Promise<CampaignSegmentPlayers[]> {
  // This would query the database based on segment criteria
  // For now, return mock data
  const mockPlayers: CampaignSegmentPlayers[] = [];
  
  for (let i = 0; i < Math.min(limit, 100); i++) {
    mockPlayers.push({
      userId: 1000 + i,
      email: `player${i}@example.com`,
      phone: `+1555${String(i).padStart(7, '0')}`,
      lastActivityDate: new Date(Date.now() - Math.random() * 30 * 24 * 60 * 60 * 1000),
      lifetimeValue: Math.random() * 5000,
      preferredChannel: ['email', 'sms', 'push'][Math.floor(Math.random() * 3)] as any,
    });
  }
  
  return mockPlayers;
}

/**
 * Send retention campaign via email
 */
export async function sendCampaignViaEmail(
  players: CampaignSegmentPlayers[],
  campaignName: string,
  message: string,
  offers: string[]
): Promise<{ sent: number; failed: number; errors: string[] }> {
  let sent = 0;
  let failed = 0;
  const errors: string[] = [];

  for (const player of players) {
    try {
      const emailContent = generateEmailContent(campaignName, message, offers);
      
      await sendBrevoEmail({
        to: player.email,
        subject: `${campaignName} - Exclusive Offer Inside!`,
        html: emailContent,
        templateName: 'retention_campaign',
        variables: {
          playerName: `Player ${player.userId}`,
          campaignName,
          offers: offers.join(', '),
          message,
        },
      });
      
      sent++;
    } catch (error) {
      failed++;
      errors.push(`Failed to send to ${player.email}: ${error}`);
    }
  }

  return { sent, failed, errors };
}

/**
 * Send retention campaign via SMS
 */
export async function sendCampaignViaSMS(
  players: CampaignSegmentPlayers[],
  campaignName: string,
  offers: string[]
): Promise<{ sent: number; failed: number; errors: string[] }> {
  let sent = 0;
  let failed = 0;
  const errors: string[] = [];

  for (const player of players) {
    if (!player.phone) {
      failed++;
      continue;
    }

    try {
      const smsContent = generateSMSContent(campaignName, offers);
      
      await sendSMS({
        to: player.phone,
        message: smsContent,
      });
      
      sent++;
    } catch (error) {
      failed++;
      errors.push(`Failed to send SMS to ${player.phone}: ${error}`);
    }
  }

  return { sent, failed, errors };
}

/**
 * Send retention campaign via push notification
 */
export async function sendCampaignViaPush(
  players: CampaignSegmentPlayers[],
  campaignName: string,
  message: string,
  offers: string[]
): Promise<{ sent: number; failed: number; errors: string[] }> {
  let sent = 0;
  let failed = 0;
  const errors: string[] = [];

  for (const player of players) {
    try {
      // In production, this would send via Firebase Cloud Messaging or similar
      // For now, just track as sent
      sent++;
    } catch (error) {
      failed++;
      errors.push(`Failed to send push to user ${player.userId}: ${error}`);
    }
  }

  return { sent, failed, errors };
}

/**
 * Generate email content for retention campaign
 */
function generateEmailContent(
  campaignName: string,
  message: string,
  offers: string[]
): string {
  const offersHtml = offers
    .map((offer) => `<li style="margin: 8px 0;">${offer}</li>`)
    .join('');

  return `
    <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
      <h2 style="color: #1f2937;">${campaignName}</h2>
      <p style="color: #4b5563; line-height: 1.6;">${message}</p>
      
      <h3 style="color: #1f2937; margin-top: 24px;">Your Exclusive Offers:</h3>
      <ul style="color: #4b5563; line-height: 1.8;">
        ${offersHtml}
      </ul>
      
      <div style="margin-top: 32px; text-align: center;">
        <a href="https://playcoinkrazy.com/casino" style="background-color: #3b82f6; color: white; padding: 12px 24px; text-decoration: none; border-radius: 6px; display: inline-block;">
          Claim Your Offer
        </a>
      </div>
      
      <p style="color: #9ca3af; font-size: 12px; margin-top: 32px;">
        This is a promotional email. You can manage your preferences in your account settings.
      </p>
    </div>
  `;
}

/**
 * Generate SMS content for retention campaign
 */
function generateSMSContent(campaignName: string, offers: string[]): string {
  const offersText = offers.slice(0, 2).join(', ');
  return `${campaignName}: ${offersText}. Claim now at playcoinkrazy.com`;
}

/**
 * Calculate campaign performance metrics
 */
export async function calculateCampaignMetrics(
  campaignId: number,
  sent: number,
  opened: number,
  clicked: number,
  converted: number,
  revenue: number
): Promise<{
  openRate: number;
  clickRate: number;
  conversionRate: number;
  revenuePerSent: number;
  roi: number;
}> {
  return {
    openRate: (opened / sent) * 100,
    clickRate: (clicked / sent) * 100,
    conversionRate: (converted / sent) * 100,
    revenuePerSent: revenue / sent,
    roi: ((revenue - (sent * 0.01)) / (sent * 0.01)) * 100, // Assuming $0.01 cost per send
  };
}

/**
 * Get campaign performance by channel
 */
export async function getCampaignPerformanceByChannel(
  campaignId: number
): Promise<
  Array<{
    channel: string;
    sent: number;
    opened: number;
    clicked: number;
    converted: number;
    openRate: number;
    clickRate: number;
    conversionRate: number;
  }>
> {
  // Mock data - would query database in production
  return [
    {
      channel: 'email',
      sent: 2850,
      opened: 1368,
      clicked: 684,
      converted: 410,
      openRate: 48.0,
      clickRate: 24.0,
      conversionRate: 14.4,
    },
    {
      channel: 'sms',
      sent: 1500,
      opened: 1425,
      clicked: 712,
      converted: 214,
      openRate: 95.0,
      clickRate: 47.5,
      conversionRate: 14.3,
    },
    {
      channel: 'push',
      sent: 2000,
      opened: 1200,
      clicked: 480,
      converted: 160,
      openRate: 60.0,
      clickRate: 24.0,
      conversionRate: 8.0,
    },
  ];
}

/**
 * Pause campaign
 */
export async function pauseCampaign(campaignId: number): Promise<boolean> {
  // Update campaign status to 'paused' in database
  return true;
}

/**
 * Resume campaign
 */
export async function resumeCampaign(campaignId: number): Promise<boolean> {
  // Update campaign status back to 'active' in database
  return true;
}

/**
 * Cancel campaign
 */
export async function cancelCampaign(campaignId: number): Promise<boolean> {
  // Update campaign status to 'completed' in database
  return true;
}