gridpilot.gg/apps/website/lib/builders/view-data/LeagueDetailViewDataBuilder.ts

import type { LeagueWithCapacityAndScoringDTO } from '@/lib/types/generated/LeagueWithCapacityAndScoringDTO';
import type { LeagueMembershipsDTO } from '@/lib/types/generated/LeagueMembershipsDTO';
import type { RaceDTO } from '@/lib/types/generated/RaceDTO';
import type { GetDriverOutputDTO } from '@/lib/types/generated/GetDriverOutputDTO';
import type { LeagueScoringConfigDTO } from '@/lib/types/generated/LeagueScoringConfigDTO';
import type { LeagueDetailViewData, LeagueInfoData, LiveRaceData, DriverSummaryData, SponsorInfo } from '@/lib/view-data/LeagueDetailViewData';

/**
 * LeagueDetailViewDataBuilder
 *
 * Transforms API DTOs into LeagueDetailViewData for server-side rendering.
 * Deterministic; side-effect free; no HTTP calls.
 */
export class LeagueDetailViewDataBuilder {
  static build(input: {
    league: LeagueWithCapacityAndScoringDTO;
    owner: GetDriverOutputDTO | null;
    scoringConfig: LeagueScoringConfigDTO | null;
    memberships: LeagueMembershipsDTO;
    races: RaceDTO[];
    sponsors: any[];
  }): LeagueDetailViewData {
    const { league, owner, scoringConfig, memberships, races, sponsors } = input;
    
    // Calculate running races - using available fields from RaceDTO
    const runningRaces: LiveRaceData[] = races
      .filter(r => r.name.includes('Running')) // Placeholder filter
      .map(r => ({
        id: r.id,
        name: r.name,
        date: r.date,
        registeredCount: 0,
        strengthOfField: 0,
      }));
    
    // Calculate info data
    const membersCount = Array.isArray(memberships.members) ? memberships.members.length : 0;
    const completedRacesCount = races.filter(r => {
      const status = (r as any).status;
      return status === 'completed' || status === 'past';
    }).length;
    
    // Compute real avgSOF from races
    const racesWithSOF = races.filter(r => {
      const sof = (r as any).strengthOfField;
      return typeof sof === 'number' && sof > 0;
    });
    const avgSOF = racesWithSOF.length > 0
      ? Math.round(racesWithSOF.reduce((sum, r) => sum + ((r as any).strengthOfField || 0), 0) / racesWithSOF.length)
      : null;
    
    const info: LeagueInfoData = {
      name: league.name,
      description: league.description || '',
      membersCount,
      racesCount: completedRacesCount,
      avgSOF,
      structure: `Solo • ${league.settings?.maxDrivers ?? 32} max`,
      scoring: scoringConfig?.scoringPresetId || 'Standard',
      createdAt: league.createdAt,
      discordUrl: league.socialLinks?.discordUrl,
      youtubeUrl: league.socialLinks?.youtubeUrl,
      websiteUrl: league.socialLinks?.websiteUrl,
    };
    
    // Convert owner to driver summary
    const ownerSummary: DriverSummaryData | null = owner ? {
      driverId: owner.id,
      driverName: owner.name,
      avatarUrl: owner.avatarUrl || null,
      rating: null,
      rank: null,
      roleBadgeText: 'Owner',
      roleBadgeClasses: 'bg-yellow-500/10 text-yellow-500 border-yellow-500/30',
      profileUrl: `/drivers/${owner.id}`,
    } : null;
    
    // Convert sponsors
    const sponsorInfo: SponsorInfo[] = sponsors.map(s => ({
      id: s.id,
      name: s.name,
      tier: s.tier,
      logoUrl: s.logoUrl,
      websiteUrl: s.websiteUrl,
      tagline: s.tagline,
    }));
    
    // Convert memberships to summaries
    const adminSummaries: DriverSummaryData[] = (memberships.members || [])
      .filter(m => m.role === 'admin')
      .map(m => ({
        driverId: m.driverId,
        driverName: m.driver.name,
        avatarUrl: (m.driver as any).avatarUrl || null,
        rating: null,
        rank: null,
        roleBadgeText: 'Admin',
        roleBadgeClasses: 'bg-blue-500/10 text-blue-500 border-blue-500/30',
        profileUrl: `/drivers/${m.driverId}`,
      }));

    const stewardSummaries: DriverSummaryData[] = (memberships.members || [])
      .filter(m => m.role === 'steward')
      .map(m => ({
        driverId: m.driverId,
        driverName: m.driver.name,
        avatarUrl: (m.driver as any).avatarUrl || null,
        rating: null,
        rank: null,
        roleBadgeText: 'Steward',
        roleBadgeClasses: 'bg-purple-500/10 text-purple-500 border-purple-500/30',
        profileUrl: `/drivers/${m.driverId}`,
      }));

    const memberSummaries: DriverSummaryData[] = (memberships.members || [])
      .filter(m => m.role === 'member')
      .map(m => ({
        driverId: m.driverId,
        driverName: m.driver.name,
        avatarUrl: (m.driver as any).avatarUrl || null,
        rating: null,
        rank: null,
        roleBadgeText: 'Member',
        roleBadgeClasses: 'bg-zinc-500/10 text-zinc-500 border-zinc-500/30',
        profileUrl: `/drivers/${m.driverId}`,
      }));

    return {
      leagueId: league.id,
      name: league.name,
      description: league.description || '',
      logoUrl: league.logoUrl,
      info,
      runningRaces,
      sponsors: sponsorInfo,
      ownerSummary,
      adminSummaries,
      stewardSummaries,
      memberSummaries,
      sponsorInsights: null, // Only for sponsor mode
    };
  }
}