import { DriversApiClient } from '@/lib/api/drivers/DriversApiClient';
import { TeamsApiClient } from '@/lib/api/teams/TeamsApiClient';
import { Result } from '@/lib/contracts/Result';
import { Service, DomainError } from '@/lib/contracts/services/Service';
import { ConsoleErrorReporter } from '@/lib/infrastructure/logging/ConsoleErrorReporter';
import { ConsoleLogger } from '@/lib/infrastructure/logging/ConsoleLogger';
import type { DriverLeaderboardItemDTO } from '@/lib/types/generated/DriverLeaderboardItemDTO';
import type { TeamListItemDTO } from '@/lib/types/generated/TeamListItemDTO';
import { getWebsiteApiBaseUrl } from '@/lib/config/apiBaseUrl';
import { ApiError } from '@/lib/api/base/ApiError';

export interface LeaderboardsData {
  drivers: { drivers: DriverLeaderboardItemDTO[] };
  teams: { teams: TeamListItemDTO[] };
}

export class LeaderboardsService implements Service {
  async getLeaderboards(): Promise<Result<LeaderboardsData, DomainError>> {
    try {
      const baseUrl = getWebsiteApiBaseUrl();
      const errorReporter = new ConsoleErrorReporter();
      const logger = new ConsoleLogger();
      
      const driversApiClient = new DriversApiClient(baseUrl, errorReporter, logger);
      const teamsApiClient = new TeamsApiClient(baseUrl, errorReporter, logger);
      
      const [driverResult, teamResult] = await Promise.all([
        driversApiClient.getLeaderboard(),
        teamsApiClient.getAll(),
      ]);
      
      if (!driverResult && !teamResult) {
        return Result.err({ type: 'notFound', message: 'No leaderboard data available' });
      }

      // Check if team ranking is needed but not provided by API
      // TeamListItemDTO does not have a rank field, so we cannot provide ranked team data
      if (teamResult && teamResult.teams.length > 0) {
        const hasRankField = teamResult.teams.some(team => 'rank' in team);
        if (!hasRankField) {
          return Result.err({ type: 'serverError', message: 'Team ranking not implemented' });
        }
      }

      const data: LeaderboardsData = {
        drivers: driverResult || { drivers: [] },
        teams: teamResult || { teams: [] },
      };
      
      return Result.ok(data);
    } catch (error) {
      // Convert ApiError to DomainError
      if (error instanceof ApiError) {
        switch (error.type) {
          case 'NOT_FOUND':
            return Result.err({ type: 'notFound', message: error.message });
          case 'AUTH_ERROR':
            return Result.err({ type: 'unauthorized', message: error.message });
          case 'SERVER_ERROR':
            return Result.err({ type: 'serverError', message: error.message });
          case 'NETWORK_ERROR':
          case 'TIMEOUT_ERROR':
            return Result.err({ type: 'networkError', message: error.message });
          default:
            return Result.err({ type: 'unknown', message: error.message });
        }
      }
      
      // Handle non-ApiError cases
      if (error instanceof Error) {
        return Result.err({ type: 'unknown', message: error.message });
      }
      
      return Result.err({ type: 'unknown', message: 'Leaderboards fetch failed' });
    }
  }
}