import { Result } from '../../shared/result/Result';
import { ICheckoutService } from '../ports/ICheckoutService';
import { ICheckoutConfirmationPort } from '../ports/ICheckoutConfirmationPort';
import { CheckoutStateEnum } from '../../domain/value-objects/CheckoutState';

interface SessionMetadata {
  sessionName: string;
  trackId: string;
  carIds: string[];
}

export class ConfirmCheckoutUseCase {
  private static readonly DEFAULT_TIMEOUT_MS = 30000;

  constructor(
    private readonly checkoutService: ICheckoutService,
    private readonly confirmationPort: ICheckoutConfirmationPort
  ) {}

  async execute(sessionMetadata?: SessionMetadata): Promise<Result<void>> {
    const infoResult = await this.checkoutService.extractCheckoutInfo();
    
    if (infoResult.isErr()) {
      return Result.err(infoResult.unwrapErr());
    }

    const info = infoResult.unwrap();

    if (info.state.getValue() === CheckoutStateEnum.INSUFFICIENT_FUNDS) {
      return Result.err(new Error('Insufficient funds to complete checkout'));
    }

    if (!info.price) {
      return Result.err(new Error('Could not extract price from checkout page'));
    }

    // Request confirmation via port with full checkout context
    const confirmationResult = await this.confirmationPort.requestCheckoutConfirmation({
      price: info.price,
      state: info.state,
      sessionMetadata: sessionMetadata || {
        sessionName: 'Unknown Session',
        trackId: 'unknown',
        carIds: [],
      },
      timeoutMs: ConfirmCheckoutUseCase.DEFAULT_TIMEOUT_MS,
    });

    if (confirmationResult.isErr()) {
      return Result.err(confirmationResult.unwrapErr());
    }

    const confirmation = confirmationResult.unwrap();

    if (confirmation.isCancelled()) {
      return Result.err(new Error('Checkout cancelled by user'));
    }

    if (confirmation.isTimeout()) {
      return Result.err(new Error('Checkout confirmation timeout'));
    }

    return await this.checkoutService.proceedWithCheckout();
  }
}