import { getDb } from "./db.ts";
import { users } from "../drizzle/schema.ts";
import { eq } from "drizzle-orm";

export type EmailCampaignType =
  | "welcome"
  | "win_notification"
  | "tier_promotion"
  | "re_engagement"
  | "redemption_confirmation"
  | "bonus_available"
  | "tournament_reminder"
  | "vip_exclusive";

export async function sendEmailCampaign(
  userId: number,
  campaignType: EmailCampaignType,
  variables: Record<string, string | number>
): Promise<boolean> {
  try {
    const database = await getDb();
    if (!database) return false;
    const user = await database.select().from(users).where(eq(users.id, userId)).limit(1);
    if (!user[0] || !user[0].email) return false;

    // Email templates
    const templates: Record<EmailCampaignType, { subject: string; body: (vars: Record<string, string | number>) => string }> = {
      welcome: {
        subject: "Welcome to CoinKrazy",
        body: (vars) => `Hi ${vars.userName},\n\nWelcome to CoinKrazy! Get your ${vars.welcomeBonusAmount} SC welcome bonus with code ${vars.welcomeCode}.\n\nBest regards,\nThe CoinKrazy Team`,
      },
      win_notification: {
        subject: "Congratulations! You Won SC!",
        body: (vars) => `Hi ${vars.userName},\n\nYou won ${vars.winAmount} SC on ${vars.gameName}!\n\nYour new balance: ${vars.newBalance} SC\n\nCheers,\nThe CoinKrazy Team`,
      },
      tier_promotion: {
        subject: "Congratulations! You've Been Promoted to VIP!",
        body: (vars) => `Hi ${vars.userName},\n\nYou've been promoted to ${vars.newTier} VIP!\n\nDaily Limit: $${vars.dailyLimit}\nCashback: ${vars.cashbackPercent}%\n\nWelcome to the elite!\nThe CoinKrazy Team`,
      },
      re_engagement: {
        subject: "We Miss You! Come Back and Claim Your Bonus",
        body: (vars) => `Hi ${vars.userName},\n\nWe miss you! Claim your ${vars.bonusAmount} SC comeback bonus with code ${vars.bonusCode}.\n\nValid for ${vars.validDays} days.\n\nWe can't wait to see you!\nThe CoinKrazy Team`,
      },
      redemption_confirmation: {
        subject: "Your Redemption Request",
        body: (vars) => `Hi ${vars.userName},\n\nYour redemption request of $${vars.amount} via ${vars.method} has been received.\n\nReference: ${vars.referenceId}\nProcessing time: ${vars.processingTime}\n\nBest regards,\nThe CoinKrazy Team`,
      },
      bonus_available: {
        subject: "New Bonus Available",
        body: (vars) => `Hi ${vars.userName},\n\nA new bonus ${vars.bonusName} is available!\n\nBonus: ${vars.bonusAmount} SC\nCode: ${vars.bonusCode}\nValid until: ${vars.expiryDate}\n\nHappy playing!\nThe CoinKrazy Team`,
      },
      tournament_reminder: {
        subject: "Tournament Starting Soon",
        body: (vars) => `Hi ${vars.userName},\n\nTournament ${vars.tournamentName} starts at ${vars.startTime}!\n\nPrize Pool: $${vars.prizePool}\nEntry Fee: ${vars.entryFee} SC\n\nSee you there!\nThe CoinKrazy Team`,
      },
      vip_exclusive: {
        subject: "Exclusive VIP Offer",
        body: (vars) => `Hi ${vars.userName},\n\nAs a ${vars.tierName} VIP member, here's an exclusive offer: ${vars.offerName}\n\nOffer Details: ${vars.offerDetails}\nValue: $${vars.offerValue}\n\nThank you for being awesome!\nThe CoinKrazy Team`,
      },
    };

    const template = templates[campaignType];
    const subject = template.subject;
    const body = template.body(variables);

    console.log(`📧 Email Campaign: ${campaignType} to ${user[0].email}`);
    console.log(`Subject: ${subject}`);
    console.log(`Body: ${body}`);

    // In production, integrate with SendGrid, Mailgun, or AWS SES
    return true;
  } catch (error) {
    console.error("Failed to send email campaign:", error);
    return false;
  }
}

export async function triggerWelcomeSequence(userId: number): Promise<void> {
  const database = await getDb();
  if (!database) return;
  const user = await database.select().from(users).where(eq(users.id, userId)).limit(1);
  if (!user[0]) return;

  await sendEmailCampaign(userId, "welcome", {
    userName: user[0].name || "Player",
    welcomeBonusAmount: 10,
    welcomeCode: Math.random().toString(36).substring(7).toUpperCase(),
  });
}

export async function triggerWinNotification(
  userId: number,
  gameName: string,
  winAmount: number,
  betAmount: number,
  newBalance: number
): Promise<void> {
  const database = await getDb();
  if (!database) return;
  const user = await database.select().from(users).where(eq(users.id, userId)).limit(1);
  if (!user[0]) return;

  await sendEmailCampaign(userId, "win_notification", {
    userName: user[0].name || "Player",
    winAmount,
    gameName,
    winTime: new Date().toLocaleString(),
    betAmount,
    newBalance,
  });
}

export async function triggerTierPromotion(userId: number, newTier: string): Promise<void> {
  const database = await getDb();
  if (!database) return;
  const user = await database.select().from(users).where(eq(users.id, userId)).limit(1);
  if (!user[0]) return;

  const tierBenefits: Record<string, Record<string, number>> = {
    bronze: { dailyLimit: 100, cashbackPercent: 1, bonusMultiplier: 1, freeSpins: 10 },
    silver: { dailyLimit: 250, cashbackPercent: 2, bonusMultiplier: 1.5, freeSpins: 20 },
    gold: { dailyLimit: 500, cashbackPercent: 3, bonusMultiplier: 2, freeSpins: 50 },
    platinum: { dailyLimit: 1000, cashbackPercent: 5, bonusMultiplier: 2.5, freeSpins: 100 },
    diamond: { dailyLimit: 5000, cashbackPercent: 10, bonusMultiplier: 3, freeSpins: 200 },
  };

  const benefits = tierBenefits[newTier] || tierBenefits.bronze;

  await sendEmailCampaign(userId, "tier_promotion", {
    userName: user[0].name || "Player",
    newTier: newTier.charAt(0).toUpperCase() + newTier.slice(1),
    dailyLimit: benefits.dailyLimit,
    cashbackPercent: benefits.cashbackPercent,
    bonusMultiplier: benefits.bonusMultiplier,
    freeSpins: benefits.freeSpins,
  });
}

export async function triggerReEngagement(userId: number): Promise<void> {
  const database = await getDb();
  if (!database) return;
  const user = await database.select().from(users).where(eq(users.id, userId)).limit(1);
  if (!user[0]) return;

  await sendEmailCampaign(userId, "re_engagement", {
    userName: user[0].name || "Player",
    bonusAmount: 50,
    bonusCode: Math.random().toString(36).substring(7).toUpperCase(),
    validDays: 7,
    newGamesCount: 25,
  });
}

// Welcome email automation sequence
// Sends a series of emails over the first week after registration
export async function startWelcomeAutomation(userId: number): Promise<void> {
  const database = await getDb();
  if (!database) return;
  const user = await database.select().from(users).where(eq(users.id, userId)).limit(1);
  if (!user[0]) return;

  const userName = user[0].name || "Player";
  const welcomeCode = "WELCOME" + Math.random().toString(36).substring(2, 6).toUpperCase();

  // Day 0: Immediate welcome email
  console.log(`[WelcomeAutomation] Day 0: Sending welcome email to user ${userId}`);
  await sendEmailCampaign(userId, "welcome", {
    userName,
    welcomeBonusAmount: 10,
    welcomeCode,
  });

  // Day 1: Getting started guide (scheduled)
  console.log(`[WelcomeAutomation] Scheduling Day 1 email for user ${userId}`);
  setTimeout(async () => {
    await sendEmailCampaign(userId, "bonus_available", {
      userName,
      bonusName: "Getting Started Bonus",
      bonusAmount: 50,
      bonusCode: "START50",
      expiryDate: new Date(Date.now() + 7 * 86400000).toLocaleDateString(),
    });
  }, 86400000); // 24 hours

  // Day 3: Feature discovery (scheduled)
  console.log(`[WelcomeAutomation] Scheduling Day 3 email for user ${userId}`);
  setTimeout(async () => {
    await sendEmailCampaign(userId, "bonus_available", {
      userName,
      bonusName: "Explore Our Games",
      bonusAmount: 25,
      bonusCode: "EXPLORE25",
      expiryDate: new Date(Date.now() + 4 * 86400000).toLocaleDateString(),
    });
  }, 3 * 86400000); // 3 days

  // Day 7: VIP invitation (scheduled)
  console.log(`[WelcomeAutomation] Scheduling Day 7 email for user ${userId}`);
  setTimeout(async () => {
    await sendEmailCampaign(userId, "vip_exclusive", {
      userName,
      tierName: "New Member",
      offerName: "First Week Anniversary Bonus",
      offerDetails: "Celebrate your first week with bonus SC and free spins!",
      offerValue: 100,
    });
  }, 7 * 86400000); // 7 days
}

// Redemption confirmation email
export async function triggerRedemptionConfirmation(
  userId: number,
  amount: number,
  method: string,
  referenceId: string
): Promise<void> {
  const database = await getDb();
  if (!database) return;
  const user = await database.select().from(users).where(eq(users.id, userId)).limit(1);
  if (!user[0]) return;

  const processingTimes: Record<string, string> = {
    bank_transfer: "3-5 business days",
    cashapp: "1-2 business days",
    crypto: "24-48 hours",
    gift_card: "Instant",
  };

  await sendEmailCampaign(userId, "redemption_confirmation", {
    userName: user[0].name || "Player",
    amount,
    method: method.replace("_", " ").replace(/\b\w/g, (l) => l.toUpperCase()),
    referenceId,
    processingTime: processingTimes[method] || "3-5 business days",
  });
}

// Tournament reminder email
export async function triggerTournamentReminder(
  userId: number,
  tournamentName: string,
  startTime: string,
  prizePool: number,
  entryFee: number
): Promise<void> {
  const database = await getDb();
  if (!database) return;
  const user = await database.select().from(users).where(eq(users.id, userId)).limit(1);
  if (!user[0]) return;

  await sendEmailCampaign(userId, "tournament_reminder", {
    userName: user[0].name || "Player",
    tournamentName,
    startTime,
    prizePool,
    entryFee,
  });
}