import { PageWrapper } from '@/components/shared/state/PageWrapper';
import { LeagueScheduleTemplate } from '@/templates/LeagueScheduleTemplate';
import { PageDataFetcher } from '@/lib/page/PageDataFetcher';
import { LeagueService } from '@/lib/services/leagues/LeagueService';
import { LeaguesApiClient } from '@/lib/api/leagues/LeaguesApiClient';
import { DriversApiClient } from '@/lib/api/drivers/DriversApiClient';
import { SponsorsApiClient } from '@/lib/api/sponsors/SponsorsApiClient';
import { RacesApiClient } from '@/lib/api/races/RacesApiClient';
import { EnhancedErrorReporter } from '@/lib/infrastructure/EnhancedErrorReporter';
import { ConsoleLogger } from '@/lib/infrastructure/logging/ConsoleLogger';
import { getWebsiteApiBaseUrl } from '@/lib/config/apiBaseUrl';
import { notFound } from 'next/navigation';
import { LeagueScheduleViewModel, LeagueScheduleRaceViewModel } from '@/lib/view-models/LeagueScheduleViewModel';
import type { LeagueScheduleDTO } from '@/lib/types/generated/LeagueScheduleDTO';
import type { RaceDTO } from '@/lib/types/generated/RaceDTO';

interface Props {
  params: { id: string };
}

function mapRaceDtoToViewModel(race: RaceDTO): LeagueScheduleRaceViewModel {
  const scheduledAt = race.date ? new Date(race.date) : new Date(0);
  const now = new Date();
  const isPast = scheduledAt.getTime() < now.getTime();
  const isUpcoming = !isPast;

  return {
    id: race.id,
    name: race.name,
    scheduledAt,
    isPast,
    isUpcoming,
    status: isPast ? 'completed' : 'scheduled',
    track: undefined,
    car: undefined,
    sessionType: undefined,
    isRegistered: undefined,
  };
}

function mapScheduleDtoToViewModel(dto: LeagueScheduleDTO): LeagueScheduleViewModel {
  const races = dto.races.map(mapRaceDtoToViewModel);
  return new LeagueScheduleViewModel(races);
}

export default async function Page({ params }: Props) {
  // Validate params
  if (!params.id) {
    notFound();
  }

  // Fetch data using PageDataFetcher.fetchManual for multiple dependencies
  const data = await PageDataFetcher.fetchManual(async () => {
    // Create dependencies
    const baseUrl = getWebsiteApiBaseUrl();
    const logger = new ConsoleLogger();
    const errorReporter = new EnhancedErrorReporter(logger, {
      showUserNotifications: true,
      logToConsole: true,
      reportToExternal: process.env.NODE_ENV === 'production',
    });

    // Create API clients
    const leaguesApiClient = new LeaguesApiClient(baseUrl, errorReporter, logger);
    const driversApiClient = new DriversApiClient(baseUrl, errorReporter, logger);
    const sponsorsApiClient = new SponsorsApiClient(baseUrl, errorReporter, logger);
    const racesApiClient = new RacesApiClient(baseUrl, errorReporter, logger);

    // Create service
    const service = new LeagueService(
      leaguesApiClient,
      driversApiClient,
      sponsorsApiClient,
      racesApiClient
    );

    // Fetch data
    const result = await service.getLeagueSchedule(params.id);
    if (!result) {
      throw new Error('League schedule not found');
    }
    return mapScheduleDtoToViewModel(result);
  });

  if (!data) {
    notFound();
  }

  // Create a wrapper component that passes data to the template
  const TemplateWrapper = ({ data }: { data: LeagueScheduleViewModel }) => {
    return (
      <LeagueScheduleTemplate
        data={data}
        leagueId={params.id}
      />
    );
  };

  return (
    <PageWrapper
      data={data}
      Template={TemplateWrapper}
      loading={{ variant: 'skeleton', message: 'Loading schedule...' }}
      errorConfig={{ variant: 'full-screen' }}
      empty={{
        title: 'Schedule not found',
        description: 'The schedule for this league is not available.',
      }}
    />
  );
}