import { injectable } from 'inversify';
import { RacesApiClient } from '@/lib/api/races/RacesApiClient';
import { Result } from '@/lib/contracts/Result';
import { DomainError, Service } 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';

/**
 * Race Service - DTO Only
 *
 * Returns raw API DTOs. No ViewModels or UX logic.
 * All client-side presentation logic must be handled by hooks/components.
 */
@injectable()
export class RaceService implements Service {
  private apiClient: RacesApiClient;

  constructor() {
    const baseUrl = getWebsiteApiBaseUrl();
    const logger = new ConsoleLogger();
    const errorReporter = new ConsoleErrorReporter();
    this.apiClient = new RacesApiClient(baseUrl, errorReporter, logger);
  }

  async getRaceById(raceId: string): Promise<Result<unknown, DomainError>> {
    try {
      // This would need a driverId, but for now we'll use a placeholder
      const data = await this.apiClient.getDetail(raceId, 'placeholder-driver-id');
      return Result.ok(data);
    } catch (error: unknown) {
      return Result.err(this.mapError(error, 'Failed to fetch race by ID'));
    }
  }

  async getRacesByLeagueId(leagueId: string): Promise<Result<unknown, DomainError>> {
    try {
      const data = await this.apiClient.getPageData(leagueId);
      return Result.ok(data);
    } catch (error: unknown) {
      return Result.err(this.mapError(error, 'Failed to fetch races by league ID'));
    }
  }

  async getAllRacesPageData(): Promise<Result<any, DomainError>> {
    try {
      const data = await this.apiClient.getPageData();
      return Result.ok(data);
    } catch (error: unknown) {
      return Result.err(this.mapError(error, 'Failed to fetch all races page data'));
    }
  }

  async findByLeagueId(leagueId: string): Promise<Result<unknown[], DomainError>> {
    try {
      const result = await this.apiClient.getPageData(leagueId);
      return Result.ok(result.races || []);
    } catch (error: unknown) {
      return Result.err(this.mapError(error, 'Failed to find races by league ID'));
    }
  }

  async registerForRace(_: string, __: string, ___: string): Promise<Result<void, DomainError>> {
    return Result.err({ type: 'notImplemented', message: 'registerForRace' });
  }

  async withdrawFromRace(_: string, __: string): Promise<Result<void, DomainError>> {
    return Result.err({ type: 'notImplemented', message: 'withdrawFromRace' });
  }

  async fileProtest(__: unknown): Promise<Result<void, DomainError>> {
    return Result.err({ type: 'notImplemented', message: 'fileProtest' });
  }

  private mapError(error: unknown, defaultMessage: string): DomainError {
    if (error instanceof ApiError) {
      return {
        type: this.mapApiErrorType(error.type),
        message: error.message
      };
    }
    return {
      type: 'unknown',
      message: defaultMessage
    };
  }

  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';
    }
  }
}
