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

export type BadgeTier = "gold" | "silver" | "bronze";

export interface BadgeConfig {
  tier: BadgeTier;
  minReferrals: number;
  displayName: string;
  icon: string;
  color: string;
}

const BADGE_TIERS: Record<BadgeTier, BadgeConfig> = {
  gold: {
    tier: "gold",
    minReferrals: 50,
    displayName: "Gold Referrer",
    icon: "🥇",
    color: "#FFD700",
  },
  silver: {
    tier: "silver",
    minReferrals: 20,
    displayName: "Silver Referrer",
    icon: "🥈",
    color: "#C0C0C0",
  },
  bronze: {
    tier: "bronze",
    minReferrals: 5,
    displayName: "Bronze Referrer",
    icon: "🥉",
    color: "#CD7F32",
  },
};

export async function getUserBadge(userId: number): Promise<BadgeConfig | null> {
  const db = await getDb();
  if (!db) return null;

  const userReferrals = await db
    .select()
    .from(referrals)
    .where(eq(referrals.referrerId, userId));

  const completedCount = userReferrals.filter(
    (r) => r.status === "completed"
  ).length;

  // Determine badge tier based on completed referrals
  if (completedCount >= BADGE_TIERS.gold.minReferrals) {
    return BADGE_TIERS.gold;
  } else if (completedCount >= BADGE_TIERS.silver.minReferrals) {
    return BADGE_TIERS.silver;
  } else if (completedCount >= BADGE_TIERS.bronze.minReferrals) {
    return BADGE_TIERS.bronze;
  }

  return null;
}

export async function getTopReferrersWithBadges(
  limit: number = 10
): Promise<
  Array<{
    userId: number;
    completedReferrals: number;
    totalEarnings: number;
    badge: BadgeConfig | null;
  }>
> {
  const db = await getDb();
  if (!db) return [];

  const allReferrals = await db.select().from(referrals);

  // Group by referrer and calculate stats
  const referrerStats: Record<
    number,
    {
      userId: number;
      completedReferrals: number;
      totalEarnings: number;
    }
  > = {};

  for (const ref of allReferrals) {
    if (!referrerStats[ref.referrerId]) {
      referrerStats[ref.referrerId] = {
        userId: ref.referrerId,
        completedReferrals: 0,
        totalEarnings: 0,
      };
    }

    if (ref.status === "completed") {
      referrerStats[ref.referrerId].completedReferrals++;
      referrerStats[ref.referrerId].totalEarnings += 1; // 1 SC per referral
    }
  }

  // Sort by total earnings and return top N with badges
  const topReferrers = Object.values(referrerStats)
    .sort((a, b) => b.totalEarnings - a.totalEarnings)
    .slice(0, limit);

  // Add badges to each referrer
  return topReferrers.map((referrer) => {
    let badge: BadgeConfig | null = null;

    if (referrer.completedReferrals >= BADGE_TIERS.gold.minReferrals) {
      badge = BADGE_TIERS.gold;
    } else if (referrer.completedReferrals >= BADGE_TIERS.silver.minReferrals) {
      badge = BADGE_TIERS.silver;
    } else if (referrer.completedReferrals >= BADGE_TIERS.bronze.minReferrals) {
      badge = BADGE_TIERS.bronze;
    }

    return {
      ...referrer,
      badge,
    };
  });
}

export function getBadgeProgress(
  completedReferrals: number
): {
  currentBadge: BadgeConfig | null;
  nextBadge: BadgeConfig | null;
  progressToNext: number;
} {
  let currentBadge: BadgeConfig | null = null;
  let nextBadge: BadgeConfig | null = null;
  let progressToNext = 0;

  if (completedReferrals >= BADGE_TIERS.gold.minReferrals) {
    currentBadge = BADGE_TIERS.gold;
    nextBadge = null;
    progressToNext = 100;
  } else if (completedReferrals >= BADGE_TIERS.silver.minReferrals) {
    currentBadge = BADGE_TIERS.silver;
    nextBadge = BADGE_TIERS.gold;
    progressToNext = Math.round(
      ((completedReferrals - BADGE_TIERS.silver.minReferrals) /
        (BADGE_TIERS.gold.minReferrals - BADGE_TIERS.silver.minReferrals)) *
        100
    );
  } else if (completedReferrals >= BADGE_TIERS.bronze.minReferrals) {
    currentBadge = BADGE_TIERS.bronze;
    nextBadge = BADGE_TIERS.silver;
    progressToNext = Math.round(
      ((completedReferrals - BADGE_TIERS.bronze.minReferrals) /
        (BADGE_TIERS.silver.minReferrals - BADGE_TIERS.bronze.minReferrals)) *
        100
    );
  } else {
    currentBadge = null;
    nextBadge = BADGE_TIERS.bronze;
    progressToNext = Math.round(
      (completedReferrals / BADGE_TIERS.bronze.minReferrals) * 100
    );
  }

  return {
    currentBadge,
    nextBadge,
    progressToNext,
  };
}