import { CompanyPolicyBuilder } from './policy-builder';
import type {
  CompanyLeaveProgramContext,
  Duration,
  DurationExpression,
  EvidenceRequirement,
  FactRef,
  ParentalRelationship,
  PolicyCondition,
  TenureMatchTier,
  WageReplacementRef,
} from './types';

function fact(path: string): FactRef {
  return { kind: 'fact_ref', path };
}

function isEvidenceRequirement(value: Duration | EvidenceRequirement): value is EvidenceRequirement {
  return 'key' in value;
}

export function createCompanyLeaveProgramContext(): CompanyLeaveProgramContext {
  return {
    employee: {
      country: {
        is(country: string): PolicyCondition {
          return { type: 'employee_country_is', country };
        },
      },
      tenure: {
        monthsAt(asOf: FactRef) {
          return {
            match(tiers: TenureMatchTier[]): DurationExpression {
              return {
                type: 'tenure_months_duration',
                tiers: tiers.map((tier) => ({ ...tier })),
              };
            },
          };
        },
      },
    },
    leave: {
      reason: {
        isParental(): PolicyCondition {
          return { type: 'leave_reason_is_parental' };
        },
        isOneOf(values: string[]): PolicyCondition {
          return { type: 'leave_reason_in', values: [...values] };
        },
      },
      startDate: fact('leave.startDate'),
      parentalRelationship: {
        match(cases): DurationExpression {
          const durationCases: Partial<Record<ParentalRelationship, Duration>> = {};
          let unknown: EvidenceRequirement | undefined;

          for (const [relationship, value] of Object.entries(cases)) {
            if (value === undefined) {
              continue;
            }
            if (relationship === 'unknown') {
              if (isEvidenceRequirement(value)) {
                unknown = value;
              }
              continue;
            }
            if (!isEvidenceRequirement(value)) {
              durationCases[relationship as ParentalRelationship] = value;
            }
          }

          return {
            type: 'parental_relationship_duration',
            cases: durationCases,
            ...(unknown === undefined ? {} : { unknown }),
          };
        },
      },
    },
    pay: {
      contractualWeeklyPay: fact('pay.contractualWeeklyPay'),
    },
    programs: {
      wageReplacement(programCodes: string[]): WageReplacementRef {
        return { kind: 'wage_replacement_ref', programCodes: [...programCodes] };
      },
    },
    evidence: {
      require(key: string, message?: string): EvidenceRequirement {
        return {
          key,
          ...(message === undefined ? {} : { message }),
        };
      },
    },
    policy() {
      return new CompanyPolicyBuilder();
    },
  };
}