gridpilot.gg/packages/racing/application/use-cases/GetEntitySponsorshipPricingUseCase.ts

/**
 * Application Use Case: GetEntitySponsorshipPricingUseCase
 *
 * Retrieves sponsorship pricing configuration for any entity.
 * Used by sponsors to see available slots and prices.
 */

import type { ISponsorshipPricingRepository } from '../../domain/repositories/ISponsorshipPricingRepository';
import type { ISponsorshipRequestRepository } from '../../domain/repositories/ISponsorshipRequestRepository';
import type { ISeasonSponsorshipRepository } from '../../domain/repositories/ISeasonSponsorshipRepository';
import type { SponsorableEntityType } from '../../domain/entities/SponsorshipRequest';
import type { SponsorshipTier } from '../../domain/entities/SeasonSponsorship';
import type { IEntitySponsorshipPricingPresenter } from '../presenters/IEntitySponsorshipPricingPresenter';
import type { AsyncUseCase } from '@gridpilot/shared/application';
import type { ILogger } from '../../../shared/src/logging/ILogger';

export interface GetEntitySponsorshipPricingDTO {
  entityType: SponsorableEntityType;
  entityId: string;
}

export interface SponsorshipSlotDTO {
  tier: SponsorshipTier;
  price: number;
  currency: string;
  formattedPrice: string;
  benefits: string[];
  available: boolean;
  maxSlots: number;
  filledSlots: number;
  pendingRequests: number;
}

export interface GetEntitySponsorshipPricingResultDTO {
  entityType: SponsorableEntityType;
  entityId: string;
  acceptingApplications: boolean;
  customRequirements?: string;
  mainSlot?: SponsorshipSlotDTO;
  secondarySlot?: SponsorshipSlotDTO;
}

export class GetEntitySponsorshipPricingUseCase
  implements AsyncUseCase<GetEntitySponsorshipPricingDTO, void> {
  constructor(
    private readonly sponsorshipPricingRepo: ISponsorshipPricingRepository,
    private readonly sponsorshipRequestRepo: ISponsorshipRequestRepository,
    private readonly seasonSponsorshipRepo: ISeasonSponsorshipRepository,
    private readonly presenter: IEntitySponsorshipPricingPresenter,
    private readonly logger: ILogger,
  ) {}

  async execute(dto: GetEntitySponsorshipPricingDTO): Promise<void> {
    this.logger.debug(
      `Executing GetEntitySponsorshipPricingUseCase for entityType: ${dto.entityType}, entityId: ${dto.entityId}`,
      { dto },
    );

    try {
      const pricing = await this.sponsorshipPricingRepo.findByEntity(dto.entityType, dto.entityId);

      if (!pricing) {
        this.logger.warn(
          `No pricing found for entityType: ${dto.entityType}, entityId: ${dto.entityId}. Presenting null.`,
          { dto },
        );
        this.presenter.present(null);
        return;
      }

      this.logger.debug(`Found pricing for entityType: ${dto.entityType}, entityId: ${dto.entityId}`, { pricing });

      // Count pending requests by tier
      const pendingRequests = await this.sponsorshipRequestRepo.findPendingByEntity(
        dto.entityType,
        dto.entityId,
      );
      const pendingMainCount = pendingRequests.filter(r => r.tier === 'main').length;
      const pendingSecondaryCount = pendingRequests.filter(r => r.tier === 'secondary').length;

      this.logger.debug(
        `Pending requests counts: main=${pendingMainCount}, secondary=${pendingSecondaryCount}`,
      );

      // Count filled slots (for seasons, check SeasonSponsorship table)
      let filledMainSlots = 0;
      let filledSecondarySlots = 0;

      if (dto.entityType === 'season') {
        const sponsorships = await this.seasonSponsorshipRepo.findBySeasonId(dto.entityId);
        const activeSponsorships = sponsorships.filter(s => s.isActive());
        filledMainSlots = activeSponsorships.filter(s => s.tier === 'main').length;
        filledSecondarySlots = activeSponsorships.filter(s => s.tier === 'secondary').length;
        this.logger.debug(
          `Filled slots for season: main=${filledMainSlots}, secondary=${filledSecondarySlots}`,
        );
      }

      const result: GetEntitySponsorshipPricingResultDTO = {
        entityType: dto.entityType,
        entityId: dto.entityId,
        acceptingApplications: pricing.acceptingApplications,
        ...(pricing.customRequirements !== undefined
          ? { customRequirements: pricing.customRequirements }
          : {}),
      };

      if (pricing.mainSlot) {
        const mainMaxSlots = pricing.mainSlot.maxSlots;
        result.mainSlot = {
          tier: 'main',
          price: pricing.mainSlot.price.amount,
          currency: pricing.mainSlot.price.currency,
          formattedPrice: pricing.mainSlot.price.format(),
          benefits: pricing.mainSlot.benefits,
          available: pricing.mainSlot.available && filledMainSlots < mainMaxSlots,
          maxSlots: mainMaxSlots,
          filledSlots: filledMainSlots,
          pendingRequests: pendingMainCount,
        };
        this.logger.debug(`Main slot pricing information processed`, { mainSlot: result.mainSlot });
      }

      if (pricing.secondarySlots) {
        const secondaryMaxSlots = pricing.secondarySlots.maxSlots;
        result.secondarySlot = {
          tier: 'secondary',
          price: pricing.secondarySlots.price.amount,
          currency: pricing.secondarySlots.price.currency,
          formattedPrice: pricing.secondarySlots.price.format(),
          benefits: pricing.secondarySlots.benefits,
          available:
            pricing.secondarySlots.available && filledSecondarySlots < secondaryMaxSlots,
          maxSlots: secondaryMaxSlots,
          filledSlots: filledSecondarySlots,
          pendingRequests: pendingSecondaryCount,
        };
        this.logger.debug(`Secondary slot pricing information processed`, {
          secondarySlot: result.secondarySlot,
        });
      }

      this.logger.info(
        `Successfully retrieved and processed entity sponsorship pricing for entityType: ${dto.entityType}, entityId: ${dto.entityId}`,
        { result },
      );
      this.presenter.present(result);
    } catch (error: unknown) {
      let errorMessage = 'An unknown error occurred';
      if (error instanceof Error) {
        errorMessage = error.message;
      }
      this.logger.error(
        `Failed to get entity sponsorship pricing for entityType: ${dto.entityType}, entityId: ${dto.entityId}. Error: ${errorMessage}`,
        { error, dto },
      );
      // Re-throw the error or present an error state if the presenter supports it
      throw error;
    }
  }
}