src/utils/ranking.ts

import { ProviderInfo, CalendarData, ModelData } from "../types/heatmap";
import { generateCalendarData } from "./calendar";
import { fetchAllProvidersData, fetchAllAuthorsData } from "./authors";

export interface RankingBadge {
  className: string;
  icon: string | null;
}

export const getRankingBadge = (rank: number): RankingBadge => {
  if (rank === 1) {
    return {
      className: "absolute -top-4 -left-4 w-12 h-12 bg-gradient-to-br from-yellow-400 via-yellow-500 to-yellow-600 text-white rounded-full flex items-center justify-center text-lg font-bold shadow-2xl border-4 border-yellow-300",
      icon: "👑"
    };
  } else if (rank === 2) {
    return {
      className: "absolute -top-4 -left-4 w-10 h-10 bg-gradient-to-br from-gray-300 via-gray-400 to-gray-500 text-white rounded-full flex items-center justify-center text-base font-bold shadow-xl border-3 border-gray-200",
      icon: "🥈"
    };
  } else if (rank === 3) {
    return {
      className: "absolute -top-4 -left-4 w-10 h-10 bg-gradient-to-br from-amber-600 via-amber-700 to-amber-800 text-white rounded-full flex items-center justify-center text-base font-bold shadow-xl border-3 border-amber-400",
      icon: "🥉"
    };
  } else {
    return {
      className: "absolute -top-3 -left-3 w-8 h-8 bg-gradient-to-br from-blue-500 to-blue-600 text-white rounded-full flex items-center justify-center text-sm font-bold shadow-lg",
      icon: null
    };
  }
};

export const extractUniqueAuthors = (providers: ProviderInfo[]): string[] => {
  const allAuthors = providers.flatMap(({ authors }) => authors);
  return Array.from(new Set(allAuthors));
};

export const sortProvidersByActivity = (
  providers: ProviderInfo[],
  calendarData: CalendarData
): ProviderInfo[] => {
  return providers.sort((providerA, providerB) => {
    const providerAData = calendarData[providerA.authors[0]] || [];
    const providerBData = calendarData[providerB.authors[0]] || [];

    const providerAActivityCount = providerAData.reduce(
      (totalCount, day) => totalCount + day.count,
      0
    );
    const providerBActivityCount = providerBData.reduce(
      (totalCount, day) => totalCount + day.count,
      0
    );

    return providerBActivityCount - providerAActivityCount;
  });
};

export const sortProvidersByRecentRelease = (
  providers: ProviderInfo[],
  calendarData: CalendarData
): ProviderInfo[] => {
  return providers.sort((providerA, providerB) => {
    const providerAData = calendarData[providerA.authors[0]] || [];
    const providerBData = calendarData[providerB.authors[0]] || [];

    const getLatestDate = (data: typeof providerAData) => {
      if (data.length === 0) return null;
      const datesWithActivity = data.filter(day => day.count > 0);
      if (datesWithActivity.length === 0) return null;
      return datesWithActivity.reduce((latest, day) => {
        return new Date(day.date) > new Date(latest.date) ? day : latest;
      }).date;
    };

    const latestA = getLatestDate(providerAData);
    const latestB = getLatestDate(providerBData);

    if (!latestA && !latestB) return 0;
    if (!latestA) return 1;
    if (!latestB) return -1;

    return new Date(latestB).getTime() - new Date(latestA).getTime();
  });
};

export const getProviders = async (providers: ProviderInfo[]) => {
  const uniqueAuthors = extractUniqueAuthors(providers);

  const authorModelsData: ModelData[] = await fetchAllAuthorsData(uniqueAuthors);
  const providersWithMetadata = await fetchAllProvidersData(providers);

  const calendarData = generateCalendarData(authorModelsData, providersWithMetadata);

  // Calculate and store most recent release date for each provider
  const providersWithReleaseDate = providersWithMetadata.map(provider => {
    const providerData = calendarData[provider.authors[0]] || [];
    const datesWithActivity = providerData.filter(day => day.count > 0);

    if (datesWithActivity.length > 0) {
      const latestActivity = datesWithActivity.reduce((latest, day) => {
        return new Date(day.date) > new Date(latest.date) ? day : latest;
      });
      return { ...provider, mostRecentRelease: latestActivity.date };
    }

    return { ...provider, mostRecentRelease: null };
  });

  const sortedProvidersByActivity = sortProvidersByActivity(providersWithReleaseDate, calendarData);

  return {
    calendarData,
    providers: sortedProvidersByActivity,
  };
};