gridpilot.gg/apps/website/lib/services/races/RacesService.ts

import { RacesApiClient } from '@/lib/api/races/RacesApiClient';
import { Result } from '@/lib/contracts/Result';
import { DomainError } from '@/lib/contracts/services/Service';
import { ConsoleLogger } from '@/lib/infrastructure/logging/ConsoleLogger';
import { ConsoleErrorReporter } from '@/lib/infrastructure/logging/ConsoleErrorReporter';
import { getWebsiteApiBaseUrl } from '@/lib/config/apiBaseUrl';
import { ApiError } from '@/lib/api/base/ApiError';

/**
 * Races Service
 * 
 * Orchestration service for race-related operations.
 * Returns raw API DTOs. No ViewModels or UX logic.
 */
export class RacesService {
  private apiClient: RacesApiClient;

  constructor() {
    // Service creates its own dependencies
    const baseUrl = getWebsiteApiBaseUrl();
    const logger = new ConsoleLogger();
    const errorReporter = new ConsoleErrorReporter();
    
    this.apiClient = new RacesApiClient(baseUrl, errorReporter, logger);
  }

  /**
   * Get races page data
   * Returns races for the main races page
   */
  async getRacesPageData(): Promise<Result<any, DomainError>> {
    try {
      const data = await this.apiClient.getPageData();
      return Result.ok(data);
    } catch (error) {
      if (error instanceof ApiError) {
        return Result.err({
          type: this.mapApiErrorType(error.type),
          message: error.message
        });
      }
      return Result.err({
        type: 'unknown',
        message: 'Failed to fetch races page data'
      });
    }
  }

  /**
   * Get race detail
   * Returns detailed information for a specific race
   */
  async getRaceDetail(raceId: string, driverId: string): Promise<Result<any, DomainError>> {
    try {
      const data = await this.apiClient.getDetail(raceId, driverId);
      return Result.ok(data);
    } catch (error) {
      if (error instanceof ApiError) {
        return Result.err({
          type: this.mapApiErrorType(error.type),
          message: error.message
        });
      }
      return Result.err({
        type: 'unknown',
        message: 'Failed to fetch race detail'
      });
    }
  }

  /**
   * Get race results detail
   * Returns results for a specific race
   */
  async getRaceResultsDetail(raceId: string): Promise<Result<any, DomainError>> {
    try {
      const data = await this.apiClient.getResultsDetail(raceId);
      return Result.ok(data);
    } catch (error) {
      if (error instanceof ApiError) {
        return Result.err({
          type: this.mapApiErrorType(error.type),
          message: error.message
        });
      }
      return Result.err({
        type: 'unknown',
        message: 'Failed to fetch race results'
      });
    }
  }

  /**
   * Get race with strength of field
   * Returns race data with SOF calculation
   */
  async getRaceWithSOF(raceId: string): Promise<Result<any, DomainError>> {
    try {
      const data = await this.apiClient.getWithSOF(raceId);
      return Result.ok(data);
    } catch (error) {
      if (error instanceof ApiError) {
        return Result.err({
          type: this.mapApiErrorType(error.type),
          message: error.message
        });
      }
      return Result.err({
        type: 'unknown',
        message: 'Failed to fetch race SOF'
      });
    }
  }

  /**
   * Get all races for the all races page
   * Returns all races with pagination support
   */
  async getAllRacesPageData(): Promise<Result<any, DomainError>> {
    try {
      const data = await this.apiClient.getPageData();
      return Result.ok(data);
    } catch (error) {
      if (error instanceof ApiError) {
        return Result.err({
          type: this.mapApiErrorType(error.type),
          message: error.message
        });
      }
      return Result.err({
        type: 'unknown',
        message: 'Failed to fetch all races'
      });
    }
  }

  private mapApiErrorType(apiErrorType: string): DomainError['type'] {
    switch (apiErrorType) {
      case 'NOT_FOUND':
        return 'notFound';
      case 'AUTH_ERROR':
        return 'unauthorized';
      case 'VALIDATION_ERROR':
        return 'validation';
      case 'SERVER_ERROR':
        return 'serverError';
      case 'NETWORK_ERROR':
        return 'networkError';
      default:
        return 'unknown';
    }
  }
}