import type { PaymentsApiClient } from '../../api/payments/PaymentsApiClient';
import type { PaymentDto, MembershipFeeDto, PrizeDto } from '../../types/generated';

// TODO: Move these types to apps/website/lib/types/generated when available
type CreatePaymentInputDto = { amount: number; leagueId: string; driverId: string; description: string };
type CreatePaymentOutputDto = { id: string; success: boolean };
import {
  PaymentViewModel,
  MembershipFeeViewModel,
  PrizeViewModel,
  WalletViewModel,
} from '../../view-models';

/**
 * Payment Service
 *
 * Orchestrates payment operations by coordinating API calls and view model creation.
 * All dependencies are injected via constructor.
 */
export class PaymentService {
  constructor(
    private readonly apiClient: PaymentsApiClient
  ) {}

  /**
   * Get all payments with optional filters
   */
  async getPayments(leagueId?: string, driverId?: string): Promise<PaymentViewModel[]> {
    const dto = await this.apiClient.getPayments(leagueId, driverId);
    return dto.payments.map((payment: PaymentDto) => new PaymentViewModel(payment));
  }

  /**
   * Get single payment by ID
   */
  async getPayment(paymentId: string): Promise<PaymentViewModel> {
    // Note: Assuming the API returns a single payment from the list
    const dto = await this.apiClient.getPayments();
    const payment = dto.payments.find((p: PaymentDto) => p.id === paymentId);
    if (!payment) {
      throw new Error(`Payment with ID ${paymentId} not found`);
    }
    return new PaymentViewModel(payment);
  }

  /**
   * Create a new payment
   */
  async createPayment(input: CreatePaymentInputDto): Promise<CreatePaymentOutputDto> {
    return await this.apiClient.createPayment(input);
  }

  /**
   * Get membership fees for a league
   */
  async getMembershipFees(leagueId: string): Promise<MembershipFeeViewModel[]> {
    const dto = await this.apiClient.getMembershipFees(leagueId);
    return dto.fees.map((fee: MembershipFeeDto) => new MembershipFeeViewModel(fee));
  }

  /**
   * Get prizes with optional filters
   */
  async getPrizes(leagueId?: string, seasonId?: string): Promise<PrizeViewModel[]> {
    const dto = await this.apiClient.getPrizes(leagueId, seasonId);
    return dto.prizes.map((prize: PrizeDto) => new PrizeViewModel(prize));
  }

  /**
   * Get wallet for a driver
   */
  async getWallet(driverId: string): Promise<WalletViewModel> {
    const dto = await this.apiClient.getWallet(driverId);
    return new WalletViewModel(dto);
  }

  /**
   * Process a payment (alias for createPayment)
   */
  async processPayment(input: CreatePaymentInputDto): Promise<CreatePaymentOutputDto> {
    return await this.createPayment(input);
  }

  /**
   * Get payment history for a user (driver)
   */
  async getPaymentHistory(driverId: string): Promise<PaymentViewModel[]> {
    return await this.getPayments(undefined, driverId);
  }
}