edr-platform/apps/edr-freight-api/src/modules/contracts/contract-pricing.service.ts

import { Injectable } from '@nestjs/common';

import { RatesService } from '../rule-engine/services/rates.service';
import { ContainerTypesService } from '../rule-engine/services/container-types.service';
import { ExchangeService } from '@edr/api-common';
import { ContractsRepository } from './contracts.repository';
import { Contract } from './entities/contract.entity';

/** A single unit-rate line at contract phase — NO quantities, NO totals. */
export interface ContractUnitRateLineItem {
  code: string;
  label: string;
  unit: 'per_container' | 'per_ton' | 'per_item' | 'per_km' | 'flat';
  unitPrice: number;
  containerSize?: string | null;
  conditionalOn?: string | null;
  cargoTypeCode?: string | null;
}

/** The contract `pricing_breakdown` shape (doc §9.1). */
export interface ContractPricingBreakdown {
  displayMode: 'UNIT_RATES';
  currency: string;
  lineItems: ContractUnitRateLineItem[];
  generatedAt: string;
}

/** Map a rate's storage unit to the contract-display unit. */
function toContractUnit(rateUnit: string): ContractUnitRateLineItem['unit'] {
  switch (rateUnit) {
    case 'PER_TON':
      return 'per_ton';
    case 'PER_KM':
      return 'per_km';
    case 'PER_CONTAINER':
    case 'PER_WAGON':
      return 'per_container';
    default:
      return 'flat';
  }
}

@Injectable()
export class ContractPricingService {
  constructor(
    private readonly contractsRepository: ContractsRepository,
    private readonly ratesService: RatesService,
    private readonly containerTypesService: ContainerTypesService,
    private readonly exchangeService: ExchangeService,
  ) {}

  /** Base rail rate type for the contract's direction + freight. */
  private baseRateType(contract: Contract): string {
    const isBulk = contract.freightType === 'BULK';
    if (contract.tradeDirection === 'IMPORT') {
      return isBulk ? 'BULK_IMPORT' : 'CONTAINER_IMPORT';
    }
    if (contract.tradeDirection === 'EXPORT') {
      return isBulk ? 'BULK_EXPORT' : 'CONTAINER_EXPORT';
    }
    return isBulk ? 'INTERCITY_BULK' : 'INTERCITY_CONTAINER';
  }

  /**
   * Build the unit-rate breakdown from live rates. Emits per-unit prices only
   * (one per container size, conditional hazard/reefer surcharges, and bulk
   * commodity rate) — NO totals or quantities (doc §9.1).
   */
  async buildBreakdown(contract: Contract): Promise<ContractPricingBreakdown> {
    const liveRates = await this.ratesService.findLiveRates();
    const currency = contract.paymentCurrency;
    const isEtb = currency === 'ETB';
    const usdToEtb = isEtb ? await this.exchangeService.getRate('USD', 'ETB') : 1;
    const convert = (usd: number): number => (isEtb ? Math.round(usd * usdToEtb) : usd);

    const lineItems: ContractUnitRateLineItem[] = [];
    const baseType = this.baseRateType(contract);

    if (contract.freightType === 'CONTAINER') {
      const sizes = (contract.cargoScope ?? [])
        .map((c) => c.containerSize)
        .filter((s): s is string => !!s);
      const { data: containerTypes } = await this.containerTypesService.findAll({
        isActive: true,
        pageSize: 500,
      });
      for (const size of sizes) {
        const sizeFt = size === '40ft' ? 40 : 20;
        const matchedTypes = containerTypes.filter((ct) => ct.sizeFt === sizeFt);
        const matchedIds = new Set(matchedTypes.map((ct) => ct.id));
        const rate =
          liveRates.find(
            (r) =>
              r.rateType === baseType &&
              r.currency === 'USD' &&
              r.containerTypeId &&
              matchedIds.has(r.containerTypeId),
          ) ??
          liveRates.find(
            (r) => r.rateType === baseType && r.currency === 'USD' && !r.containerTypeId,
          );
        if (!rate) continue;
        lineItems.push({
          code: `CONTAINER_${size.toUpperCase()}`,
          label: `${size} container`,
          unit: toContractUnit(rate.rateUnit),
          unitPrice: convert(Number(rate.rateValue)),
          containerSize: size,
        });
      }
    } else {
      const bulkRate =
        liveRates.find((r) => r.rateType === baseType && r.currency === 'USD') ?? null;
      const cargoScope = (contract.cargoScope ?? []).find((c) => c.cargoTypeId);
      if (bulkRate) {
        lineItems.push({
          code: 'BULK_FREIGHT',
          label: cargoScope?.cargoType?.cargoTypeName ?? 'Bulk cargo',
          unit: toContractUnit(bulkRate.rateUnit),
          unitPrice: convert(Number(bulkRate.rateValue)),
          cargoTypeCode: cargoScope?.cargoType?.code ?? null,
        });
      }
    }

    // First / last mile trucking unit rates — shown when the contract carries
    // that leg. Per-unit prices only; the actual amount (× km / containers /
    // tons / flat) is computed at booking time.
    if (contract.firstMilePickupAddress) {
      const fm = liveRates.find(
        (r) => r.rateType === 'FIRST_MILE' && r.currency === 'USD',
      );
      if (fm && Number(fm.rateValue) > 0) {
        lineItems.push({
          code: 'FIRST_MILE',
          label: 'First mile (pick-up)',
          unit: toContractUnit(fm.rateUnit),
          unitPrice: convert(Number(fm.rateValue)),
        });
      }
    }
    if (contract.lastMileDeliveryAddress) {
      const lm = liveRates.find(
        (r) => r.rateType === 'LAST_MILE' && r.currency === 'USD',
      );
      if (lm && Number(lm.rateValue) > 0) {
        lineItems.push({
          code: 'LAST_MILE',
          label: 'Last mile (delivery)',
          unit: toContractUnit(lm.rateUnit),
          unitPrice: convert(Number(lm.rateValue)),
        });
      }
    }

    // Conditional surcharges — shown only when the contract toggles them on AND
    // the rate has a non-zero value (a 0 rate means "no surcharge").
    if (contract.isHazardous) {
      const hazard = liveRates.find(
        (r) => r.rateType === 'HAZARD_SURCHARGE' && r.currency === 'USD',
      );
      if (hazard && Number(hazard.rateValue) > 0) {
        lineItems.push({
          code: 'HAZARD_SURCHARGE',
          label: 'Hazardous surcharge',
          unit: toContractUnit(hazard.rateUnit),
          unitPrice: convert(Number(hazard.rateValue)),
          conditionalOn: 'is_hazardous',
        });
      }
    }
    if (contract.isReefer) {
      const reefer = liveRates.find(
        (r) => r.rateType === 'REEFER_SURCHARGE' && r.currency === 'USD',
      );
      if (reefer && Number(reefer.rateValue) > 0) {
        lineItems.push({
          code: 'REEFER_SURCHARGE',
          label: 'Reefer surcharge',
          unit: toContractUnit(reefer.rateUnit),
          unitPrice: convert(Number(reefer.rateValue)),
          conditionalOn: 'is_reefer',
        });
      }
    }

    return {
      displayMode: 'UNIT_RATES',
      currency,
      lineItems,
      generatedAt: new Date().toISOString(),
    };
  }

  /** Generate (and persist) the unit-rate breakdown for a contract. */
  async generatePrice(contractId: string): Promise<ContractPricingBreakdown> {
    const contract = await this.contractsRepository.findByIdWithRelations(contractId);
    if (!contract) {
      throw new Error(`Contract ${contractId} not found`);
    }
    const breakdown = await this.buildBreakdown(contract);
    await this.contractsRepository.update(contractId, {
      pricingBreakdown: breakdown as never,
      pricingDisplayMode: 'UNIT_RATES',
    } as never);
    return breakdown;
  }

  /**
   * Freeze the contract's unit rates into contract_rate_snapshots (one row per
   * rate line) at submit time. The booking later computes totals from these.
   */
  async freezeRateSnapshots(contractId: string): Promise<void> {
    const contract = await this.contractsRepository.findByIdWithRelations(contractId);
    if (!contract) return;
    const breakdown =
      (contract.pricingBreakdown as ContractPricingBreakdown | null) ??
      (await this.buildBreakdown(contract));

    await this.contractsRepository.clearRateSnapshots(contractId);
    for (const line of breakdown.lineItems) {
      await this.contractsRepository.createRateSnapshot({
        contractId,
        rateCode: line.code,
        description: line.label,
        unitPrice: line.unitPrice,
        unitOfMeasure: line.unit,
        currency: breakdown.currency,
        containerSize: line.containerSize ?? null,
        isSurcharge: !!line.conditionalOn,
        conditionalOn: line.conditionalOn ?? null,
      });
    }
  }
}