1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

/**
 * RateConfiguration - defines pricing for a room type
 * This is the starting point for all rate calculations
 */
interface RateConfiguration {
    roomTypeId: RoomTypeId;
    rackRate: Money;                    // Maximum base rate
    seasonalRates: SeasonalRate[];
    dayOfWeekModifiers: DayOfWeekModifier[];
    lengthOfStayDiscounts: LOSDiscount[];
}
 
interface SeasonalRate {
    seasonCode: string;              // 'PEAK', 'SHOULDER', 'LOW'
    dateRanges: DateRange[];         // When this season applies
    modifier: RateModifier;          // Percentage or fixed amount
}
 
interface DayOfWeekModifier {
    daysOfWeek: DayOfWeek[];         // FRIDAY, SATURDAY, etc.
    modifier: RateModifier;          // Typically premium for weekends
}
 
interface LOSDiscount {
    minimumNights: number;           // 3, 7, 14 nights, etc.
    discount: RateModifier;          // Usually percentage discount
    applicableTo: 'ALL_NIGHTS' | 'EXTRA_NIGHTS_ONLY';
}
 
/**
 * Rate modifier - can be percentage or fixed amount
 */
interface RateModifier {
    type: 'PERCENTAGE' | 'FIXED_AMOUNT' | 'FIXED_RATE';
    value: number;                   // Percentage: 1.2 = 20% increase
                                     // Fixed rate: absolute value
    direction: 'INCREASE' | 'DECREASE'; // For clarity, though sign in value works
}
 
// Example: Peak weekend rate with length-of-stay discount
// Rack rate: $200
// Peak season: +20% → $240
// Weekend: +10% → $264
// 7+ night stay: -15% → $224.40 per night

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

/**
 * RatePlan entity - named pricing configuration with terms
 */
class RatePlan {
    private readonly id: RatePlanId;
    private readonly hotelId: HotelId;
    private code: string;                    // e.g., "BAR", "ADVANCE21", "AAA"
    private name: string;                    // Display name
    private description: string;
    
    // Pricing
    private baseRateModifier: RateModifier;  // Applied to calculated base rate
    private includedMeals: MealPlan;         // BB, HB, FB, RO (room only)
    private includedExtras: IncludedExtra[]; // Parking, WiFi, etc.
    
    // Availability restrictions
    private bookableChannels: BookingChannel[];  // Where this rate is visible
    private validDateRanges: DateRange[];        // When rate plan is active
    private blackoutDates: LocalDate[];          // Dates where not available
    
    // Booking restrictions
    private advanceBookingRequirement: AdvanceBookingRule | null;
    private minimumStay: number;                 // Minimum nights
    private maximumStay: number | null;          // Maximum nights
    private closedToArrival: DayOfWeek[];        // Cannot arrive on these days
    private closedToDeparture: DayOfWeek[];      // Cannot depart on these days
    
    // Guest restrictions
    private requiredMembership: MembershipType | null;
    private requiredLoyaltyTier: LoyaltyTier | null;
    private guestVerificationRequired: boolean;  // Check ID at arrival
    
    // Terms
    private cancellationPolicyId: CancellationPolicyId;
    private prepaymentRequired: boolean;
    private prepaymentPercentage: number;        // 0-100
    private guaranteeRequired: boolean;
    
    // Status
    private isActive: boolean;
    private displayPriority: number;             // Order in search results
    
    constructor(params: RatePlanCreationParams) {
        this.validate(params);
        // ... initialization
    }
    
    // ============ Eligibility Methods ============
    
    /**
     * Check if this rate plan is available for a booking
     */
    isAvailableFor(context: BookingContext): boolean {
        return (
            this.isActive &&
            this.isWithinValidDates(context.stayDates) &&
            this.meetsAdvanceBookingRequirement(context.bookingDate) &&
            this.meetsStayLengthRequirement(context.nights) &&
            this.isAvailableOnChannel(context.channel) &&
            this.meetsGuestRequirements(context.guest) &&
            !this.hasBlackoutConflict(context.stayDates)
        );
    }
    
    private meetsAdvanceBookingRequirement(bookingDate: LocalDate): boolean {
        if (!this.advanceBookingRequirement) return true;
        
        const daysInAdvance = bookingDate.until(
            this.advanceBookingRequirement.checkInDate, 
            ChronoUnit.DAYS
        );
        
        return daysInAdvance >= this.advanceBookingRequirement.minimumDays;
    }
    
    private meetsStayLengthRequirement(nights: number): boolean {
        if (nights < this.minimumStay) return false;
        if (this.maximumStay && nights > this.maximumStay) return false;
        return true;
    }
    
    private hasBlackoutConflict(stayDates: DateRange): boolean {
        return this.blackoutDates.some(blackout => 
            stayDates.contains(blackout)
        );
    }
    
    // ============ Pricing Methods ============
    
    /**
     * Apply this rate plan's modifier to base rate
     */
    applyToBaseRate(baseRate: Money): Money {
        return this.baseRateModifier.apply(baseRate);
    }
    
    /**
     * Get effective cancellation policy for this rate plan
     */
    getCancellationPolicy(): CancellationPolicy {
        return CancellationPolicyRepository.findById(
            this.cancellationPolicyId
        );
    }
    
    // ============ Query Methods ============
    
    isPrepaid(): boolean {
        return this.prepaymentRequired && this.prepaymentPercentage === 100;
    }
    
    isRefundable(): boolean {
        const policy = this.getCancellationPolicy();
        return policy.allowsAnyCancellation();
    }
}
 
interface AdvanceBookingRule {
    minimumDays: number;      // Book at least N days before check-in
    maximumDays: number;      // Book no more than N days before
    checkInDate: LocalDate;   // Reference date for calculation
}
 
interface IncludedExtra {
    type: ExtraType;          // PARKING, WIFI, BREAKFAST, GYM
    description: string;
    monetaryValue: Money;     // For display purposes
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198

/**
 * PricingEngine - calculates final rate for a stay
 * Orchestrates all pricing components and modifiers
 */
class PricingEngine {
    private readonly rateRepository: RateRepository;
    private readonly promotionEngine: PromotionEngine;
    private readonly taxCalculator: TaxCalculator;
    private readonly demandAnalyzer: DemandAnalyzer;
    
    constructor(dependencies: PricingEngineDependencies) {
        this.rateRepository = dependencies.rateRepository;
        this.promotionEngine = dependencies.promotionEngine;
        this.taxCalculator = dependencies.taxCalculator;
        this.demandAnalyzer = dependencies.demandAnalyzer;
    }
    
    /**
     * Calculate complete pricing for a potential booking
     */
    calculatePricing(request: PricingRequest): PricingResult {
        const nightlyBreakdown: NightlyRate[] = [];
        let subtotal = Money.zero();
        
        // Calculate rate for each night
        for (const night of request.stayDates.eachNight()) {
            const nightRate = this.calculateNightRate(request, night);
            nightlyBreakdown.push(nightRate);
            subtotal = subtotal.add(nightRate.totalBeforeTax);
        }
        
        // Apply promotions to the total
        const promotionResult = this.promotionEngine.apply(
            subtotal,
            request.promoCode,
            request.context
        );
        
        // Calculate taxes on post-promotion amount
        const taxableAmount = promotionResult.finalAmount;
        const taxes = this.taxCalculator.calculate(
            taxableAmount,
            request.hotel.address,
            request.stayDates
        );
        
        // Add fixed fees
        const fees = this.calculateFees(request);
        
        return new PricingResult({
            nightlyBreakdown,
            roomSubtotal: subtotal,
            promotionDiscount: promotionResult.discountAmount,
            promotionsApplied: promotionResult.appliedPromotions,
            subtotalAfterPromotion: promotionResult.finalAmount,
            taxes,
            fees,
            grandTotal: promotionResult.finalAmount
                .add(taxes.totalTax)
                .add(fees.totalFees),
            currency: request.currency,
        });
    }
    
    /**
     * Calculate rate for a single night
     */
    private calculateNightRate(
        request: PricingRequest,
        night: LocalDate
    ): NightlyRate {
        // 1. Get base rate for room type
        const rackRate = request.roomType.rackRate;
        
        // 2. Apply seasonal modifier
        const seasonModifier = this.rateRepository.getSeasonalModifier(
            request.roomType.id,
            night
        );
        let rate = seasonModifier.apply(rackRate);
        
        // 3. Apply day-of-week modifier
        const dowModifier = this.rateRepository.getDayOfWeekModifier(
            request.roomType.id,
            night.dayOfWeek
        );
        rate = dowModifier.apply(rate);
        
        // 4. Check for specific date override (events, holidays)
        const dateOverride = this.rateRepository.getDateOverride(
            request.roomType.id,
            night
        );
        if (dateOverride) {
            rate = dateOverride.rate;
        }
        
        // 5. Apply dynamic pricing adjustment based on demand
        const demandMultiplier = this.demandAnalyzer.getMultiplier(
            request.roomType.id,
            night,
            request.hotel.id
        );
        rate = rate.multiply(demandMultiplier);
        
        // 6. Apply rate plan modifier
        rate = request.ratePlan.applyToBaseRate(rate);
        
        // 7. Apply length-of-stay discount
        const losDiscount = this.getLengthOfStayDiscount(
            request.roomType.id,
            request.nights
        );
        rate = losDiscount.apply(rate);
        
        // 8. Calculate extra person charges
        const extraPersonCharge = request.roomType.calculateExtraPersonCharge(
            request.adults,
            request.children,
            this.getExtraPersonRates(request.roomType.id)
        );
        
        return new NightlyRate({
            date: night,
            baseRate: rackRate,
            adjustedRate: rate,
            extraPersonCharge,
            totalBeforeTax: rate.add(extraPersonCharge),
            modifiersApplied: [
                seasonModifier,
                dowModifier,
                demandMultiplier,
                losDiscount,
            ].filter(m => !m.isIdentity()),
        });
    }
    
    /**
     * Calculate fixed fees (resort fee, parking, etc.)
     */
    private calculateFees(request: PricingRequest): FeeBreakdown {
        const fees: Fee[] = [];
        
        // Resort/Amenity fee (per night)
        const resortFee = this.rateRepository.getResortFee(request.hotel.id);
        if (resortFee) {
            fees.push(new Fee({
                type: FeeType.RESORT_FEE,
                amount: resortFee.multiply(request.nights),
                description: 'Resort amenity fee',
                taxable: true,
            }));
        }
        
        // Parking (if selected)
        if (request.parkingRequested) {
            const parkingRate = this.rateRepository.getParkingRate(
                request.hotel.id,
                request.parkingType
            );
            fees.push(new Fee({
                type: FeeType.PARKING,
                amount: parkingRate.multiply(request.nights),
                description: `${request.parkingType} parking`,
                taxable: true,
            }));
        }
        
        // Pet fee (if applicable)
        if (request.hasPets) {
            const petFee = this.rateRepository.getPetFee(request.hotel.id);
            fees.push(new Fee({
                type: FeeType.PET_FEE,
                amount: petFee,  // Usually one-time fee
                description: 'Pet accommodation fee',
                taxable: false,
            }));
        }
        
        return new FeeBreakdown(fees);
    }
}
 
interface PricingRequest {
    hotel: Hotel;
    roomType: RoomType;
    ratePlan: RatePlan;
    stayDates: DateRange;
    nights: number;
    adults: number;
    children: number;
    promoCode: string | null;
    currency: Currency;
    parkingRequested: boolean;
    parkingType: 'SELF' | 'VALET';
    hasPets: boolean;
    context: BookingContext;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210

/**
 * Promotion entity - temporary pricing offer
 */
class Promotion {
    private readonly id: PromotionId;
    private code: string;                    // User-facing code: "SUMMER25"
    private name: string;
    private description: string;
    
    // Discount definition
    private discountType: DiscountType;
    private discountValue: number;           // Amount or percentage
    private maximumDiscount: Money | null;   // Cap for percentage discounts
    
    // Validity
    private bookingValidFrom: Instant;       // When promo can be used
    private bookingValidUntil: Instant;
    private stayValidFrom: LocalDate;        // When stay must occur
    private stayValidUntil: LocalDate;
    
    // Restrictions
    private applicableRoomTypes: RoomTypeId[] | 'ALL';
    private applicableRatePlans: RatePlanId[] | 'ALL';
    private minimumStay: number;
    private minimumSpend: Money | null;
    private applicableChannels: BookingChannel[];
    
    // Usage limits
    private totalUsageLimit: number | null;  // Max total uses
    private currentUsageCount: number;
    private perGuestLimit: number | null;    // Max uses per guest
    
    // Stacking rules
    private stackable: boolean;              // Can combine with other promos
    private stackPriority: number;           // Order when stacking
    
    // Target audience
    private loyaltyTierRequired: LoyaltyTier | null;
    private newGuestOnly: boolean;
    private returningGuestOnly: boolean;
    
    constructor(params: PromotionCreationParams) {
        this.validate(params);
        // ... initialization
    }
    
    // ============ Eligibility Methods ============
    
    isApplicable(context: PromotionContext): PromotionEligibility {
        const checks: EligibilityCheck[] = [];
        
        // Time-based checks
        checks.push(this.checkBookingWindow(context.bookingTime));
        checks.push(this.checkStayWindow(context.stayDates));
        
        // Room/rate checks
        checks.push(this.checkRoomTypeApplicability(context.roomTypeId));
        checks.push(this.checkRatePlanApplicability(context.ratePlanId));
        
        // Stay requirement checks
        checks.push(this.checkMinimumStay(context.nights));
        checks.push(this.checkMinimumSpend(context.subtotal));
        
        // Guest checks
        checks.push(this.checkLoyaltyRequirement(context.guest));
        checks.push(this.checkNewGuestRequirement(context.guest));
        checks.push(this.checkPerGuestLimit(context.guest));
        
        // Usage checks
        checks.push(this.checkTotalUsageLimit());
        
        const failedCheck = checks.find(c => !c.passed);
        if (failedCheck) {
            return PromotionEligibility.ineligible(failedCheck.reason);
        }
        
        return PromotionEligibility.eligible();
    }
    
    private checkTotalUsageLimit(): EligibilityCheck {
        if (!this.totalUsageLimit) {
            return { passed: true };
        }
        
        if (this.currentUsageCount >= this.totalUsageLimit) {
            return {
                passed: false,
                reason: 'Promotion has reached its usage limit',
            };
        }
        
        return { passed: true };
    }
    
    // ============ Discount Calculation ============
    
    calculateDiscount(subtotal: Money): DiscountResult {
        let discount: Money;
        
        switch (this.discountType) {
            case DiscountType.PERCENTAGE:
                discount = subtotal.multiply(this.discountValue / 100);
                break;
            case DiscountType.FIXED_AMOUNT:
                discount = Money.of(this.discountValue, subtotal.currency);
                break;
            case DiscountType.FIXED_PRICE_PER_NIGHT:
                // Handled differently - replaces rate
                throw new Error('Fixed price promos handled at night level');
            default:
                discount = Money.zero();
        }
        
        // Apply maximum cap
        if (this.maximumDiscount && discount.isGreaterThan(this.maximumDiscount)) {
            discount = this.maximumDiscount;
        }
        
        // Cannot discount more than subtotal
        if (discount.isGreaterThan(subtotal)) {
            discount = subtotal;
        }
        
        return new DiscountResult({
            promotionId: this.id,
            promotionCode: this.code,
            originalAmount: subtotal,
            discountAmount: discount,
            finalAmount: subtotal.subtract(discount),
        });
    }
    
    // ============ Usage Tracking ============
    
    recordUsage(reservationId: ReservationId): void {
        this.currentUsageCount += 1;
        // Would also record in usage history for per-guest tracking
    }
}
 
enum DiscountType {
    PERCENTAGE = 'PERCENTAGE',
    FIXED_AMOUNT = 'FIXED_AMOUNT',
    FIXED_PRICE_PER_NIGHT = 'FIXED_PRICE_PER_NIGHT',
    FREE_NIGHT = 'FREE_NIGHT',  // Stay 4 nights, pay for 3
    FREE_UPGRADE = 'FREE_UPGRADE',
}
 
/**
 * PromotionEngine - orchestrates promotion evaluation and stacking
 */
class PromotionEngine {
    private readonly promotionRepository: PromotionRepository;
    
    /**
     * Apply promotion(s) to a booking subtotal
     */
    apply(
        subtotal: Money,
        promoCode: string | null,
        context: PromotionContext
    ): PromotionApplicationResult {
        const appliedPromotions: AppliedPromotion[] = [];
        let currentAmount = subtotal;
        
        // 1. Find explicitly requested promotion
        if (promoCode) {
            const promotion = this.promotionRepository.findByCode(promoCode);
            if (!promotion) {
                throw new InvalidPromotionCodeError(promoCode);
            }
            
            const eligibility = promotion.isApplicable(context);
            if (!eligibility.eligible) {
                throw new PromotionNotApplicableError(
                    promoCode, 
                    eligibility.reason
                );
            }
            
            const result = promotion.calculateDiscount(currentAmount);
            currentAmount = result.finalAmount;
            appliedPromotions.push(result.toAppliedPromotion());
        }
        
        // 2. Find and apply automatic promotions (member benefits, etc.)
        const autoPromotions = this.promotionRepository
            .findAutoApplyPromotions()
            .filter(p => p.isApplicable(context).eligible)
            .sort((a, b) => b.stackPriority - a.stackPriority);
        
        for (const promo of autoPromotions) {
            // Check stacking rules
            if (!promo.stackable && appliedPromotions.length > 0) {
                continue;
            }
            
            const result = promo.calculateDiscount(currentAmount);
            currentAmount = result.finalAmount;
            appliedPromotions.push(result.toAppliedPromotion());
        }
        
        return new PromotionApplicationResult({
            originalAmount: subtotal,
            finalAmount: currentAmount,
            discountAmount: subtotal.subtract(currentAmount),
            appliedPromotions,
        });
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

/**
 * TaxCalculator - handles complex multi-jurisdiction tax calculations
 */
class TaxCalculator {
    private readonly taxRateRepository: TaxRateRepository;
    
    /**
     * Calculate all applicable taxes for a hotel stay
     */
    calculate(
        taxableAmount: Money,
        hotelAddress: Address,
        stayDates: DateRange
    ): TaxBreakdown {
        const applicableTaxes: TaxLineItem[] = [];
        
        // Get tax rates for this jurisdiction and date range
        // Tax rates can change! Must use rates valid during the stay
        const taxRates = this.taxRateRepository.getRatesFor(
            hotelAddress.country,
            hotelAddress.state,
            hotelAddress.city,
            stayDates
        );
        
        // Apply each tax type
        for (const rate of taxRates) {
            // Check if tax applies to this amount type
            if (!rate.appliesTo.includes(TaxableType.ROOM_CHARGE)) {
                continue;
            }
            
            // Check for exemptions (long stays often exempt from tourism tax)
            if (this.isExempt(rate, stayDates.nights)) {
                continue;
            }
            
            const taxAmount = this.calculateTaxAmount(
                taxableAmount,
                rate,
                stayDates.nights
            );
            
            applicableTaxes.push(new TaxLineItem({
                taxType: rate.taxType,
                taxName: rate.displayName,
                rate: rate.rate,
                rateType: rate.rateType,  // PERCENTAGE or PER_NIGHT
                taxableAmount: taxableAmount,
                calculatedTax: taxAmount,
                jurisdictionCode: rate.jurisdictionCode,
            }));
        }
        
        const totalTax = applicableTaxes.reduce(
            (sum, item) => sum.add(item.calculatedTax),
            Money.zero()
        );
        
        return new TaxBreakdown({
            lineItems: applicableTaxes,
            totalTax,
        });
    }
    
    private calculateTaxAmount(
        taxableAmount: Money,
        rate: TaxRate,
        nights: number
    ): Money {
        switch (rate.rateType) {
            case TaxRateType.PERCENTAGE:
                return taxableAmount.multiply(rate.rate / 100);
                
            case TaxRateType.PER_NIGHT:
                return Money.of(rate.rate, taxableAmount.currency)
                    .multiply(nights);
                
            case TaxRateType.PER_ROOM_PER_NIGHT:
                // Would need room count from context
                return Money.of(rate.rate, taxableAmount.currency)
                    .multiply(nights);
                
            default:
                throw new UnknownTaxRateTypeError(rate.rateType);
        }
    }
    
    private isExempt(rate: TaxRate, nights: number): boolean {
        // Common exemption: extended stays (30+ nights) exempt from tourism tax
        if (rate.exemptAfterNights && nights >= rate.exemptAfterNights) {
            return true;
        }
        
        return false;
    }
}
 
interface TaxRate {
    taxType: TaxType;
    displayName: string;
    rate: number;
    rateType: TaxRateType;
    appliesTo: TaxableType[];
    jurisdictionCode: string;
    effectiveFrom: LocalDate;
    effectiveUntil: LocalDate | null;
    exemptAfterNights: number | null;
}
 
enum TaxType {
    SALES = 'SALES',
    OCCUPANCY = 'OCCUPANCY',
    TOURISM = 'TOURISM',
    CONVENTION = 'CONVENTION',
    CITY = 'CITY',
    VAT = 'VAT',
}
 
enum TaxableType {
    ROOM_CHARGE = 'ROOM_CHARGE',
    RESORT_FEE = 'RESORT_FEE',
    PARKING = 'PARKING',
    F_AND_B = 'F_AND_B',  // Food and beverage
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

/**
 * RepricingService - handles pricing recalculation for modifications
 */
class RepricingService {
    private readonly pricingEngine: PricingEngine;
    private readonly repricePolicy: RepricingPolicy;
    
    /**
     * Calculate pricing impact of a date modification
     */
    calculateDateModificationPricing(
        reservation: Reservation,
        newCheckIn: LocalDate,
        newCheckOut: LocalDate
    ): DateModificationPricing {
        const originalDates = new DateRange(
            reservation.checkInDate,
            reservation.checkOutDate
        );
        const newDates = new DateRange(newCheckIn, newCheckOut);
        
        // Identify which nights are unchanged, added, or removed
        const nightAnalysis = this.analyzeNightChanges(originalDates, newDates);
        
        // Calculate pricing for each category
        const unchanged = this.priceUnchangedNights(
            reservation,
            nightAnalysis.unchangedNights
        );
        
        const added = this.priceAddedNights(
            reservation,
            nightAnalysis.addedNights
        );
        
        const removed = this.calculateRemovalCredit(
            reservation,
            nightAnalysis.removedNights
        );
        
        // Recalculate taxes on new total
        const newSubtotal = unchanged.total
            .add(added.total)
            .subtract(removed.creditAmount);
        
        const newTaxes = this.pricingEngine.calculateTaxes(
            newSubtotal,
            reservation.hotel,
            newDates
        );
        
        // Determine net change
        const originalTotal = reservation.totalAmount;
        const newTotal = newSubtotal.add(newTaxes.totalTax);
        const difference = newTotal.subtract(originalTotal);
        
        return new DateModificationPricing({
            originalTotal,
            newTotal,
            difference,
            isAdditionalPaymentRequired: difference.isPositive(),
            isRefundDue: difference.isNegative(),
            breakdown: {
                unchangedNights: unchanged,
                addedNights: added,
                removedNights: removed,
                newTaxBreakdown: newTaxes,
            },
        });
    }
    
    private analyzeNightChanges(
        original: DateRange,
        newRange: DateRange
    ): NightChangeAnalysis {
        const originalNights = new Set(original.eachNight().map(d => d.toString()));
        const newNights = new Set(newRange.eachNight().map(d => d.toString()));
        
        const unchanged: LocalDate[] = [];
        const added: LocalDate[] = [];
        const removed: LocalDate[] = [];
        
        // Find unchanged (intersection)
        for (const night of originalNights) {
            if (newNights.has(night)) {
                unchanged.push(LocalDate.parse(night));
            } else {
                removed.push(LocalDate.parse(night));
            }
        }
        
        // Find added (in new but not original)
        for (const night of newNights) {
            if (!originalNights.has(night)) {
                added.push(LocalDate.parse(night));
            }
        }
        
        return { unchangedNights: unchanged, addedNights: added, removedNights: removed };
    }
    
    private priceUnchangedNights(
        reservation: Reservation,
        nights: LocalDate[]
    ): NightsPricing {
        // Apply rate lock policy - usually keep original rates
        if (this.repricePolicy.honorOriginalRateForUnchangedNights) {
            return this.extractOriginalPricing(reservation, nights);
        }
        
        // Or reprice at current rates (unusual but some policies require)
        return this.priceAtCurrentRates(reservation, nights);
    }
    
    private priceAddedNights(
        reservation: Reservation,
        nights: LocalDate[]
    ): NightsPricing {
        if (nights.length === 0) {
            return NightsPricing.empty();
        }
        
        // Strategy depends on policy
        if (this.repricePolicy.useOriginalRateForExtensions) {
            // Honor original rate plan and rate for extensions
            // This is guest-friendly but revenue-suboptimal
            return this.priceAtOriginalRates(reservation, nights);
        }
        
        // Standard: price new nights at current market rates
        const pricingRequest = this.buildPricingRequest(reservation, nights);
        return this.pricingEngine.priceNights(pricingRequest, nights);
    }
    
    private calculateRemovalCredit(
        reservation: Reservation,
        nights: LocalDate[]
    ): RemovalCredit {
        if (nights.length === 0) {
            return RemovalCredit.none();
        }
        
        // Always credit at original rates (what was charged)
        const originalPricing = this.extractOriginalPricing(reservation, nights);
        
        // Apply cancellation policy if applicable
        if (this.repricePolicy.applyPolicyToRemovedNights) {
            const policy = reservation.cancellationPolicy;
            const penalty = policy.calculatePenaltyForNights(nights.length);
            
            return new RemovalCredit({
                nights,
                grossCredit: originalPricing.total,
                penaltyAmount: penalty,
                netCredit: originalPricing.total.subtract(penalty),
            });
        }
        
        return new RemovalCredit({
            nights,
            grossCredit: originalPricing.total,
            penaltyAmount: Money.zero(),
            netCredit: originalPricing.total,
        });
    }
}
 
/**
 * Policy configuration for repricing behavior
 */
interface RepricingPolicy {
    honorOriginalRateForUnchangedNights: boolean;
    useOriginalRateForExtensions: boolean;
    useOriginalPromotionsForExtensions: boolean;
    applyPolicyToRemovedNights: boolean;
    allowDowngradeRefund: boolean;
    repriceOnRoomTypeChange: 'DIFFERENTIAL' | 'COMPLETE';
}