Merge branch 'dev' into passenger/feat/iam

apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts

@@ -1,5 +1,5 @@
 import { Body, Controller, Delete, Get, Param, Post, Patch, UseGuards, Query, Req, BadRequestException } from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiBearerAuth, ApiResponse, ApiQuery } from '@nestjs/swagger';
+import { ApiTags, ApiOperation, ApiBearerAuth, ApiResponse, ApiQuery, ApiBody } from '@nestjs/swagger';
 import { BookingsService } from './bookings.service';
 import { GuestBookingService } from './guest-booking.service';
 import { CreateBookingDto, ModifyBookingDto, CancelBookingDto } from './bookings.dto';
@@ -74,21 +74,24 @@ export class BookingsController {
   @Get()
   @ApiOperation({ 
     summary: 'List all bookings with filters (Admin/Agent)',
-    description: 'Returns paginated list of bookings with search and status filters'
+    description: 'Returns paginated list of bookings. Use `returnLegStatus=OUTBOUND_ONLY` to find round-trip no-shows on the return leg, `INBOUND_ONLY` for passengers who only used the return leg, `BOTH_USED` for fully completed round-trips, and `NEITHER_USED` for confirmed but not yet boarded.'
   })
   @ApiQuery({ name: 'search', required: false, description: 'Search by booking reference, email, or phone' })
   @ApiQuery({ name: 'status', required: false, description: 'Filter by booking status' })
+  @ApiQuery({ name: 'returnLegStatus', required: false, description: 'Filter round-trip leg usage: NEITHER_USED | OUTBOUND_ONLY | INBOUND_ONLY | BOTH_USED | NOT_APPLICABLE' })
   @ApiQuery({ name: 'page', required: false, description: 'Page number' })
   @ApiQuery({ name: 'pageSize', required: false, description: 'Items per page' })
   findAll(
     @Query('search') search?: string,
     @Query('status') status?: string,
+    @Query('returnLegStatus') returnLegStatus?: string,
     @Query('page') page?: string,
     @Query('pageSize') pageSize?: string,
   ) {
     return this.service.findAll({ 
       search, 
-      status, 
+      status,
+      returnLegStatus,
       page: page ? parseInt(page) : 1, 
       pageSize: pageSize ? parseInt(pageSize) : 20 
     });
@@ -96,35 +99,153 @@ export class BookingsController {
   
   @Post('guest')
   @ApiOperation({ 
-    summary: 'Create guest booking without login (optional account creation)',
-    description: `Creates a booking without requiring login. Features:
-    
-**Guest Checkout:**
-- No login required
-- Contact details from first passenger
-- Booking confirmation sent to email/phone
+    summary: 'Create guest booking — ONE_WAY | ROUND_TRIP | TRANSIT | ROUND_TRIP_TRANSIT (no login required)',
+    description: `Creates a booking without requiring login. Supports all four booking types.
 
-**Optional Account Creation:**
-- Set createAccount=true with password
-- Account created using first passenger details
-- Automatic login after booking
-- Loyalty points and wallet created
+**bookingType: ONE_WAY (default)**
+- scheduleId, holdId, originStationId, destinationStationId, seatClassId
+- passengers[]: { seatId, passengerName, dateOfBirth, idDocumentType, … }
 
-**Passenger Details Storage:**
-- savePassengerDetails=true: Save for future bookings
-- Stored by userId (if account created) or deviceId
-- Retrieve saved passengers for quick booking
+**bookingType: ROUND_TRIP**
+- Above + returnScheduleId, returnHoldId, returnOriginStationId, returnDestinationStationId, returnSeatClassId
+- passengers[]: each must include returnSeatId (seat on the return leg)
 
-**Verifayda Verification:**
-- Ethiopian nationals: National ID verified via Verifayda
-- Other nationals: Passport details (no verification)
+**bookingType: TRANSIT**
+- scheduleId/holdId (leg-1) + leg2ScheduleId, leg2HoldId, transitStationId, leg2DestinationStationId
+- passengers[]: each must include leg2SeatId
 
-**Age-Based Pricing:**
-- ADULT (≥5 years): Full fare
-- CHILD (<5 years): First child FREE, subsequent children full fare`
+**bookingType: ROUND_TRIP_TRANSIT**
+- All TRANSIT outbound fields + returnScheduleId/returnHoldId/returnOriginStationId/returnDestinationStationId/returnLeg2ScheduleId/returnLeg2HoldId/returnTransitStationId/returnLeg2DestinationStationId
+- passengers[]: each must include leg2SeatId, returnSeatId, returnLeg2SeatId
+
+**Optional account creation:** set createAccount=true with password — creates account from first passenger details, loyalty + wallet initialised.
+
+**Verifayda:** Ethiopian nationals verified; international passengers require passportNumber + passportCountry.`
   })
-  @ApiResponse({ status: 201, description: 'Booking created successfully' })
-  @ApiResponse({ status: 400, description: 'Verifayda verification failed or invalid data' })
+  @ApiBody({
+    type: CreateGuestBookingDto,
+    examples: {
+      ONE_WAY: {
+        summary: 'ONE_WAY — single direct journey (guest)',
+        value: {
+          scheduleId: 'schedule-uuid',
+          holdId: 'hold-uuid',
+          originStationId: 'station-uuid',
+          destinationStationId: 'station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'ONE_WAY',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+            phone: '+251911234567',
+            email: 'abebe@email.com',
+          }],
+          savePassengerDetails: true,
+          deviceId: 'device-uuid-123',
+        },
+      },
+      ROUND_TRIP: {
+        summary: 'ROUND_TRIP — outbound + return, single PNR (guest)',
+        value: {
+          scheduleId: 'outbound-schedule-uuid',
+          holdId: 'outbound-hold-uuid',
+          originStationId: 'addis-station-uuid',
+          destinationStationId: 'djibouti-station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'ROUND_TRIP',
+          returnScheduleId: 'return-schedule-uuid',
+          returnHoldId: 'return-hold-uuid',
+          returnOriginStationId: 'djibouti-station-uuid',
+          returnDestinationStationId: 'addis-station-uuid',
+          returnSeatClassId: 'seat-class-uuid',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'outbound-seat-uuid',
+            returnSeatId: 'return-seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+            phone: '+251911234567',
+          }],
+          savePassengerDetails: true,
+          deviceId: 'device-uuid-123',
+        },
+      },
+      TRANSIT: {
+        summary: 'TRANSIT — connecting train, single PNR (guest)',
+        value: {
+          scheduleId: 'leg1-schedule-uuid',
+          holdId: 'leg1-hold-uuid',
+          originStationId: 'addis-station-uuid',
+          destinationStationId: 'diredawa-station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'TRANSIT',
+          leg2ScheduleId: 'leg2-schedule-uuid',
+          leg2HoldId: 'leg2-hold-uuid',
+          transitStationId: 'diredawa-station-uuid',
+          leg2DestinationStationId: 'djibouti-station-uuid',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'leg1-seat-uuid',
+            leg2SeatId: 'leg2-seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+            phone: '+251911234567',
+          }],
+          deviceId: 'device-uuid-123',
+        },
+      },
+      ROUND_TRIP_TRANSIT: {
+        summary: 'ROUND_TRIP_TRANSIT — round trip via connecting trains, 4 holds (guest)',
+        value: {
+          scheduleId: 'ob-leg1-schedule-uuid',
+          holdId: 'ob-leg1-hold-uuid',
+          originStationId: 'addis-station-uuid',
+          destinationStationId: 'diredawa-station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'ROUND_TRIP_TRANSIT',
+          leg2ScheduleId: 'ob-leg2-schedule-uuid',
+          leg2HoldId: 'ob-leg2-hold-uuid',
+          transitStationId: 'diredawa-station-uuid',
+          leg2DestinationStationId: 'djibouti-station-uuid',
+          returnScheduleId: 'ret-leg1-schedule-uuid',
+          returnHoldId: 'ret-leg1-hold-uuid',
+          returnOriginStationId: 'djibouti-station-uuid',
+          returnDestinationStationId: 'diredawa-station-uuid',
+          returnLeg2ScheduleId: 'ret-leg2-schedule-uuid',
+          returnLeg2HoldId: 'ret-leg2-hold-uuid',
+          returnTransitStationId: 'diredawa-station-uuid',
+          returnLeg2DestinationStationId: 'addis-station-uuid',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'ob-leg1-seat-uuid',
+            leg2SeatId: 'ob-leg2-seat-uuid',
+            returnSeatId: 'ret-leg1-seat-uuid',
+            returnLeg2SeatId: 'ret-leg2-seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+            phone: '+251911234567',
+          }],
+          deviceId: 'device-uuid-123',
+        },
+      },
+    },
+  })
+  @ApiResponse({ status: 201, description: 'Booking created successfully with fareBreakdown' })
+  @ApiResponse({ status: 400, description: 'Missing required seat IDs for bookingType, or Verifayda verification failed' })
   createGuest(@Req() req: any, @Body() dto: CreateGuestBookingDto) {
     return this.guestService.createGuestBooking(dto, req);
   }
@@ -143,13 +264,149 @@ export class BookingsController {
   @UseGuards(JwtGuard)
   @ApiBearerAuth('JWT-auth')
   @ApiOperation({ 
-    summary: 'Create booking (requires login)',
-    description: `Creates a booking for logged-in users with saved passenger profiles.
-    Use POST /bookings/guest for guest checkout without login.`
+    summary: 'Create booking — ONE_WAY | ROUND_TRIP | TRANSIT | ROUND_TRIP_TRANSIT',
+    description: `Creates a booking for a logged-in passenger. bookingType controls which fields are required.
+
+**ONE_WAY**
+- scheduleId, holdId, originStationId, destinationStationId, seatClassId
+- passengers[]: { seatId, passengerName, dateOfBirth, idDocumentType, … }
+
+**ROUND_TRIP**
+- Above + returnScheduleId, returnHoldId, returnOriginStationId, returnDestinationStationId, returnSeatClassId
+- passengers[]: { seatId (outbound), returnSeatId (return), passengerName, … }
+- Combined fare = outbound fare + return fare; single promo/loyalty deduction
+
+**TRANSIT** (connecting train, single PNR)
+- scheduleId/holdId for leg-1 + leg2ScheduleId, leg2HoldId, transitStationId, leg2DestinationStationId
+- passengers[]: { seatId (leg-1), leg2SeatId (leg-2), passengerName, … }
+
+**ROUND_TRIP_TRANSIT** (round trip, each direction via connecting train)
+- All TRANSIT outbound fields + returnScheduleId, returnHoldId, returnOriginStationId, returnDestinationStationId, returnLeg2ScheduleId, returnLeg2HoldId, returnTransitStationId, returnLeg2DestinationStationId
+- passengers[]: { seatId, leg2SeatId, returnSeatId, returnLeg2SeatId, passengerName, … }
+- 4 holds required, 4 seat sets per passenger, single PNR, single payment
+
+**Age-Based Pricing (all types)**
+- ADULT (≥5 years): full fare per leg
+- CHILD (<5 years): first child FREE per booking, subsequent children full fare`
+  })
+  @ApiBody({
+    type: CreateBookingDto,
+    examples: {
+      ONE_WAY: {
+        summary: 'ONE_WAY — single direct journey',
+        value: {
+          passengerId: 'passenger-uuid',
+          scheduleId: 'schedule-uuid',
+          holdId: 'hold-uuid',
+          originStationId: 'station-uuid',
+          destinationStationId: 'station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'ONE_WAY',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+          }],
+        },
+      },
+      ROUND_TRIP: {
+        summary: 'ROUND_TRIP — outbound + return, single PNR',
+        value: {
+          passengerId: 'passenger-uuid',
+          scheduleId: 'outbound-schedule-uuid',
+          holdId: 'outbound-hold-uuid',
+          originStationId: 'addis-station-uuid',
+          destinationStationId: 'djibouti-station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'ROUND_TRIP',
+          returnScheduleId: 'return-schedule-uuid',
+          returnHoldId: 'return-hold-uuid',
+          returnOriginStationId: 'djibouti-station-uuid',
+          returnDestinationStationId: 'addis-station-uuid',
+          returnSeatClassId: 'seat-class-uuid',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'outbound-seat-uuid',
+            returnSeatId: 'return-seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+          }],
+        },
+      },
+      TRANSIT: {
+        summary: 'TRANSIT — connecting train, single PNR',
+        value: {
+          passengerId: 'passenger-uuid',
+          scheduleId: 'leg1-schedule-uuid',
+          holdId: 'leg1-hold-uuid',
+          originStationId: 'addis-station-uuid',
+          destinationStationId: 'diredawa-station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'TRANSIT',
+          leg2ScheduleId: 'leg2-schedule-uuid',
+          leg2HoldId: 'leg2-hold-uuid',
+          transitStationId: 'diredawa-station-uuid',
+          leg2DestinationStationId: 'djibouti-station-uuid',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'leg1-seat-uuid',
+            leg2SeatId: 'leg2-seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+          }],
+        },
+      },
+      ROUND_TRIP_TRANSIT: {
+        summary: 'ROUND_TRIP_TRANSIT — round trip via connecting trains, 4 holds',
+        value: {
+          passengerId: 'passenger-uuid',
+          scheduleId: 'ob-leg1-schedule-uuid',
+          holdId: 'ob-leg1-hold-uuid',
+          originStationId: 'addis-station-uuid',
+          destinationStationId: 'diredawa-station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'ROUND_TRIP_TRANSIT',
+          leg2ScheduleId: 'ob-leg2-schedule-uuid',
+          leg2HoldId: 'ob-leg2-hold-uuid',
+          transitStationId: 'diredawa-station-uuid',
+          leg2DestinationStationId: 'djibouti-station-uuid',
+          returnScheduleId: 'ret-leg1-schedule-uuid',
+          returnHoldId: 'ret-leg1-hold-uuid',
+          returnOriginStationId: 'djibouti-station-uuid',
+          returnDestinationStationId: 'diredawa-station-uuid',
+          returnLeg2ScheduleId: 'ret-leg2-schedule-uuid',
+          returnLeg2HoldId: 'ret-leg2-hold-uuid',
+          returnTransitStationId: 'diredawa-station-uuid',
+          returnLeg2DestinationStationId: 'addis-station-uuid',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'ob-leg1-seat-uuid',
+            leg2SeatId: 'ob-leg2-seat-uuid',
+            returnSeatId: 'ret-leg1-seat-uuid',
+            returnLeg2SeatId: 'ret-leg2-seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+          }],
+        },
+      },
+    },
   })
   @ApiResponse({ status: 201, description: 'Booking created with fare breakdown' })
-  @ApiResponse({ status: 400, description: 'Verifayda verification failed or invalid passenger data' })
-  @ApiResponse({ status: 404, description: 'Trip or seat hold not found' })
+  @ApiResponse({ status: 400, description: 'Missing required fields for bookingType, or Verifayda verification failed' })
+  @ApiResponse({ status: 404, description: 'Schedule or seat hold not found' })
   create(@Body() dto: CreateBookingDto) { 
     return this.service.create(dto); 
   }

apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts

@@ -4,7 +4,10 @@ import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Currency, IdDocumentType } from '@prisma/client';
 
 export class PassengerInputDto {
-  @ApiProperty() @IsString() seatId: string;
+  @ApiProperty({ example: 'seat-uuid', description: 'Outbound / leg-1 seat ID (all booking types)' }) @IsString() seatId: string;
+  @ApiPropertyOptional({ example: 'leg2-seat-uuid', description: '**TRANSIT / ROUND_TRIP_TRANSIT:** Outbound leg-2 seat ID' }) @IsOptional() @IsString() leg2SeatId?: string;
+  @ApiPropertyOptional({ example: 'return-seat-uuid', description: '**ROUND_TRIP / ROUND_TRIP_TRANSIT:** Return leg-1 seat ID' }) @IsOptional() @IsString() returnSeatId?: string;
+  @ApiPropertyOptional({ example: 'ret-leg2-seat-uuid', description: '**ROUND_TRIP_TRANSIT:** Return leg-2 seat ID' }) @IsOptional() @IsString() returnLeg2SeatId?: string;
   @ApiProperty({ example: 'Abebe Kebede' }) @IsString() passengerName: string;
   @ApiProperty({ example: '1990-05-15', description: 'Date of birth (YYYY-MM-DD) for age calculation. Age <5 = CHILD (first free), Age ≥5 = ADULT (full fare)' }) @IsDateString() dateOfBirth: string;
   @ApiProperty({ example: 'NATIONAL_ID', enum: IdDocumentType, description: 'NATIONAL_ID for Ethiopians (Verifayda verified), PASSPORT for others' }) @IsEnum(IdDocumentType) idDocumentType: IdDocumentType;
@@ -14,19 +17,170 @@ export class PassengerInputDto {
   @ApiPropertyOptional({ example: 'Ethiopian', description: 'Ethiopian (Verifayda + Telebirr/CBE/eBirr), Djiboutian (Passport + Waafi), Other (Passport + Card)' }) @IsOptional() @IsString() nationality?: string;
 }
 
+export class RoundTripPassengerDto {
+  @ApiProperty({ description: 'Outbound journey seat ID', example: 'seat-uuid-outbound' }) 
+  @IsString() outboundSeatId: string;
+  
+  @ApiProperty({ description: 'Return journey seat ID', example: 'seat-uuid-return' }) 
+  @IsString() returnSeatId: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP_TRANSIT:** Outbound leg-2 seat ID' })
+  @IsOptional() @IsString() outboundLeg2SeatId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP_TRANSIT:** Return leg-2 seat ID' })
+  @IsOptional() @IsString() returnLeg2SeatId?: string;
+  
+  @ApiProperty({ 
+    example: 'Abebe Kebede',
+    description: 'Full passenger name (will be verified via Verifayda for Ethiopian nationals)'
+  }) 
+  @IsString() passengerName: string;
+  
+  @ApiProperty({ 
+    example: '1990-05-15', 
+    description: 'Date of birth (YYYY-MM-DD) for age calculation. Age <5 = CHILD (first child FREE), Age ≥5 = ADULT (full fare for both legs)'
+  }) 
+  @IsDateString() dateOfBirth: string;
+  
+  @ApiProperty({ 
+    example: 'NATIONAL_ID', 
+    enum: IdDocumentType,
+    description: 'NATIONAL_ID for Ethiopians (Verifayda verified), PASSPORT for others'
+  }) 
+  @IsEnum(IdDocumentType) idDocumentType: IdDocumentType;
+  
+  @ApiPropertyOptional({ 
+    example: 'ET123456789', 
+    description: 'Ethiopian national ID - verified via Verifayda 2.0 (NOT stored in database)' 
+  }) 
+  @IsOptional() @IsString() idDocumentNumber?: string;
+  
+  @ApiPropertyOptional({ 
+    example: 'P1234567', 
+    description: 'Passport number for non-Ethiopian passengers (no verification)' 
+  }) 
+  @IsOptional() @IsString() passportNumber?: string;
+  
+  @ApiPropertyOptional({ 
+    example: 'Djibouti', 
+    description: 'Passport issuing country for non-Ethiopians' 
+  }) 
+  @IsOptional() @IsString() passportCountry?: string;
+  
+  @ApiPropertyOptional({ 
+    example: 'Ethiopian', 
+    description: 'Ethiopian (Verifayda + Telebirr/CBE/eBirr), Djiboutian (Passport + Waafi), Other (Passport + Card)' 
+  }) 
+  @IsOptional() @IsString() nationality?: string;
+}
+
 export class CreateBookingDto {
-  @ApiProperty() @IsString() passengerId: string;
-  @ApiProperty() @IsString() scheduleId: string;
-  @ApiProperty() @IsString() holdId: string;
-  @ApiProperty({ example: 'station-uuid', description: 'Origin station UUID for this leg (must match the hold)' }) @IsString() originStationId: string;
-  @ApiProperty({ example: 'station-uuid', description: 'Destination station UUID for this leg (must match the hold)' }) @IsString() destinationStationId: string;
-  @ApiProperty({ type: [PassengerInputDto], description: 'Array of passengers with age-based categorization. First child (<5 years) travels FREE.' }) @IsArray() @ValidateNested({ each: true }) @Type(() => PassengerInputDto) passengers: PassengerInputDto[];
-  @ApiProperty({ example: 'seat-class-uuid', description: 'Seat class UUID (Economy Regular, Economy Bed, VIP Bed)' })
+  @ApiProperty({ description: 'Passenger ID' }) 
+  @IsString() passengerId: string;
+  
+  @ApiProperty({ description: 'Outbound / leg-1 schedule ID' }) 
+  @IsString() scheduleId: string;
+  
+  @ApiProperty({ description: 'Outbound / leg-1 seat hold ID' }) 
+  @IsString() holdId: string;
+  
+  @ApiProperty({ example: 'station-uuid', description: 'Outbound origin station UUID' }) 
+  @IsString() originStationId: string;
+  
+  @ApiProperty({ example: 'station-uuid', description: 'Outbound destination station UUID' }) 
+  @IsString() destinationStationId: string;
+  
+  @ApiProperty({ example: 'seat-class-uuid', description: 'Outbound seat class UUID (Economy Regular, Economy Bed, VIP Bed)' })
   @IsString() seatClassId: string;
-  @ApiPropertyOptional() @IsOptional() @IsString() promoCode?: string;
-  @ApiPropertyOptional() @IsOptional() @IsInt() loyaltyRedemptionPoints?: number;
-  @ApiPropertyOptional({ example: 'ONE_WAY' }) @IsOptional() @IsString() bookingType?: string;
-  @ApiPropertyOptional({ example: 'DJF', enum: Currency, description: 'Display currency for fare breakdown (ETB, DJF, USD). Transaction always in ETB.' }) @IsOptional() @IsEnum(Currency) displayCurrency?: Currency;
+
+  @ApiProperty({ 
+    example: 'ONE_WAY', 
+    enum: ['ONE_WAY', 'ROUND_TRIP', 'TRANSIT', 'ROUND_TRIP_TRANSIT'],
+    description: `Booking type:
+
+**ONE_WAY:** Single direct journey — needs: scheduleId, holdId. Passenger: seatId.
+
+**ROUND_TRIP:** Outbound + return, single PNR — needs above + returnScheduleId, returnHoldId, returnOriginStationId, returnDestinationStationId. Passenger: seatId + returnSeatId.
+
+**TRANSIT:** Single journey via connecting train, single PNR — needs above + leg2ScheduleId, leg2HoldId, transitStationId, leg2DestinationStationId. Passenger: seatId + leg2SeatId.
+
+**ROUND_TRIP_TRANSIT:** Round trip via connecting trains — needs all 4 hold sets + all station fields. Passenger: seatId + leg2SeatId + returnSeatId + returnLeg2SeatId.`,
+    default: 'ONE_WAY'
+  }) 
+  @IsOptional() @IsString() bookingType?: string;
+  
+  @ApiProperty({ 
+    type: [PassengerInputDto], 
+    description: `Passenger array — required seat fields vary by bookingType:
+
+**ONE_WAY:** { seatId, passengerName, dateOfBirth, idDocumentType, … }
+
+**ROUND_TRIP:** { seatId (outbound leg-1), returnSeatId (return leg-1), passengerName, … }
+
+**TRANSIT:** { seatId (leg-1), leg2SeatId (leg-2), passengerName, … }
+
+**ROUND_TRIP_TRANSIT:** { seatId, leg2SeatId, returnSeatId, returnLeg2SeatId, passengerName, … }
+
+**Age-based pricing:** First child (<5 years) travels FREE, subsequent children pay full fare.`
+  }) 
+  @IsArray() @ValidateNested({ each: true }) @Type(() => PassengerInputDto) 
+  passengers: PassengerInputDto[];
+
+  @ApiPropertyOptional({ description: 'Promo code for discount (applies to combined fare for round-trip)' }) 
+  @IsOptional() @IsString() promoCode?: string;
+  
+  @ApiPropertyOptional({ description: 'Loyalty points to redeem (applies to combined fare for round-trip)' }) 
+  @IsOptional() @IsInt() loyaltyRedemptionPoints?: number;
+  
+  @ApiPropertyOptional({ example: 'DJF', enum: Currency, description: 'Display currency for fare breakdown (ETB, DJF, USD). Transaction always in ETB.' }) 
+  @IsOptional() @IsEnum(Currency) displayCurrency?: Currency;
+
+  // Transit-specific fields
+  @ApiPropertyOptional({ description: '**TRANSIT / ROUND_TRIP_TRANSIT:** Leg-2 schedule ID' })
+  @IsOptional() @IsString() leg2ScheduleId?: string;
+
+  @ApiPropertyOptional({ description: '**TRANSIT / ROUND_TRIP_TRANSIT:** Leg-2 seat hold ID' })
+  @IsOptional() @IsString() leg2HoldId?: string;
+
+  @ApiPropertyOptional({ description: '**TRANSIT / ROUND_TRIP_TRANSIT:** Transit (connecting) station UUID' })
+  @IsOptional() @IsString() transitStationId?: string;
+
+  @ApiPropertyOptional({ description: '**TRANSIT / ROUND_TRIP_TRANSIT:** Leg-2 destination station UUID' })
+  @IsOptional() @IsString() leg2DestinationStationId?: string;
+
+  @ApiPropertyOptional({ description: '**TRANSIT / ROUND_TRIP_TRANSIT:** Leg-2 seat class ID (defaults to outbound seatClassId)' })
+  @IsOptional() @IsString() leg2SeatClassId?: string;
+
+  // Round-trip transit: return direction transit fields
+  @ApiPropertyOptional({ description: '**ROUND_TRIP_TRANSIT:** Return leg-1 schedule ID' })
+  @IsOptional() @IsString() returnScheduleId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP / ROUND_TRIP_TRANSIT:** Return origin station ID' })
+  @IsOptional() @IsString() returnOriginStationId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP / ROUND_TRIP_TRANSIT:** Return destination station ID' })
+  @IsOptional() @IsString() returnDestinationStationId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP / ROUND_TRIP_TRANSIT:** Return seat hold ID' })
+  @IsOptional() @IsString() returnHoldId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP / ROUND_TRIP_TRANSIT:** Return seat class ID' })
+  @IsOptional() @IsString() returnSeatClassId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP_TRANSIT:** Return leg-2 schedule ID' })
+  @IsOptional() @IsString() returnLeg2ScheduleId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP_TRANSIT:** Return leg-2 seat hold ID' })
+  @IsOptional() @IsString() returnLeg2HoldId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP_TRANSIT:** Return transit (connecting) station UUID' })
+  @IsOptional() @IsString() returnTransitStationId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP_TRANSIT:** Return leg-2 destination station UUID' })
+  @IsOptional() @IsString() returnLeg2DestinationStationId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP_TRANSIT:** Return leg-2 seat class ID' })
+  @IsOptional() @IsString() returnLeg2SeatClassId?: string;
 }
 
 export class ModifyBookingDto {

apps/edr-passenger-api/src/modules/bookings/bookings.module.ts

@@ -1,5 +1,6 @@
 import { Module } from '@nestjs/common';
 import { HttpModule } from '@nestjs/axios';
+import { AuditModule } from '../../common/audit.module';
 import { BookingsController } from './bookings.controller';
 import { BookingsService } from './bookings.service';
 import { GuestBookingService } from './guest-booking.service';
@@ -7,9 +8,10 @@ import { SeatsModule } from '../seats/seats.module';
 import { VerifaydaModule } from '../verifayda/verifayda.module';
 import { CurrencyModule } from '../currency/currency.module';
 import { AuthModule } from '../auth/auth.module';
+import { FareEngineModule } from '../fare-engine/fare-engine.module';
 
 @Module({
-  imports: [SeatsModule, VerifaydaModule, CurrencyModule, HttpModule, AuthModule],
+  imports: [AuditModule, SeatsModule, VerifaydaModule, CurrencyModule, FareEngineModule, HttpModule, AuthModule],
   controllers: [BookingsController],
   providers: [BookingsService, GuestBookingService],
   exports: [BookingsService, GuestBookingService]

apps/edr-passenger-api/src/modules/bookings/bookings.service.ts

@@ -8,6 +8,7 @@ import { CreateBookingDto, ModifyBookingDto } from './bookings.dto';
 import { Cron, CronExpression } from '@nestjs/schedule';
 import { VerifaydaService } from '../verifayda/verifayda.service';
 import { CurrencyService } from '../currency/currency.service';
+import { FareEngineService } from '../fare-engine/fare-engine.service';
 import { Currency, PassengerCategory, IdDocumentType } from '@prisma/client';
 
 function generateRef(): string {
@@ -26,6 +27,7 @@ function calculateAge(dateOfBirth: Date): number {
 interface BookingFilters {
   search?: string;
   status?: string;
+  returnLegStatus?: string;
   page?: number;
   pageSize?: number;
 }
@@ -39,6 +41,7 @@ export class BookingsService {
     private readonly eventEmitter: EventEmitter2,
     private readonly verifaydaService: VerifaydaService,
     private readonly currencyService: CurrencyService,
+    private readonly fareEngine: FareEngineService,
   ) {}
 
   async findByPassengerId(passengerId: string, filters: BookingFilters = {}) {
@@ -85,6 +88,8 @@ export class BookingsService {
         displayTotalMinor: booking.displayTotalMinor,
         adultCount: booking.adultCount,
         childCount: booking.childCount,
+        bookingType: booking.bookingType,
+        returnLegStatus: (booking as any).returnLegStatus ?? null,
         createdAt: booking.createdAt,
         schedule: {
           train: booking.schedule.train,
@@ -162,6 +167,8 @@ export class BookingsService {
         displayTotalMinor: booking.displayTotalMinor,
         adultCount: booking.adultCount,
         childCount: booking.childCount,
+        bookingType: booking.bookingType,
+        returnLegStatus: (booking as any).returnLegStatus ?? null,
         createdAt: booking.createdAt,
         schedule: {
           train: booking.schedule.train,
@@ -183,7 +190,7 @@ export class BookingsService {
   }
 
   async findAll(filters: BookingFilters = {}) {
-    const { search, status, page = 1, pageSize = 20 } = filters;
+    const { search, status, returnLegStatus, page = 1, pageSize = 20 } = filters;
     const skip = (page - 1) * pageSize;
     
     const where: any = {};
@@ -197,9 +204,8 @@ export class BookingsService {
       ];
     }
     
-    if (status) {
-      where.status = status;
-    }
+    if (status) where.status = status;
+    if (returnLegStatus) (where as any).returnLegStatus = returnLegStatus;
     
     const [items, total] = await Promise.all([
       this.prisma.booking.findMany({
@@ -239,6 +245,10 @@ export class BookingsService {
           displayTotalMinor: booking.displayTotalMinor,
           contactEmail: booking.contactEmail,
           contactPhone: booking.contactPhone,
+          bookingType: booking.bookingType,
+          returnLegStatus: (booking as any).returnLegStatus ?? null,
+          adultCount: booking.adultCount,
+          childCount: booking.childCount,
           createdAt: booking.createdAt,
           passenger: iam
             ? { fullName: iam.name?.en ?? iam.name?.am ?? null, email: iam.email, phone: iam.phone_number }
@@ -263,15 +273,19 @@ export class BookingsService {
   }
 
   async create(dto: CreateBookingDto) {
+    if (dto.bookingType === 'ROUND_TRIP')         return this.createRoundTripBooking(dto);
+    if (dto.bookingType === 'TRANSIT')            return this.createTransitBooking(dto);
+    if (dto.bookingType === 'ROUND_TRIP_TRANSIT') return this.createRoundTripTransitBooking(dto);
+    return this.createOneWayBooking(dto);
+  }
+
+  private async createOneWayBooking(dto: CreateBookingDto) {
     const hold = await this.prisma.seatHold.findUnique({ where: { id: dto.holdId } });
     if (!hold || hold.expiresAt < new Date()) throw new BadRequestException('Seat hold expired');
+    
     const schedule = await this.prisma.trainSchedule.findUnique({
       where: { id: dto.scheduleId },
-      include: {
-        originStation: true,
-        destinationStation: true,
-        stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } },
-      },
+      include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } }
     });
     if (!schedule) throw new NotFoundException('Schedule not found');
 
@@ -279,18 +293,498 @@ export class BookingsService {
     const destStop = schedule.stopTimes.find(s => s.stationId === dto.destinationStationId);
     if (!originStop || !destStop) throw new NotFoundException('Origin or destination not found');
 
-    const segmentRoute = `${originStop.station.code}-${destStop.station.code}`;
-    const fullRoute = `${schedule.originStation.code}-${schedule.destinationStation.code}`;
+    const passengersData = await this.processPassengers(dto.passengers as any[]);
+    const { adultCount, childCount } = this.countPassengers(passengersData);
+    const fareCalculation = await this.calculateFare(dto.scheduleId, dto.seatClassId, originStop, destStop, passengersData[0]?.nationality, adultCount, childCount, dto.promoCode, dto.loyaltyRedemptionPoints);
+    
+    const displayCurrency = dto.displayCurrency || Currency.ETB;
+    let displayTotalMinor = fareCalculation.totalMinor;
+    if (displayCurrency !== Currency.ETB) {
+      displayTotalMinor = await this.currencyService.convertAmount(fareCalculation.totalMinor, Currency.ETB, displayCurrency);
+    }
 
-    const seatIds = dto.passengers.map((p) => p.seatId);
-    const passengersData = [];
-    let adultCount = 0, childCount = 0;
+    const booking = await this.prisma.booking.create({
+      data: {
+        bookingRef: generateRef(),
+        passengerId: dto.passengerId,
+        scheduleId: dto.scheduleId,
+        status: 'PENDING_PAYMENT',
+        bookingType: 'ONE_WAY',
+        totalMinor: fareCalculation.totalMinor,
+        adultCount,
+        childCount,
+        displayCurrency,
+        displayTotalMinor,
+        seats: {
+          create: passengersData.map(p => ({
+            seat: { connect: { id: p.seatId } },
+            passengerName: p.passengerName,
+            dateOfBirth: p.dateOfBirth,
+            passengerCategory: p.category,
+            idDocumentType: p.idDocumentType,
+            passportNumber: p.passportNumber,
+            passportCountry: p.passportCountry,
+            verifaydaVerified: p.verifaydaVerified,
+            verifaydaData: p.verifaydaData,
+            fareMinor: p.category === PassengerCategory.ADULT ? fareCalculation.baseFareMinor : (fareCalculation.paidChildrenCount > 0 ? fareCalculation.baseFareMinor : 0),
+            displayCurrency
+          }))
+        }
+      },
+      include: { seats: { include: { seat: true } }, schedule: { include: { originStation: true, destinationStation: true, train: true } } }
+    });
 
-    for (const passenger of dto.passengers) {
+    await this.seatsService.confirmSeats(passengersData.map(p => p.seatId));
+    this.eventEmitter.emit('booking.created', { booking });
+    return { ...booking, fareBreakdown: fareCalculation };
+  }
+
+  private async createRoundTripBooking(dto: CreateBookingDto) {
+    if (!dto.returnScheduleId || !dto.returnHoldId || !dto.returnOriginStationId || !dto.returnDestinationStationId) {
+      throw new BadRequestException('Return trip details required for round-trip booking');
+    }
+
+    const [outboundHold, returnHold] = await Promise.all([
+      this.prisma.seatHold.findUnique({ where: { id: dto.holdId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.returnHoldId } })
+    ]);
+    
+    if (!outboundHold || outboundHold.expiresAt < new Date()) throw new BadRequestException('Outbound seat hold expired');
+    if (!returnHold || returnHold.expiresAt < new Date()) throw new BadRequestException('Return seat hold expired');
+
+    const [outboundSchedule, returnSchedule] = await Promise.all([
+      this.prisma.trainSchedule.findUnique({
+        where: { id: dto.scheduleId },
+        include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } }
+      }),
+      this.prisma.trainSchedule.findUnique({
+        where: { id: dto.returnScheduleId },
+        include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } }
+      })
+    ]);
+
+    if (!outboundSchedule || !returnSchedule) throw new NotFoundException('Schedule not found');
+
+    const outboundOriginStop = outboundSchedule.stopTimes.find(s => s.stationId === dto.originStationId);
+    const outboundDestStop = outboundSchedule.stopTimes.find(s => s.stationId === dto.destinationStationId);
+    const returnOriginStop = returnSchedule.stopTimes.find(s => s.stationId === dto.returnOriginStationId);
+    const returnDestStop = returnSchedule.stopTimes.find(s => s.stationId === dto.returnDestinationStationId);
+
+    if (!outboundOriginStop || !outboundDestStop || !returnOriginStop || !returnDestStop) {
+      throw new NotFoundException('Origin or destination stops not found');
+    }
+
+    const passengersData = await this.processRoundTripPassengers(dto.passengers as any[]);
+    const { adultCount, childCount } = this.countPassengers(passengersData);
+
+    const [outboundFare, returnFare] = await Promise.all([
+      this.calculateFare(dto.scheduleId, dto.seatClassId, outboundOriginStop, outboundDestStop, passengersData[0]?.nationality, adultCount, childCount),
+      this.calculateFare(dto.returnScheduleId, dto.returnSeatClassId || dto.seatClassId, returnOriginStop, returnDestStop, passengersData[0]?.nationality, adultCount, childCount)
+    ]);
+
+    const combinedBaseFareMinor = outboundFare.totalBaseFareMinor + returnFare.totalBaseFareMinor;
+    let discountMinor = 0;
+    if (dto.promoCode) {
+      const promo = await this.prisma.promotion.findUnique({ where: { code: dto.promoCode } });
+      if (promo?.active && promo.validUntil > new Date()) {
+        discountMinor = promo.percentOff ? Math.round(combinedBaseFareMinor * promo.percentOff / 100) : (promo.amountOffMinor ?? 0);
+      }
+    }
+
+    const loyaltyMinor = (dto.loyaltyRedemptionPoints ?? 0) * 10;
+    const taxesMinor = Math.round(combinedBaseFareMinor * 0.05);
+    const totalMinor = Math.max(0, combinedBaseFareMinor - discountMinor - loyaltyMinor + taxesMinor);
+
+    const displayCurrency = dto.displayCurrency || Currency.ETB;
+    let displayTotalMinor = totalMinor;
+    if (displayCurrency !== Currency.ETB) {
+      displayTotalMinor = await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency);
+    }
+
+    const booking = await this.prisma.booking.create({
+      data: {
+        bookingRef: generateRef(),
+        passengerId: dto.passengerId,
+        scheduleId: dto.scheduleId,
+        status: 'PENDING_PAYMENT',
+        bookingType: 'ROUND_TRIP',
+        totalMinor,
+        adultCount,
+        childCount,
+        displayCurrency,
+        displayTotalMinor,
+        returnScheduleId: dto.returnScheduleId,
+        returnOriginStationId: dto.returnOriginStationId,
+        returnDestinationStationId: dto.returnDestinationStationId,
+        returnHoldId: dto.returnHoldId,
+        returnSeatClassId: dto.returnSeatClassId,
+        returnLegStatus: 'NEITHER_USED',
+        seats: {
+          create: [
+            ...passengersData.map(p => ({
+              seat: { connect: { id: p.outboundSeatId } },
+              leg: 1,
+              scheduleId: dto.scheduleId,
+              passengerName: p.passengerName,
+              dateOfBirth: p.dateOfBirth,
+              passengerCategory: p.category,
+              idDocumentType: p.idDocumentType,
+              passportNumber: p.passportNumber,
+              passportCountry: p.passportCountry,
+              verifaydaVerified: p.verifaydaVerified,
+              verifaydaData: p.verifaydaData,
+              fareMinor: p.category === PassengerCategory.ADULT ? outboundFare.baseFareMinor : (outboundFare.paidChildrenCount > 0 ? outboundFare.baseFareMinor : 0),
+              displayCurrency,
+            })),
+            ...passengersData.map(p => ({
+              seat: { connect: { id: p.returnSeatId } },
+              leg: 2,
+              scheduleId: dto.returnScheduleId,
+              passengerName: p.passengerName,
+              dateOfBirth: p.dateOfBirth,
+              passengerCategory: p.category,
+              idDocumentType: p.idDocumentType,
+              passportNumber: p.passportNumber,
+              passportCountry: p.passportCountry,
+              verifaydaVerified: p.verifaydaVerified,
+              verifaydaData: p.verifaydaData,
+              fareMinor: p.category === PassengerCategory.ADULT ? returnFare.baseFareMinor : (returnFare.paidChildrenCount > 0 ? returnFare.baseFareMinor : 0),
+              displayCurrency,
+            })),
+          ],
+        },
+      } as any,
+      include: { seats: { include: { seat: true } }, schedule: { include: { originStation: true, destinationStation: true, train: true } } }
+    });
+
+    const outboundSeatIds = passengersData.map(p => p.outboundSeatId);
+    const returnSeatIds = passengersData.map(p => p.returnSeatId);
+    await Promise.all([
+      this.seatsService.confirmSeats(outboundSeatIds),
+      this.seatsService.confirmSeats(returnSeatIds)
+    ]);
+
+    this.eventEmitter.emit('booking.created', { booking });
+
+    return {
+      ...booking,
+      fareBreakdown: {
+        outboundFare: outboundFare.baseFareMinor,
+        returnFare: returnFare.baseFareMinor,
+        combinedBaseFareMinor,
+        discountMinor,
+        loyaltyRedemptionMinor: loyaltyMinor,
+        taxesFeesMinor: taxesMinor,
+        totalMinor,
+        currency: 'ETB',
+        displayCurrency,
+        displayTotalMinor
+      }
+    };
+  }
+
+  private async createTransitBooking(dto: CreateBookingDto) {
+    if (!dto.leg2ScheduleId || !dto.leg2HoldId || !dto.transitStationId || !dto.leg2DestinationStationId) {
+      throw new BadRequestException('leg2ScheduleId, leg2HoldId, transitStationId and leg2DestinationStationId are required for TRANSIT bookings');
+    }
+
+    const [leg1Hold, leg2Hold] = await Promise.all([
+      this.prisma.seatHold.findUnique({ where: { id: dto.holdId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.leg2HoldId } }),
+    ]);
+    if (!leg1Hold || leg1Hold.expiresAt < new Date()) throw new BadRequestException('Leg-1 seat hold expired');
+    if (!leg2Hold || leg2Hold.expiresAt < new Date()) throw new BadRequestException('Leg-2 seat hold expired');
+
+    const [leg1Schedule, leg2Schedule] = await Promise.all([
+      this.prisma.trainSchedule.findUnique({
+        where: { id: dto.scheduleId },
+        include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } },
+      }),
+      this.prisma.trainSchedule.findUnique({
+        where: { id: dto.leg2ScheduleId },
+        include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } },
+      }),
+    ]);
+    if (!leg1Schedule) throw new NotFoundException('Leg-1 schedule not found');
+    if (!leg2Schedule) throw new NotFoundException('Leg-2 schedule not found');
+
+    const leg1OriginStop = leg1Schedule.stopTimes.find(s => s.stationId === dto.originStationId);
+    const leg1DestStop   = leg1Schedule.stopTimes.find(s => s.stationId === dto.transitStationId);
+    const leg2OriginStop = leg2Schedule.stopTimes.find(s => s.stationId === dto.transitStationId);
+    const leg2DestStop   = leg2Schedule.stopTimes.find(s => s.stationId === dto.leg2DestinationStationId);
+    if (!leg1OriginStop || !leg1DestStop) throw new NotFoundException('Leg-1 origin or transit station not found on schedule');
+    if (!leg2OriginStop || !leg2DestStop) throw new NotFoundException('Transit or leg-2 destination station not found on leg-2 schedule');
+
+    const passengersData = await this.processPassengers(dto.passengers as any[]);
+    const { adultCount, childCount } = this.countPassengers(passengersData);
+
+    const leg2SeatClassId = dto.leg2SeatClassId ?? dto.seatClassId;
+    const [leg1Fare, leg2Fare] = await Promise.all([
+      this.calculateFare(dto.scheduleId, dto.seatClassId, leg1OriginStop, leg1DestStop, passengersData[0]?.nationality, adultCount, childCount),
+      this.calculateFare(dto.leg2ScheduleId, leg2SeatClassId, leg2OriginStop, leg2DestStop, passengersData[0]?.nationality, adultCount, childCount),
+    ]);
+
+    const combinedBase = leg1Fare.totalBaseFareMinor + leg2Fare.totalBaseFareMinor;
+    let discountMinor = 0;
+    if (dto.promoCode) {
+      const promo = await this.prisma.promotion.findUnique({ where: { code: dto.promoCode } });
+      if (promo?.active && promo.validUntil > new Date()) {
+        discountMinor = promo.percentOff ? Math.round(combinedBase * promo.percentOff / 100) : (promo.amountOffMinor ?? 0);
+      }
+    }
+    const loyaltyMinor    = (dto.loyaltyRedemptionPoints ?? 0) * 10;
+    const taxesMinor      = Math.round(combinedBase * 0.05);
+    const totalMinor      = Math.max(0, combinedBase - discountMinor - loyaltyMinor + taxesMinor);
+    const displayCurrency = dto.displayCurrency || Currency.ETB;
+    const displayTotalMinor = displayCurrency !== Currency.ETB
+      ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
+      : totalMinor;
+
+    // Single booking — leg-1 seats at leg=1, leg-2 seats at leg=2
+    const booking = await this.prisma.booking.create({
+      data: {
+        bookingRef: generateRef(),
+        passengerId: dto.passengerId,
+        scheduleId: dto.scheduleId,
+        status: 'PENDING_PAYMENT',
+        bookingType: 'TRANSIT',
+        totalMinor,
+        adultCount,
+        childCount,
+        displayCurrency,
+        displayTotalMinor,
+        leg2ScheduleId: dto.leg2ScheduleId,
+        leg2OriginStationId: dto.transitStationId,
+        leg2DestinationStationId: dto.leg2DestinationStationId,
+        leg2SeatClassId,
+        seats: {
+          create: [
+            ...passengersData.map(p => ({
+              seat: { connect: { id: p.seatId } },
+              leg: 1,
+              scheduleId: dto.scheduleId,
+              passengerName: p.passengerName,
+              dateOfBirth: p.dateOfBirth,
+              passengerCategory: p.category,
+              idDocumentType: p.idDocumentType,
+              passportNumber: p.passportNumber,
+              passportCountry: p.passportCountry,
+              verifaydaVerified: p.verifaydaVerified,
+              verifaydaData: p.verifaydaData,
+              fareMinor: p.category === PassengerCategory.ADULT ? leg1Fare.baseFareMinor : (leg1Fare.paidChildrenCount > 0 ? leg1Fare.baseFareMinor : 0),
+              displayCurrency,
+            })),
+            ...passengersData.map(p => ({
+              seat: { connect: { id: p.leg2SeatId ?? p.seatId } },
+              leg: 2,
+              scheduleId: dto.leg2ScheduleId,
+              passengerName: p.passengerName,
+              dateOfBirth: p.dateOfBirth,
+              passengerCategory: p.category,
+              idDocumentType: p.idDocumentType,
+              passportNumber: p.passportNumber,
+              passportCountry: p.passportCountry,
+              verifaydaVerified: p.verifaydaVerified,
+              verifaydaData: p.verifaydaData,
+              fareMinor: p.category === PassengerCategory.ADULT ? leg2Fare.baseFareMinor : (leg2Fare.paidChildrenCount > 0 ? leg2Fare.baseFareMinor : 0),
+              displayCurrency,
+            })),
+          ],
+        },
+      } as any,
+      include: { seats: { include: { seat: true } }, schedule: { include: { originStation: true, destinationStation: true, train: true } } },
+    });
+
+    await Promise.all([
+      this.seatsService.confirmSeats(passengersData.map(p => p.seatId)),
+      this.seatsService.confirmSeats(passengersData.map(p => p.leg2SeatId ?? p.seatId)),
+    ]);
+    this.eventEmitter.emit('booking.created', { booking });
+
+    return {
+      ...booking,
+      fareBreakdown: {
+        leg1BaseFareMinor: leg1Fare.baseFareMinor,
+        leg2BaseFareMinor: leg2Fare.baseFareMinor,
+        adultCount, childCount,
+        freeChildrenCount: Math.min(childCount, 1),
+        paidChildrenCount: leg1Fare.paidChildrenCount,
+        combinedBaseFareMinor: combinedBase,
+        discountMinor, loyaltyRedemptionMinor: loyaltyMinor,
+        taxesFeesMinor: taxesMinor, totalMinor,
+        currency: 'ETB', displayCurrency, displayTotalMinor,
+      },
+    };
+  }
+
+  private async createRoundTripTransitBooking(dto: CreateBookingDto) {
+    if (!dto.leg2ScheduleId || !dto.leg2HoldId || !dto.transitStationId || !dto.leg2DestinationStationId ||
+        !dto.returnScheduleId || !dto.returnHoldId || !dto.returnOriginStationId || !dto.returnDestinationStationId ||
+        !dto.returnLeg2ScheduleId || !dto.returnLeg2HoldId || !dto.returnTransitStationId || !dto.returnLeg2DestinationStationId) {
+      throw new BadRequestException(
+        'ROUND_TRIP_TRANSIT requires outbound transit fields (leg2ScheduleId, leg2HoldId, transitStationId, leg2DestinationStationId) ' +
+        'AND return transit fields (returnScheduleId, returnHoldId, returnOriginStationId, returnDestinationStationId, ' +
+        'returnLeg2ScheduleId, returnLeg2HoldId, returnTransitStationId, returnLeg2DestinationStationId)',
+      );
+    }
+
+    // Validate all 4 holds
+    const [obL1Hold, obL2Hold, retL1Hold, retL2Hold] = await Promise.all([
+      this.prisma.seatHold.findUnique({ where: { id: dto.holdId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.leg2HoldId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.returnHoldId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.returnLeg2HoldId } }),
+    ]);
+    const now = new Date();
+    if (!obL1Hold  || obL1Hold.expiresAt  < now) throw new BadRequestException('Outbound leg-1 seat hold expired');
+    if (!obL2Hold  || obL2Hold.expiresAt  < now) throw new BadRequestException('Outbound leg-2 seat hold expired');
+    if (!retL1Hold || retL1Hold.expiresAt < now) throw new BadRequestException('Return leg-1 seat hold expired');
+    if (!retL2Hold || retL2Hold.expiresAt < now) throw new BadRequestException('Return leg-2 seat hold expired');
+
+    // Load all 4 schedules
+    const [obL1Sched, obL2Sched, retL1Sched, retL2Sched] = await Promise.all([
+      this.prisma.trainSchedule.findUnique({ where: { id: dto.scheduleId }, include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } } }),
+      this.prisma.trainSchedule.findUnique({ where: { id: dto.leg2ScheduleId }, include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } } }),
+      this.prisma.trainSchedule.findUnique({ where: { id: dto.returnScheduleId }, include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } } }),
+      this.prisma.trainSchedule.findUnique({ where: { id: dto.returnLeg2ScheduleId }, include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } } }),
+    ]);
+    if (!obL1Sched)  throw new NotFoundException('Outbound leg-1 schedule not found');
+    if (!obL2Sched)  throw new NotFoundException('Outbound leg-2 schedule not found');
+    if (!retL1Sched) throw new NotFoundException('Return leg-1 schedule not found');
+    if (!retL2Sched) throw new NotFoundException('Return leg-2 schedule not found');
+
+    const obL1Origin  = obL1Sched.stopTimes.find(s => s.stationId === dto.originStationId);
+    const obL1Dest    = obL1Sched.stopTimes.find(s => s.stationId === dto.transitStationId);
+    const obL2Origin  = obL2Sched.stopTimes.find(s => s.stationId === dto.transitStationId);
+    const obL2Dest    = obL2Sched.stopTimes.find(s => s.stationId === dto.leg2DestinationStationId);
+    const retL1Origin = retL1Sched.stopTimes.find(s => s.stationId === dto.returnOriginStationId);
+    const retL1Dest   = retL1Sched.stopTimes.find(s => s.stationId === dto.returnTransitStationId);
+    const retL2Origin = retL2Sched.stopTimes.find(s => s.stationId === dto.returnTransitStationId);
+    const retL2Dest   = retL2Sched.stopTimes.find(s => s.stationId === dto.returnLeg2DestinationStationId);
+    if (!obL1Origin || !obL1Dest)   throw new NotFoundException('Outbound leg-1: origin or transit station not found');
+    if (!obL2Origin || !obL2Dest)   throw new NotFoundException('Outbound leg-2: transit or destination not found');
+    if (!retL1Origin || !retL1Dest) throw new NotFoundException('Return leg-1: origin or transit station not found');
+    if (!retL2Origin || !retL2Dest) throw new NotFoundException('Return leg-2: transit or destination not found');
+
+    const passengersData = await this.processRoundTripPassengers(dto.passengers as any[]);
+    const { adultCount, childCount } = this.countPassengers(passengersData);
+    const nat = passengersData[0]?.nationality;
+
+    const obL2SeatClassId  = dto.leg2SeatClassId        ?? dto.seatClassId;
+    const retL1SeatClassId = dto.returnSeatClassId       ?? dto.seatClassId;
+    const retL2SeatClassId = dto.returnLeg2SeatClassId   ?? dto.seatClassId;
+
+    const [obL1Fare, obL2Fare, retL1Fare, retL2Fare] = await Promise.all([
+      this.calculateFare(dto.scheduleId,          dto.seatClassId,   obL1Origin,  obL1Dest,  nat, adultCount, childCount),
+      this.calculateFare(dto.leg2ScheduleId,       obL2SeatClassId,  obL2Origin,  obL2Dest,  nat, adultCount, childCount),
+      this.calculateFare(dto.returnScheduleId,     retL1SeatClassId, retL1Origin, retL1Dest, nat, adultCount, childCount),
+      this.calculateFare(dto.returnLeg2ScheduleId, retL2SeatClassId, retL2Origin, retL2Dest, nat, adultCount, childCount),
+    ]);
+
+    const combinedBase = obL1Fare.totalBaseFareMinor + obL2Fare.totalBaseFareMinor +
+                         retL1Fare.totalBaseFareMinor + retL2Fare.totalBaseFareMinor;
+    let discountMinor = 0;
+    if (dto.promoCode) {
+      const promo = await this.prisma.promotion.findUnique({ where: { code: dto.promoCode } });
+      if (promo?.active && promo.validUntil > new Date()) {
+        discountMinor = promo.percentOff ? Math.round(combinedBase * promo.percentOff / 100) : (promo.amountOffMinor ?? 0);
+      }
+    }
+    const loyaltyMinor    = (dto.loyaltyRedemptionPoints ?? 0) * 10;
+    const taxesMinor      = Math.round(combinedBase * 0.05);
+    const totalMinor      = Math.max(0, combinedBase - discountMinor - loyaltyMinor + taxesMinor);
+    const displayCurrency = dto.displayCurrency || Currency.ETB;
+    const displayTotalMinor = displayCurrency !== Currency.ETB
+      ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
+      : totalMinor;
+
+    const makeSeat = (p: any, seatId: string, leg: number, scheduleId: string, fare: Awaited<ReturnType<BookingsService['calculateFare']>>) => ({
+      seat: { connect: { id: seatId } },
+      leg,
+      scheduleId,
+      passengerName: p.passengerName,
+      dateOfBirth: p.dateOfBirth,
+      passengerCategory: p.category,
+      idDocumentType: p.idDocumentType,
+      passportNumber: p.passportNumber,
+      passportCountry: p.passportCountry,
+      verifaydaVerified: p.verifaydaVerified,
+      verifaydaData: p.verifaydaData,
+      fareMinor: p.category === PassengerCategory.ADULT ? fare.baseFareMinor : (fare.paidChildrenCount > 0 ? fare.baseFareMinor : 0),
+      displayCurrency,
+    });
+
+    const booking = await this.prisma.booking.create({
+      data: {
+        bookingRef: generateRef(),
+        passengerId: dto.passengerId,
+        scheduleId: dto.scheduleId,
+        status: 'PENDING_PAYMENT',
+        bookingType: 'ROUND_TRIP_TRANSIT',
+        totalMinor, adultCount, childCount, displayCurrency, displayTotalMinor,
+        // Outbound transit leg-2
+        leg2ScheduleId: dto.leg2ScheduleId,
+        leg2OriginStationId: dto.transitStationId,
+        leg2DestinationStationId: dto.leg2DestinationStationId,
+        leg2SeatClassId: obL2SeatClassId,
+        // Return transit
+        returnScheduleId: dto.returnScheduleId,
+        returnOriginStationId: dto.returnOriginStationId,
+        returnDestinationStationId: dto.returnDestinationStationId,
+        returnSeatClassId: retL1SeatClassId,
+        returnLeg2ScheduleId: dto.returnLeg2ScheduleId,
+        returnLeg2OriginStationId: dto.returnTransitStationId,
+        returnLeg2DestStationId: dto.returnLeg2DestinationStationId,
+        returnLeg2SeatClassId: retL2SeatClassId,
+        returnLegStatus: 'NEITHER_USED',
+        seats: {
+          create: [
+            // Outbound leg-1 (sequence 1)
+            ...passengersData.map(p => makeSeat(p, p.outboundSeatId, 1, dto.scheduleId, obL1Fare)),
+            // Outbound leg-2 (sequence 2)
+            ...passengersData.map(p => makeSeat(p, p.outboundLeg2SeatId ?? p.outboundSeatId, 2, dto.leg2ScheduleId!, obL2Fare)),
+            // Return leg-1 (sequence 3)
+            ...passengersData.map(p => makeSeat(p, p.returnSeatId, 3, dto.returnScheduleId!, retL1Fare)),
+            // Return leg-2 (sequence 4)
+            ...passengersData.map(p => makeSeat(p, p.returnLeg2SeatId ?? p.returnSeatId, 4, dto.returnLeg2ScheduleId!, retL2Fare)),
+          ],
+        },
+      } as any,
+      include: { seats: { include: { seat: true } }, schedule: { include: { originStation: true, destinationStation: true, train: true } } },
+    });
+
+    await Promise.all([
+      this.seatsService.confirmSeats(passengersData.map(p => p.outboundSeatId)),
+      this.seatsService.confirmSeats(passengersData.map(p => p.outboundLeg2SeatId ?? p.outboundSeatId)),
+      this.seatsService.confirmSeats(passengersData.map(p => p.returnSeatId)),
+      this.seatsService.confirmSeats(passengersData.map(p => p.returnLeg2SeatId ?? p.returnSeatId)),
+    ]);
+    this.eventEmitter.emit('booking.created', { booking });
+
+    return {
+      ...booking,
+      fareBreakdown: {
+        outboundLeg1FareMinor: obL1Fare.baseFareMinor,
+        outboundLeg2FareMinor: obL2Fare.baseFareMinor,
+        returnLeg1FareMinor:   retL1Fare.baseFareMinor,
+        returnLeg2FareMinor:   retL2Fare.baseFareMinor,
+        adultCount, childCount,
+        freeChildrenCount: Math.min(childCount, 1),
+        paidChildrenCount: obL1Fare.paidChildrenCount,
+        combinedBaseFareMinor: combinedBase,
+        discountMinor, loyaltyRedemptionMinor: loyaltyMinor,
+        taxesFeesMinor: taxesMinor, totalMinor,
+        currency: 'ETB', displayCurrency, displayTotalMinor,
+      },
+    };
+  }
+
+  private async processPassengers(passengers: any[]) {
+    const processedPassengers = [];
+    for (const passenger of passengers) {
       const dateOfBirth = new Date(passenger.dateOfBirth);
       const age = calculateAge(dateOfBirth);
       const category: PassengerCategory = age < 5 ? PassengerCategory.CHILD : PassengerCategory.ADULT;
-      if (category === PassengerCategory.ADULT) adultCount++; else childCount++;
 
       let passengerName = passenger.passengerName;
       let verifaydaVerified = false;
@@ -309,68 +803,93 @@ export class BookingsService {
         nationality = nationality || (passenger.passportCountry === 'Djibouti' ? 'Djiboutian' : 'Other');
       }
 
-      passengersData.push({ ...passenger, passengerName, dateOfBirth, category, verifaydaVerified, verifaydaData, nationality });
+      processedPassengers.push({ ...passenger, passengerName, dateOfBirth, category, verifaydaVerified, verifaydaData, nationality });
     }
+    return processedPassengers;
+  }
 
-    const primaryNationality = passengersData[0]?.nationality;
-    const baseFareMinor = await this.getBaseFare(dto.scheduleId, dto.seatClassId, segmentRoute, fullRoute, primaryNationality);
+  private async processRoundTripPassengers(passengers: any[]) {
+    const processedPassengers = [];
+    for (const passenger of passengers) {
+      const dateOfBirth = new Date(passenger.dateOfBirth);
+      const age = calculateAge(dateOfBirth);
+      const category: PassengerCategory = age < 5 ? PassengerCategory.CHILD : PassengerCategory.ADULT;
+
+      let passengerName = passenger.passengerName;
+      let verifaydaVerified = false;
+      let verifaydaData: Record<string, any> | undefined;
+      let nationality = passenger.nationality;
+
+      if (passenger.idDocumentType === IdDocumentType.NATIONAL_ID && passenger.idDocumentNumber) {
+        const verification = await this.verifaydaService.verifyNationalId(passenger.idDocumentNumber);
+        if (!verification.verified) throw new BadRequestException(`Verifayda verification failed for ${passenger.passengerName}: ${verification.failureReason}`);
+        passengerName = verification.passengerData?.fullName || passengerName;
+        verifaydaVerified = true;
+        verifaydaData = verification.passengerData?.profileData;
+        nationality = nationality || 'Ethiopian';
+      } else if (passenger.idDocumentType === IdDocumentType.PASSPORT) {
+        if (!passenger.passportNumber || !passenger.passportCountry) throw new BadRequestException(`Passport number and country required for ${passenger.passengerName}`);
+        nationality = nationality || (passenger.passportCountry === 'Djibouti' ? 'Djiboutian' : 'Other');
+      }
+
+      processedPassengers.push({ ...passenger, passengerName, dateOfBirth, category, verifaydaVerified, verifaydaData, nationality });
+    }
+    return processedPassengers;
+  }
+
+  private countPassengers(passengersData: any[]) {
+    let adultCount = 0, childCount = 0;
+    for (const passenger of passengersData) {
+      if (passenger.category === PassengerCategory.ADULT) adultCount++;
+      else childCount++;
+    }
+    return { adultCount, childCount };
+  }
+
+  private async calculateFare(
+    scheduleId: string,
+    seatClassId: string,
+    originStop: any,
+    destStop: any,
+    nationality?: string,
+    adultCount = 1,
+    childCount = 0,
+    promoCode?: string,
+    loyaltyRedemptionPoints?: number
+  ) {
+    const segmentRoute = `${originStop.station.code}-${destStop.station.code}`;
+    const baseFareMinor = await this.getBaseFare(scheduleId, seatClassId, segmentRoute, undefined, nationality, originStop.sequence, destStop.sequence);
+    
     const adultFareMinor = baseFareMinor * adultCount;
     const paidChildrenCount = Math.max(0, childCount - 1);
     const childFareMinor = baseFareMinor * paidChildrenCount;
     const totalBaseFareMinor = adultFareMinor + childFareMinor;
 
     let discountMinor = 0;
-    if (dto.promoCode) {
-      const promo = await this.prisma.promotion.findUnique({ where: { code: dto.promoCode } });
+    if (promoCode) {
+      const promo = await this.prisma.promotion.findUnique({ where: { code: promoCode } });
       if (promo?.active && promo.validUntil > new Date()) {
         discountMinor = promo.percentOff ? Math.round(totalBaseFareMinor * promo.percentOff / 100) : (promo.amountOffMinor ?? 0);
       }
     }
 
-    const loyaltyMinor = (dto.loyaltyRedemptionPoints ?? 0) * 10;
+    const loyaltyMinor = (loyaltyRedemptionPoints ?? 0) * 10;
     const taxesMinor = Math.round(totalBaseFareMinor * 0.05);
     const totalMinor = Math.max(0, totalBaseFareMinor - discountMinor - loyaltyMinor + taxesMinor);
 
-    const displayCurrency = dto.displayCurrency || Currency.ETB;
-    let displayTotalMinor = totalMinor;
-    if (displayCurrency !== Currency.ETB) {
-      displayTotalMinor = await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency);
-    }
-
-    const booking = await this.prisma.booking.create({
-      data: {
-        bookingRef: generateRef(),
-        passengerId: dto.passengerId,
-        scheduleId: dto.scheduleId,
-        status: 'PENDING_PAYMENT',
-        totalMinor, adultCount, childCount, displayCurrency, displayTotalMinor,
-        bookingType: dto.bookingType ?? 'ONE_WAY',
-        seats: {
-          create: passengersData.map((p) => ({
-            seat: { connect: { id: p.seatId } },
-            passengerName: p.passengerName,
-            dateOfBirth: p.dateOfBirth,
-            passengerCategory: p.category,
-            idDocumentType: p.idDocumentType,
-            idDocumentNumber: p.idDocumentType === IdDocumentType.NATIONAL_ID ? undefined : p.idDocumentNumber,
-            passportNumber: p.passportNumber,
-            passportCountry: p.passportCountry,
-            verifaydaVerified: p.verifaydaVerified,
-            verifaydaData: p.verifaydaData || undefined,
-            fareMinor: p.category === PassengerCategory.ADULT ? baseFareMinor : (paidChildrenCount > 0 ? baseFareMinor : 0),
-            displayCurrency,
-          })),
-        },
-      },
-      include: { seats: { include: { seat: true } }, schedule: { include: { originStation: true, destinationStation: true, train: true } } },
-    });
-
-    await this.seatsService.confirmSeats(seatIds);
-    this.eventEmitter.emit('booking.created', { booking });
-
     return {
-      ...booking,
-      fareBreakdown: { baseFareMinor, adultCount, adultFareMinor, childCount, freeChildrenCount: Math.min(childCount, 1), paidChildrenCount, childFareMinor, totalBaseFareMinor, discountMinor, loyaltyRedemptionMinor: loyaltyMinor, taxesFeesMinor: taxesMinor, totalMinor, currency: 'ETB', displayCurrency, displayTotalMinor },
+      baseFareMinor,
+      adultCount,
+      adultFareMinor,
+      childCount,
+      freeChildrenCount: Math.min(childCount, 1),
+      paidChildrenCount,
+      childFareMinor,
+      totalBaseFareMinor,
+      discountMinor,
+      loyaltyRedemptionMinor: loyaltyMinor,
+      taxesFeesMinor: taxesMinor,
+      totalMinor
     };
   }
 
@@ -380,28 +899,73 @@ export class BookingsService {
     segmentRoute?: string,
     fullRoute?: string,
     nationality?: string,
+    originStopSeq?: number,
+    destStopSeq?: number,
   ): Promise<number> {
     const now = new Date();
+
+    // 1. SegmentFareRule — most specific explicit price
+    const schedule = await this.prisma.trainSchedule.findUnique({
+      where: { id: scheduleId },
+      select: { routeId: true, originStationId: true, destinationStationId: true },
+    });
+
+    if (schedule?.routeId && originStopSeq !== undefined && destStopSeq !== undefined) {
+      const segmentFare = await this.prisma.segmentFareRule.findFirst({
+        where: {
+          routeId: schedule.routeId,
+          originStopSequence: originStopSeq,
+          destinationStopSequence: destStopSeq,
+          seatClassId,
+          nationality: nationality ?? null,
+          validFrom: { lte: now },
+          OR: [{ validUntil: null }, { validUntil: { gte: now } }],
+        },
+      }) ?? (nationality ? await this.prisma.segmentFareRule.findFirst({
+        where: {
+          routeId: schedule.routeId,
+          originStopSequence: originStopSeq,
+          destinationStopSequence: destStopSeq,
+          seatClassId,
+          nationality: null,
+          validFrom: { lte: now },
+          OR: [{ validUntil: null }, { validUntil: { gte: now } }],
+        },
+      }) : null);
+
+      if (segmentFare) return segmentFare.baseFareMinor;
+    }
+
+    // 2. FareRule table — explicit override rules
     const candidates = await this.prisma.fareRule.findMany({
       where: {
         seatClassId,
         validFrom: { lte: now },
-        OR: [
-          { validUntil: null },
-          { validUntil: { gte: now } },
-        ],
+        OR: [{ validUntil: null }, { validUntil: { gte: now } }],
       },
     });
+    const bestMatch = this.selectBestFareRule(candidates, scheduleId, segmentRoute, fullRoute, nationality);
+    if (bestMatch) return bestMatch.baseFareMinor;
 
-    const bestMatch = this.selectBestFareRule(
-      candidates,
-      scheduleId,
-      segmentRoute,
-      fullRoute,
-      nationality,
+    // 3. FareEngine — distance × rate-per-km from the schedule's route
+    if (schedule?.routeId) {
+      try {
+        const fare = await this.fareEngine.calculate({
+          routeId: schedule.routeId,
+          originStationId: schedule.originStationId,
+          destinationStationId: schedule.destinationStationId,
+          seatClassId,
+          nationality,
+        });
+        return fare.baseFarePerPassengerMinor;
+      } catch {
+        // FareEngine throws if distanceKm is missing; fall through to error
+      }
+    }
+
+    throw new BadRequestException(
+      `No fare configured for this schedule and seat class. Please set up fare rules or route distances.`,
     );
-
-    return bestMatch?.baseFareMinor ?? 35000;
   }
 
   async getByRef(bookingRef: string) {
@@ -409,7 +973,7 @@ export class BookingsService {
       where: { bookingRef },
       include: {
         schedule: { include: { originStation: true, destinationStation: true, train: true } },
-        seats: { include: { seat: { include: { coach: { include: { seatClass: true } } } } } },
+        seats: { include: { seat: { include: { coach: true } } } },
         paymentIntent: true, ticket: true,
       },
     });
@@ -418,14 +982,18 @@ export class BookingsService {
       id: booking.id, bookingRef: booking.bookingRef, status: booking.status,
       totalFare: booking.totalMinor / 100, adultCount: booking.adultCount, childCount: booking.childCount,
       displayCurrency: booking.displayCurrency, displayTotalFare: booking.displayTotalMinor ? booking.displayTotalMinor / 100 : undefined,
-      bookingType: booking.bookingType, createdAt: booking.createdAt,
+      bookingType: booking.bookingType,
+      returnLegStatus: (booking as any).returnLegStatus ?? null,
+      outboundBoardedAt: (booking as any).outboundBoardedAt ?? null,
+      returnBoardedAt: (booking as any).returnBoardedAt ?? null,
+      createdAt: booking.createdAt,
       schedule: {
         number: booking.schedule.train.number,
         origin: { id: booking.schedule.originStation.id, name: booking.schedule.originStation.name, code: booking.schedule.originStation.code, city: booking.schedule.originStation.city },
         destination: { id: booking.schedule.destinationStation.id, name: booking.schedule.destinationStation.name, code: booking.schedule.destinationStation.code, city: booking.schedule.destinationStation.city },
         departureAt: booking.schedule.departureAt, arrivalAt: booking.schedule.arrivalAt,
       },
-      passengers: booking.seats.map((bs) => ({
+      passengers: booking.seats?.map((bs: any) => ({
         fullName: bs.passengerName, category: bs.passengerCategory, verifaydaVerified: bs.verifaydaVerified,
         seat: { number: bs.seat.label, coach: bs.seat.coach.label, class: bs.seat.coach.seatClass.name },
       })),
@@ -456,6 +1024,7 @@ export class BookingsService {
     await this.prisma.bookingCancellation.create({ data: { bookingId: booking.id, cancelledBy: booking.passengerId, reason, refundAmount, refundMethod: booking.paymentIntent?.method ?? 'ORIGINAL', refundStatus: 'PENDING' } });
     await this.seatsService.releaseSeats(booking.seats.map((s) => s.seatId));
     await this.prisma.booking.update({ where: { bookingRef }, data: { status: 'CANCELLED' } });
+    this.eventEmitter.emit('booking.cancelled', { booking, refundAmount });
     return { cancelled: true, refundAmount: refundAmount / 100, currency: 'ETB' };
   }
 
@@ -523,6 +1092,37 @@ export class BookingsService {
     }
   }
 
+  // Mark round-trip bookings where the return train has departed but the return leg
+  // was never scanned. Runs every minute; only acts on CONFIRMED bookings whose
+  // returnSchedule.departureAt is in the past and returnBoardedAt is still null.
+  @Cron(CronExpression.EVERY_MINUTE)
+  async markReturnLegNoShows() {
+    const now = new Date();
+    const graceCutoff = new Date(now.getTime() - 30 * 60 * 1000);
+
+    const candidates = await this.prisma.booking.findMany({
+      where: {
+        bookingType: 'ROUND_TRIP',
+        status: 'CONFIRMED',
+        returnLegStatus: 'NEITHER_USED' as any,
+        outboundBoardedAt: { not: null },
+        returnBoardedAt: null,
+        returnScheduleId: { not: null },
+      },
+      include: { returnSchedule: { select: { departureAt: true } } },
+    } as any);
+
+    for (const b of candidates) {
+      const returnDep: Date | undefined = (b as any).returnSchedule?.departureAt;
+      if (returnDep && returnDep < graceCutoff) {
+        await this.prisma.booking.update({
+          where: { id: b.id },
+          data: { returnLegStatus: 'OUTBOUND_ONLY' } as any,
+        });
+      }
+    }
+  }
+
   private selectBestFareRule(
     candidates: any[],
     scheduleId: string,

apps/edr-passenger-api/src/modules/bookings/guest-booking.dto.ts

@@ -4,9 +4,18 @@ import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Currency, IdDocumentType } from '@prisma/client';
 
 export class GuestPassengerDto {
-  @ApiProperty({ example: 'seat-id-uuid' }) 
+  @ApiProperty({ example: 'seat-uuid', description: 'Outbound / leg-1 seat ID (all booking types)' }) 
   @IsString() seatId: string;
 
+  @ApiPropertyOptional({ example: 'return-seat-uuid', description: '**ROUND_TRIP / ROUND_TRIP_TRANSIT:** Return leg-1 seat ID. Required for ROUND_TRIP and ROUND_TRIP_TRANSIT.' })
+  @IsOptional() @IsString() returnSeatId?: string;
+
+  @ApiPropertyOptional({ example: 'leg2-seat-uuid', description: '**TRANSIT / ROUND_TRIP_TRANSIT:** Outbound leg-2 seat ID. Required for TRANSIT and ROUND_TRIP_TRANSIT.' })
+  @IsOptional() @IsString() leg2SeatId?: string;
+
+  @ApiPropertyOptional({ example: 'ret-leg2-seat-uuid', description: '**ROUND_TRIP_TRANSIT:** Return leg-2 seat ID. Required for ROUND_TRIP_TRANSIT.' })
+  @IsOptional() @IsString() returnLeg2SeatId?: string;
+
   @ApiProperty({ example: 'Abebe Kebede' }) 
   @IsString() passengerName: string;
 
@@ -36,24 +45,88 @@ export class GuestPassengerDto {
 }
 
 export class CreateGuestBookingDto {
-  @ApiProperty({ example: 'schedule-uuid' }) 
+  @ApiPropertyOptional({ 
+    example: 'ONE_WAY', 
+    enum: ['ONE_WAY', 'ROUND_TRIP', 'TRANSIT', 'ROUND_TRIP_TRANSIT'], 
+    default: 'ONE_WAY',
+    description: `Booking type:
+**ONE_WAY:** scheduleId + holdId. Passenger: seatId.
+**ROUND_TRIP:** above + returnScheduleId/returnHoldId/returnOriginStationId/returnDestinationStationId. Passenger: seatId + returnSeatId.
+**TRANSIT:** above + leg2ScheduleId/leg2HoldId/transitStationId/leg2DestinationStationId. Passenger: seatId + leg2SeatId.
+**ROUND_TRIP_TRANSIT:** all 4 hold sets + all station fields. Passenger: seatId + leg2SeatId + returnSeatId + returnLeg2SeatId.`
+  })
+  @IsOptional() @IsString() bookingType?: 'ONE_WAY' | 'ROUND_TRIP' | 'TRANSIT' | 'ROUND_TRIP_TRANSIT';
+
+  @ApiProperty({ example: 'schedule-uuid', description: 'Outbound / leg-1 schedule UUID' }) 
   @IsString() scheduleId: string;
 
-  @ApiProperty({ example: 'hold-uuid' }) 
+  @ApiProperty({ example: 'hold-uuid', description: 'Outbound seat hold UUID' }) 
   @IsString() holdId: string;
 
-  @ApiProperty({ example: 'station-uuid', description: 'Origin station UUID' }) 
+  @ApiProperty({ example: 'station-uuid', description: 'Outbound origin station UUID' }) 
   @IsString() originStationId: string;
 
-  @ApiProperty({ example: 'station-uuid', description: 'Destination station UUID' }) 
+  @ApiProperty({ example: 'station-uuid', description: 'Outbound destination station UUID' }) 
   @IsString() destinationStationId: string;
 
-  @ApiProperty({ type: [GuestPassengerDto], description: 'Array of passengers. First passenger details used for contact.' }) 
-  @IsArray() @ValidateNested({ each: true }) @Type(() => GuestPassengerDto) passengers: GuestPassengerDto[];
-
-  @ApiProperty({ example: 'seat-class-uuid', description: 'Seat class UUID' })
+  @ApiProperty({ example: 'seat-class-uuid', description: 'Outbound seat class UUID' })
   @IsString() seatClassId: string;
 
+  @ApiPropertyOptional({ example: 'seat-class-uuid', description: 'ROUND_TRIP / ROUND_TRIP_TRANSIT: return seat class UUID' })
+  @IsOptional() @IsString() returnSeatClassId?: string;
+
+  @ApiPropertyOptional({ example: 'schedule-uuid', description: 'TRANSIT / ROUND_TRIP_TRANSIT: leg-2 schedule UUID' })
+  @IsOptional() @IsString() leg2ScheduleId?: string;
+
+  @ApiPropertyOptional({ example: 'hold-uuid', description: 'TRANSIT / ROUND_TRIP_TRANSIT: leg-2 seat hold UUID' })
+  @IsOptional() @IsString() leg2HoldId?: string;
+
+  @ApiPropertyOptional({ example: 'station-uuid', description: 'TRANSIT / ROUND_TRIP_TRANSIT: connecting station UUID' })
+  @IsOptional() @IsString() transitStationId?: string;
+
+  @ApiPropertyOptional({ example: 'station-uuid', description: 'TRANSIT / ROUND_TRIP_TRANSIT: leg-2 destination station UUID' })
+  @IsOptional() @IsString() leg2DestinationStationId?: string;
+
+  @ApiPropertyOptional({ example: 'seat-class-uuid', description: 'TRANSIT / ROUND_TRIP_TRANSIT: leg-2 seat class UUID' })
+  @IsOptional() @IsString() leg2SeatClassId?: string;
+
+  @ApiPropertyOptional({ example: 'schedule-uuid', description: 'ROUND_TRIP / ROUND_TRIP_TRANSIT: return leg-1 schedule UUID' })
+  @IsOptional() @IsString() returnScheduleId?: string;
+
+  @ApiPropertyOptional({ example: 'hold-uuid', description: 'ROUND_TRIP / ROUND_TRIP_TRANSIT: return seat hold UUID' })
+  @IsOptional() @IsString() returnHoldId?: string;
+
+  @ApiPropertyOptional({ example: 'station-uuid', description: 'ROUND_TRIP / ROUND_TRIP_TRANSIT: return origin station UUID' })
+  @IsOptional() @IsString() returnOriginStationId?: string;
+
+  @ApiPropertyOptional({ example: 'station-uuid', description: 'ROUND_TRIP / ROUND_TRIP_TRANSIT: return destination station UUID' })
+  @IsOptional() @IsString() returnDestinationStationId?: string;
+
+  @ApiPropertyOptional({ example: 'schedule-uuid', description: 'ROUND_TRIP_TRANSIT: return leg-2 schedule UUID' })
+  @IsOptional() @IsString() returnLeg2ScheduleId?: string;
+
+  @ApiPropertyOptional({ example: 'hold-uuid', description: 'ROUND_TRIP_TRANSIT: return leg-2 seat hold UUID' })
+  @IsOptional() @IsString() returnLeg2HoldId?: string;
+
+  @ApiPropertyOptional({ example: 'station-uuid', description: 'ROUND_TRIP_TRANSIT: return transit station UUID' })
+  @IsOptional() @IsString() returnTransitStationId?: string;
+
+  @ApiPropertyOptional({ example: 'station-uuid', description: 'ROUND_TRIP_TRANSIT: return leg-2 destination station UUID' })
+  @IsOptional() @IsString() returnLeg2DestinationStationId?: string;
+
+  @ApiPropertyOptional({ example: 'seat-class-uuid', description: 'ROUND_TRIP_TRANSIT: return leg-2 seat class UUID' })
+  @IsOptional() @IsString() returnLeg2SeatClassId?: string;
+
+  @ApiProperty({ 
+    type: [GuestPassengerDto], 
+    description: `Passenger array. Required seat fields vary by bookingType:
+- ONE_WAY: seatId
+- ROUND_TRIP: seatId + returnSeatId
+- TRANSIT: seatId + leg2SeatId
+- ROUND_TRIP_TRANSIT: seatId + leg2SeatId + returnSeatId + returnLeg2SeatId` 
+  }) 
+  @IsArray() @ValidateNested({ each: true }) @Type(() => GuestPassengerDto) passengers: GuestPassengerDto[];
+
   @ApiPropertyOptional({ example: 'WEEKEND15' }) 
   @IsOptional() @IsString() promoCode?: string;
 
@@ -66,7 +139,7 @@ export class CreateGuestBookingDto {
   @ApiPropertyOptional({ example: 'password123', description: 'Password if createAccount is true' }) 
   @IsOptional() @IsString() password?: string;
 
-  @ApiPropertyOptional({ example: true, description: 'Save passenger details for future bookings (requires createAccount)' }) 
+  @ApiPropertyOptional({ example: true, description: 'Save passenger details for future bookings' }) 
   @IsOptional() @IsBoolean() savePassengerDetails?: boolean;
 
   @ApiPropertyOptional({ example: 'device-uuid-12345', description: 'Device ID for local storage of passenger details' }) 

apps/edr-passenger-api/src/modules/bookings/guest-booking.service.ts

@@ -4,6 +4,7 @@ import { SeatsService } from '../seats/seats.service';
 import { VerifaydaService } from '../verifayda/verifayda.service';
 import { CurrencyService } from '../currency/currency.service';
 import { PassengerAuthService } from '../auth/passenger-auth.service';
+import { FareEngineService } from '../fare-engine/fare-engine.service';
 import { EventEmitter2 } from '@nestjs/event-emitter';
 import { CreateGuestBookingDto, SavedPassengerProfileDto } from './guest-booking.dto';
 import { Currency, PassengerCategory, IdDocumentType } from '@prisma/client';
@@ -29,10 +30,18 @@ export class GuestBookingService {
     private verifaydaService: VerifaydaService,
     private currencyService: CurrencyService,
     private passengerAuthService: PassengerAuthService,
+    private fareEngine: FareEngineService,
     private eventEmitter: EventEmitter2,
   ) {}
 
-  async createGuestBooking(dto: CreateGuestBookingDto, req: any) {
+  async createGuestBooking(dto: CreateGuestBookingDto, req?: any) {
+    if (dto.bookingType === 'ROUND_TRIP')         return this.createGuestRoundTripBooking(dto, req);
+    if (dto.bookingType === 'TRANSIT')            return this.createGuestTransitBooking(dto, req);
+    if (dto.bookingType === 'ROUND_TRIP_TRANSIT') return this.createGuestRoundTripTransitBooking(dto, req);
+    return this.createGuestOneWayBooking(dto, req);
+  }
+
+  private async createGuestOneWayBooking(dto: CreateGuestBookingDto, req?: any) {
     // Validate hold
     const hold = await this.prisma.seatHold.findUnique({ where: { id: dto.holdId } });
     if (!hold || hold.expiresAt < new Date()) {
@@ -147,39 +156,7 @@ export class GuestBookingService {
 
     // Resolve or create the guest Passenger record
     const firstPassenger = passengersData[0];
-    let guestPassengerId: string;
-    let iamUserId: string | null = null;
-    let createdAccount = false;
-
-    if (dto.createAccount && firstPassenger.email && dto.password) {
-      // Delegate full IAM account creation to PassengerAuthService
-      const guestName = firstPassenger.passengerName ?? 'Guest';
-      const result = await this.passengerAuthService.register(
-        {
-          email: firstPassenger.email,
-          username: firstPassenger.email,
-          phoneNumber: firstPassenger.phone || `+251900000000`,
-          name: { en: guestName, am: guestName },
-          password: dto.password,
-          confirmPassword: dto.password,
-        },
-        req,
-      );
-      guestPassengerId = result.user.passengerId;
-      iamUserId = result.user.iamUserId;
-      createdAccount = true;
-    } else {
-      // Anonymous guest — Passenger with no User, no IAM account
-      const guestPassenger = await this.prisma.passenger.create({
-        data: {
-          // userId intentionally omitted — guest has no local User or IAM account
-          ...(dto.deviceId ? {} : {}),
-        },
-      });
-      await this.prisma.loyaltyAccount.create({ data: { passengerId: guestPassenger.id, pointsBalance: 0, tier: 'BRONZE' } });
-      await this.prisma.walletAccount.create({ data: { passengerId: guestPassenger.id, balanceMinor: 0 } });
-      guestPassengerId = guestPassenger.id;
-    }
+    const { guestPassengerId, iamUserId, createdAccount } = await this.resolveGuestPassenger(dto, firstPassenger, req);
 
     // Save passenger details for future use (if requested)
     if (dto.savePassengerDetails && (dto.createAccount || dto.deviceId)) {
@@ -264,6 +241,618 @@ export class GuestBookingService {
     };
   }
 
+  private async createGuestRoundTripBooking(dto: CreateGuestBookingDto, req?: any) {
+    if (!dto.returnScheduleId || !dto.returnHoldId || !dto.returnOriginStationId || !dto.returnDestinationStationId) {
+      throw new BadRequestException('returnScheduleId, returnHoldId, returnOriginStationId and returnDestinationStationId are required for ROUND_TRIP');
+    }
+
+    // Validate both holds
+    const [outboundHold, returnHold] = await Promise.all([
+      this.prisma.seatHold.findUnique({ where: { id: dto.holdId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.returnHoldId } }),
+    ]);
+    if (!outboundHold || outboundHold.expiresAt < new Date()) throw new BadRequestException('Outbound seat hold expired or not found');
+    if (!returnHold   || returnHold.expiresAt   < new Date()) throw new BadRequestException('Return seat hold expired or not found');
+
+    // Validate passengers have returnSeatId
+    for (const p of dto.passengers) {
+      if (!p.returnSeatId) throw new BadRequestException(`returnSeatId is required for each passenger in a ROUND_TRIP booking (missing for ${p.passengerName})`);
+    }
+
+    // Load both schedules
+    const [outboundSchedule, returnSchedule] = await Promise.all([
+      this.prisma.trainSchedule.findUnique({
+        where: { id: dto.scheduleId },
+        include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } },
+      }),
+      this.prisma.trainSchedule.findUnique({
+        where: { id: dto.returnScheduleId },
+        include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } },
+      }),
+    ]);
+    if (!outboundSchedule) throw new NotFoundException('Outbound schedule not found');
+    if (!returnSchedule)   throw new NotFoundException('Return schedule not found');
+
+    const outboundOriginStop = outboundSchedule.stopTimes.find(s => s.stationId === dto.originStationId);
+    const outboundDestStop   = outboundSchedule.stopTimes.find(s => s.stationId === dto.destinationStationId);
+    const returnOriginStop   = returnSchedule.stopTimes.find(s => s.stationId === dto.returnOriginStationId);
+    const returnDestStop     = returnSchedule.stopTimes.find(s => s.stationId === dto.returnDestinationStationId);
+    if (!outboundOriginStop || !outboundDestStop) throw new NotFoundException('Outbound origin or destination not found on schedule');
+    if (!returnOriginStop   || !returnDestStop)   throw new NotFoundException('Return origin or destination not found on schedule');
+
+    const outboundSegmentRoute = `${outboundOriginStop.station.code}-${outboundDestStop.station.code}`;
+    const outboundFullRoute    = `${outboundSchedule.originStation.code}-${outboundSchedule.destinationStation.code}`;
+    const returnSegmentRoute   = `${returnOriginStop.station.code}-${returnDestStop.station.code}`;
+    const returnFullRoute      = `${returnSchedule.originStation.code}-${returnSchedule.destinationStation.code}`;
+
+    // Process passengers (verify identity once — same person travels both legs)
+    const passengersData: any[] = [];
+    let adultCount = 0, childCount = 0;
+
+    for (const passenger of dto.passengers) {
+      const dateOfBirth = new Date(passenger.dateOfBirth);
+      const age = calculateAge(dateOfBirth);
+      const category: PassengerCategory = age < 5 ? PassengerCategory.CHILD : PassengerCategory.ADULT;
+      if (category === PassengerCategory.ADULT) adultCount++; else childCount++;
+
+      let passengerName = passenger.passengerName;
+      let verifaydaVerified = false;
+      let verifaydaData: Record<string, any> | undefined;
+      let nationality = passenger.nationality;
+
+      const isEthiopian = passenger.nationality === 'Ethiopian' ||
+                          passenger.nationality === 'ETHIOPIAN' ||
+                          passenger.idDocumentType === IdDocumentType.NATIONAL_ID;
+
+      if (isEthiopian && passenger.idDocumentType === IdDocumentType.NATIONAL_ID) {
+        if (passenger.idDocumentNumber) {
+          const verification = await this.verifaydaService.verifyNationalId(passenger.idDocumentNumber);
+          if (!verification.verified) throw new BadRequestException(`Verifayda verification failed for ${passenger.passengerName}: ${verification.failureReason}`);
+          passengerName     = verification.passengerData?.fullName || passengerName;
+          verifaydaVerified = true;
+          verifaydaData     = verification.passengerData?.profileData;
+        }
+        nationality = 'Ethiopian';
+      } else if (!isEthiopian && passenger.idDocumentType === IdDocumentType.PASSPORT) {
+        if (!passenger.passportNumber || !passenger.passportCountry) throw new BadRequestException(`Passport number and country required for ${passenger.passengerName}`);
+        nationality = nationality || (passenger.passportCountry === 'Djibouti' ? 'Djiboutian' : 'Other');
+      } else if (isEthiopian && passenger.idDocumentType === IdDocumentType.PASSPORT) {
+        nationality = 'Ethiopian';
+      } else {
+        nationality = nationality || 'Other';
+      }
+
+      passengersData.push({ ...passenger, passengerName, dateOfBirth, category, verifaydaVerified, verifaydaData, nationality });
+    }
+
+    // Calculate fares for both legs
+    const returnSeatClassId = dto.returnSeatClassId || dto.seatClassId;
+    const primaryNationality = passengersData[0]?.nationality;
+
+    const [outboundBaseFare, returnBaseFare] = await Promise.all([
+      this.getBaseFare(dto.scheduleId, dto.seatClassId, outboundSegmentRoute, outboundFullRoute, primaryNationality),
+      this.getBaseFare(dto.returnScheduleId, returnSeatClassId, returnSegmentRoute, returnFullRoute, primaryNationality),
+    ]);
+
+    const paidChildrenCount      = Math.max(0, childCount - 1);
+    const outboundTotalBase      = outboundBaseFare * adultCount + outboundBaseFare * paidChildrenCount;
+    const returnTotalBase        = returnBaseFare  * adultCount + returnBaseFare  * paidChildrenCount;
+    const combinedBaseFareMinor  = outboundTotalBase + returnTotalBase;
+
+    let discountMinor = 0;
+    if (dto.promoCode) {
+      const promo = await this.prisma.promotion.findUnique({ where: { code: dto.promoCode } });
+      if (promo?.active && promo.validUntil > new Date()) {
+        discountMinor = promo.percentOff
+          ? Math.round(combinedBaseFareMinor * promo.percentOff / 100)
+          : (promo.amountOffMinor ?? 0);
+      }
+    }
+
+    const taxesMinor = Math.round(combinedBaseFareMinor * 0.05);
+    const totalMinor = Math.max(0, combinedBaseFareMinor - discountMinor + taxesMinor);
+
+    const displayCurrency = dto.displayCurrency || Currency.ETB;
+    const displayTotalMinor = displayCurrency !== Currency.ETB
+      ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
+      : totalMinor;
+
+    // Create or resolve guest passenger (same as one-way)
+    const { guestPassengerId, iamUserId, createdAccount } = await this.resolveGuestPassenger(dto, passengersData[0], req);
+
+    // Create booking with outbound seats; return seats confirmed separately
+    const outboundSeatIds = dto.passengers.map(p => p.seatId);
+    const returnSeatIds   = dto.passengers.map(p => p.returnSeatId!);
+
+    const booking = await this.prisma.booking.create({
+      data: {
+        bookingRef:                  generateRef(),
+        passengerId:                 guestPassengerId,
+        scheduleId:                  dto.scheduleId,
+        status:                      'PENDING_PAYMENT',
+        bookingType:                 'ROUND_TRIP',
+        totalMinor,
+        adultCount,
+        childCount,
+        displayCurrency,
+        displayTotalMinor,
+        returnScheduleId:            dto.returnScheduleId,
+        returnOriginStationId:       dto.returnOriginStationId,
+        returnDestinationStationId:  dto.returnDestinationStationId,
+        returnHoldId:                dto.returnHoldId,
+        returnSeatClassId,
+        returnLegStatus:             'NEITHER_USED',
+        userAgent:                   dto.deviceId,
+        seats: {
+          create: [
+            ...passengersData.map((p) => ({
+              seat:              { connect: { id: p.seatId } },
+              leg:               1,
+              scheduleId:        dto.scheduleId,
+              passengerName:     p.passengerName,
+              dateOfBirth:       p.dateOfBirth,
+              passengerCategory: p.category,
+              idDocumentType:    p.idDocumentType,
+              passportNumber:    p.passportNumber,
+              passportCountry:   p.passportCountry,
+              verifaydaVerified: p.verifaydaVerified,
+              verifaydaData:     p.verifaydaData || undefined,
+              fareMinor:         p.category === PassengerCategory.ADULT ? outboundBaseFare : (paidChildrenCount > 0 ? outboundBaseFare : 0),
+              displayCurrency,
+            })),
+            ...passengersData.map((p) => ({
+              seat:              { connect: { id: p.returnSeatId } },
+              leg:               2,
+              scheduleId:        dto.returnScheduleId,
+              passengerName:     p.passengerName,
+              dateOfBirth:       p.dateOfBirth,
+              passengerCategory: p.category,
+              idDocumentType:    p.idDocumentType,
+              passportNumber:    p.passportNumber,
+              passportCountry:   p.passportCountry,
+              verifaydaVerified: p.verifaydaVerified,
+              verifaydaData:     p.verifaydaData || undefined,
+              fareMinor:         p.category === PassengerCategory.ADULT ? returnBaseFare : (paidChildrenCount > 0 ? returnBaseFare : 0),
+              displayCurrency,
+            })),
+          ],
+        },
+      } as any,
+      include: {
+        seats:    { include: { seat: { include: { coach: true } } } },
+        schedule: { include: { originStation: true, destinationStation: true, train: true } },
+      },
+    });
+
+    await Promise.all([
+      this.seatsService.confirmSeats(outboundSeatIds),
+      this.seatsService.confirmSeats(returnSeatIds),
+    ]);
+    this.eventEmitter.emit('booking.created', { booking });
+
+    return {
+      ...booking,
+      createdAccount,
+      iamUserId,
+      fareBreakdown: {
+        outboundBaseFareMinor: outboundBaseFare,
+        returnBaseFareMinor:   returnBaseFare,
+        adultCount,
+        childCount,
+        freeChildrenCount:     Math.min(childCount, 1),
+        paidChildrenCount,
+        combinedBaseFareMinor,
+        discountMinor,
+        taxesFeesMinor:        taxesMinor,
+        totalMinor,
+        currency:              'ETB',
+        displayCurrency,
+        displayTotalMinor,
+      },
+    };
+  }
+
+  private async createGuestTransitBooking(dto: CreateGuestBookingDto, req?: any) {
+    if (!dto.leg2ScheduleId || !dto.leg2HoldId || !dto.transitStationId || !dto.leg2DestinationStationId) {
+      throw new BadRequestException('leg2ScheduleId, leg2HoldId, transitStationId and leg2DestinationStationId are required for TRANSIT bookings');
+    }
+
+    const [leg1Hold, leg2Hold] = await Promise.all([
+      this.prisma.seatHold.findUnique({ where: { id: dto.holdId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.leg2HoldId } }),
+    ]);
+    if (!leg1Hold || leg1Hold.expiresAt < new Date()) throw new BadRequestException('Leg-1 seat hold expired or not found');
+    if (!leg2Hold || leg2Hold.expiresAt < new Date()) throw new BadRequestException('Leg-2 seat hold expired or not found');
+
+    for (const p of dto.passengers) {
+      if (!p.leg2SeatId) throw new BadRequestException(`leg2SeatId is required for each passenger in a TRANSIT booking (missing for ${p.passengerName})`);
+    }
+
+    const [leg1Schedule, leg2Schedule] = await Promise.all([
+      this.prisma.trainSchedule.findUnique({
+        where: { id: dto.scheduleId },
+        include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } },
+      }),
+      this.prisma.trainSchedule.findUnique({
+        where: { id: dto.leg2ScheduleId },
+        include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } },
+      }),
+    ]);
+    if (!leg1Schedule) throw new NotFoundException('Leg-1 schedule not found');
+    if (!leg2Schedule) throw new NotFoundException('Leg-2 schedule not found');
+
+    const leg1OriginStop = leg1Schedule.stopTimes.find(s => s.stationId === dto.originStationId);
+    const leg1DestStop   = leg1Schedule.stopTimes.find(s => s.stationId === dto.transitStationId);
+    const leg2OriginStop = leg2Schedule.stopTimes.find(s => s.stationId === dto.transitStationId);
+    const leg2DestStop   = leg2Schedule.stopTimes.find(s => s.stationId === dto.leg2DestinationStationId);
+    if (!leg1OriginStop || !leg1DestStop) throw new NotFoundException('Leg-1 origin or transit station not found on schedule');
+    if (!leg2OriginStop || !leg2DestStop) throw new NotFoundException('Transit or leg-2 destination not found on leg-2 schedule');
+
+    // Process passengers (verify identity once)
+    const passengersData: any[] = [];
+    let adultCount = 0, childCount = 0;
+    for (const passenger of dto.passengers) {
+      const dateOfBirth = new Date(passenger.dateOfBirth);
+      const age = calculateAge(dateOfBirth);
+      const category: PassengerCategory = age < 5 ? PassengerCategory.CHILD : PassengerCategory.ADULT;
+      if (category === PassengerCategory.ADULT) adultCount++; else childCount++;
+
+      let passengerName = passenger.passengerName;
+      let verifaydaVerified = false;
+      let verifaydaData: Record<string, any> | undefined;
+      let nationality = passenger.nationality;
+
+      const isEthiopian = passenger.nationality === 'Ethiopian' || passenger.nationality === 'ETHIOPIAN' || passenger.idDocumentType === IdDocumentType.NATIONAL_ID;
+      if (isEthiopian && passenger.idDocumentType === IdDocumentType.NATIONAL_ID && passenger.idDocumentNumber) {
+        const verification = await this.verifaydaService.verifyNationalId(passenger.idDocumentNumber);
+        if (!verification.verified) throw new BadRequestException(`Verifayda verification failed for ${passenger.passengerName}: ${verification.failureReason}`);
+        passengerName = verification.passengerData?.fullName || passengerName;
+        verifaydaVerified = true;
+        verifaydaData = verification.passengerData?.profileData;
+        nationality = 'Ethiopian';
+      } else if (!isEthiopian && passenger.idDocumentType === IdDocumentType.PASSPORT) {
+        if (!passenger.passportNumber || !passenger.passportCountry) throw new BadRequestException(`Passport details required for ${passenger.passengerName}`);
+        nationality = nationality || (passenger.passportCountry === 'Djibouti' ? 'Djiboutian' : 'Other');
+      } else {
+        nationality = nationality || 'Other';
+      }
+      passengersData.push({ ...passenger, passengerName, dateOfBirth, category, verifaydaVerified, verifaydaData, nationality });
+    }
+
+    const leg2SeatClassId    = dto.leg2SeatClassId || dto.seatClassId;
+    const primaryNationality = passengersData[0]?.nationality;
+    const paidChildrenCount  = Math.max(0, childCount - 1);
+
+    const [leg1BaseFare, leg2BaseFare] = await Promise.all([
+      this.getBaseFare(dto.scheduleId, dto.seatClassId,
+        `${leg1OriginStop.station.code}-${leg1DestStop.station.code}`,
+        `${leg1Schedule.originStation.code}-${leg1Schedule.destinationStation.code}`,
+        primaryNationality),
+      this.getBaseFare(dto.leg2ScheduleId, leg2SeatClassId,
+        `${leg2OriginStop.station.code}-${leg2DestStop.station.code}`,
+        `${leg2Schedule.originStation.code}-${leg2Schedule.destinationStation.code}`,
+        primaryNationality),
+    ]);
+
+    const leg1Total      = leg1BaseFare * adultCount + leg1BaseFare * paidChildrenCount;
+    const leg2Total      = leg2BaseFare * adultCount + leg2BaseFare * paidChildrenCount;
+    const combinedBase   = leg1Total + leg2Total;
+
+    let discountMinor = 0;
+    if (dto.promoCode) {
+      const promo = await this.prisma.promotion.findUnique({ where: { code: dto.promoCode } });
+      if (promo?.active && promo.validUntil > new Date()) {
+        discountMinor = promo.percentOff ? Math.round(combinedBase * promo.percentOff / 100) : (promo.amountOffMinor ?? 0);
+      }
+    }
+    const taxesMinor = Math.round(combinedBase * 0.05);
+    const totalMinor = Math.max(0, combinedBase - discountMinor + taxesMinor);
+
+    const displayCurrency = dto.displayCurrency || Currency.ETB;
+    const displayTotalMinor = displayCurrency !== Currency.ETB
+      ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
+      : totalMinor;
+
+    const { guestPassengerId, iamUserId, createdAccount } = await this.resolveGuestPassenger(dto, passengersData[0], req);
+
+    // Single booking — leg-1 seats at leg=1, leg-2 seats at leg=2
+    const booking = await this.prisma.booking.create({
+      data: {
+        bookingRef:              generateRef(),
+        passengerId:             guestPassengerId,
+        scheduleId:              dto.scheduleId,
+        status:                  'PENDING_PAYMENT',
+        bookingType:             'TRANSIT',
+        totalMinor,
+        adultCount,
+        childCount,
+        displayCurrency,
+        displayTotalMinor,
+        leg2ScheduleId:          dto.leg2ScheduleId,
+        leg2OriginStationId:     dto.transitStationId,
+        leg2DestinationStationId: dto.leg2DestinationStationId,
+        leg2SeatClassId:         leg2SeatClassId,
+        userAgent:               dto.deviceId,
+        seats: {
+          create: [
+            ...passengersData.map(p => ({
+              seat:              { connect: { id: p.seatId } },
+              leg:               1,
+              scheduleId:        dto.scheduleId,
+              passengerName:     p.passengerName,
+              dateOfBirth:       p.dateOfBirth,
+              passengerCategory: p.category,
+              idDocumentType:    p.idDocumentType,
+              passportNumber:    p.passportNumber,
+              passportCountry:   p.passportCountry,
+              verifaydaVerified: p.verifaydaVerified,
+              verifaydaData:     p.verifaydaData || undefined,
+              fareMinor:         p.category === PassengerCategory.ADULT ? leg1BaseFare : (paidChildrenCount > 0 ? leg1BaseFare : 0),
+              displayCurrency,
+            })),
+            ...passengersData.map(p => ({
+              seat:              { connect: { id: p.leg2SeatId! } },
+              leg:               2,
+              scheduleId:        dto.leg2ScheduleId,
+              passengerName:     p.passengerName,
+              dateOfBirth:       p.dateOfBirth,
+              passengerCategory: p.category,
+              idDocumentType:    p.idDocumentType,
+              passportNumber:    p.passportNumber,
+              passportCountry:   p.passportCountry,
+              verifaydaVerified: p.verifaydaVerified,
+              verifaydaData:     p.verifaydaData || undefined,
+              fareMinor:         p.category === PassengerCategory.ADULT ? leg2BaseFare : (paidChildrenCount > 0 ? leg2BaseFare : 0),
+              displayCurrency,
+            })),
+          ],
+        },
+      } as any,
+      include: {
+        seats:    { include: { seat: { include: { coach: true } } } },
+        schedule: { include: { originStation: true, destinationStation: true, train: true } },
+      },
+    });
+
+    await Promise.all([
+      this.seatsService.confirmSeats(dto.passengers.map(p => p.seatId)),
+      this.seatsService.confirmSeats(dto.passengers.map(p => p.leg2SeatId!)),
+    ]);
+    this.eventEmitter.emit('booking.created', { booking });
+
+    return {
+      ...booking,
+      createdAccount,
+      iamUserId,
+      fareBreakdown: {
+        leg1BaseFareMinor: leg1BaseFare,
+        leg2BaseFareMinor: leg2BaseFare,
+        adultCount, childCount,
+        freeChildrenCount: Math.min(childCount, 1),
+        paidChildrenCount,
+        combinedBaseFareMinor: combinedBase,
+        discountMinor, taxesFeesMinor: taxesMinor, totalMinor,
+        currency: 'ETB', displayCurrency, displayTotalMinor,
+      },
+    };
+  }
+
+  private async createGuestRoundTripTransitBooking(dto: CreateGuestBookingDto, req?: any) {
+    if (!dto.leg2ScheduleId || !dto.leg2HoldId || !dto.transitStationId || !dto.leg2DestinationStationId ||
+        !dto.returnScheduleId || !dto.returnHoldId || !dto.returnOriginStationId || !dto.returnDestinationStationId ||
+        !dto.returnLeg2ScheduleId || !dto.returnLeg2HoldId || !dto.returnTransitStationId || !dto.returnLeg2DestinationStationId) {
+      throw new BadRequestException(
+        'ROUND_TRIP_TRANSIT requires all 4 holds and all transit/return station fields',
+      );
+    }
+    for (const p of dto.passengers) {
+      if (!p.leg2SeatId)      throw new BadRequestException(`leg2SeatId required for ${p.passengerName}`);
+      if (!p.returnSeatId)    throw new BadRequestException(`returnSeatId required for ${p.passengerName}`);
+      if (!p.returnLeg2SeatId) throw new BadRequestException(`returnLeg2SeatId required for ${p.passengerName}`);
+    }
+
+    const now = new Date();
+    const [obL1Hold, obL2Hold, retL1Hold, retL2Hold] = await Promise.all([
+      this.prisma.seatHold.findUnique({ where: { id: dto.holdId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.leg2HoldId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.returnHoldId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.returnLeg2HoldId } }),
+    ]);
+    if (!obL1Hold  || obL1Hold.expiresAt  < now) throw new BadRequestException('Outbound leg-1 hold expired');
+    if (!obL2Hold  || obL2Hold.expiresAt  < now) throw new BadRequestException('Outbound leg-2 hold expired');
+    if (!retL1Hold || retL1Hold.expiresAt < now) throw new BadRequestException('Return leg-1 hold expired');
+    if (!retL2Hold || retL2Hold.expiresAt < now) throw new BadRequestException('Return leg-2 hold expired');
+
+    const [obL1Sched, obL2Sched, retL1Sched, retL2Sched] = await Promise.all([
+      this.prisma.trainSchedule.findUnique({ where: { id: dto.scheduleId },          include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } } }),
+      this.prisma.trainSchedule.findUnique({ where: { id: dto.leg2ScheduleId },      include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } } }),
+      this.prisma.trainSchedule.findUnique({ where: { id: dto.returnScheduleId },    include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } } }),
+      this.prisma.trainSchedule.findUnique({ where: { id: dto.returnLeg2ScheduleId },include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } } }),
+    ]);
+    if (!obL1Sched)  throw new NotFoundException('Outbound leg-1 schedule not found');
+    if (!obL2Sched)  throw new NotFoundException('Outbound leg-2 schedule not found');
+    if (!retL1Sched) throw new NotFoundException('Return leg-1 schedule not found');
+    if (!retL2Sched) throw new NotFoundException('Return leg-2 schedule not found');
+
+    const obL1Origin  = obL1Sched.stopTimes.find(s => s.stationId === dto.originStationId);
+    const obL1Dest    = obL1Sched.stopTimes.find(s => s.stationId === dto.transitStationId);
+    const obL2Origin  = obL2Sched.stopTimes.find(s => s.stationId === dto.transitStationId);
+    const obL2Dest    = obL2Sched.stopTimes.find(s => s.stationId === dto.leg2DestinationStationId);
+    const retL1Origin = retL1Sched.stopTimes.find(s => s.stationId === dto.returnOriginStationId);
+    const retL1Dest   = retL1Sched.stopTimes.find(s => s.stationId === dto.returnTransitStationId);
+    const retL2Origin = retL2Sched.stopTimes.find(s => s.stationId === dto.returnTransitStationId);
+    const retL2Dest   = retL2Sched.stopTimes.find(s => s.stationId === dto.returnLeg2DestinationStationId);
+    if (!obL1Origin || !obL1Dest)   throw new NotFoundException('Outbound leg-1: origin or transit stop not found');
+    if (!obL2Origin || !obL2Dest)   throw new NotFoundException('Outbound leg-2: transit or destination stop not found');
+    if (!retL1Origin || !retL1Dest) throw new NotFoundException('Return leg-1: origin or transit stop not found');
+    if (!retL2Origin || !retL2Dest) throw new NotFoundException('Return leg-2: transit or destination stop not found');
+
+    // Process passengers (verify once)
+    const passengersData: any[] = [];
+    let adultCount = 0, childCount = 0;
+    for (const passenger of dto.passengers) {
+      const dateOfBirth = new Date(passenger.dateOfBirth);
+      const category: PassengerCategory = calculateAge(dateOfBirth) < 5 ? PassengerCategory.CHILD : PassengerCategory.ADULT;
+      if (category === PassengerCategory.ADULT) adultCount++; else childCount++;
+      let passengerName = passenger.passengerName;
+      let verifaydaVerified = false;
+      let verifaydaData: Record<string, any> | undefined;
+      let nationality = passenger.nationality;
+      const isEthiopian = nationality === 'Ethiopian' || nationality === 'ETHIOPIAN' || passenger.idDocumentType === IdDocumentType.NATIONAL_ID;
+      if (isEthiopian && passenger.idDocumentType === IdDocumentType.NATIONAL_ID && passenger.idDocumentNumber) {
+        const v = await this.verifaydaService.verifyNationalId(passenger.idDocumentNumber);
+        if (!v.verified) throw new BadRequestException(`Verifayda failed for ${passenger.passengerName}: ${v.failureReason}`);
+        passengerName = v.passengerData?.fullName || passengerName;
+        verifaydaVerified = true;
+        verifaydaData = v.passengerData?.profileData;
+        nationality = 'Ethiopian';
+      } else if (!isEthiopian && passenger.idDocumentType === IdDocumentType.PASSPORT) {
+        if (!passenger.passportNumber || !passenger.passportCountry) throw new BadRequestException(`Passport details required for ${passenger.passengerName}`);
+        nationality = nationality || (passenger.passportCountry === 'Djibouti' ? 'Djiboutian' : 'Other');
+      } else {
+        nationality = nationality || 'Other';
+      }
+      passengersData.push({ ...passenger, passengerName, dateOfBirth, category, verifaydaVerified, verifaydaData, nationality });
+    }
+
+    const nat            = passengersData[0]?.nationality;
+    const paidChildren   = Math.max(0, childCount - 1);
+    const obL2ClassId    = dto.leg2SeatClassId      ?? dto.seatClassId;
+    const retL1ClassId   = dto.returnSeatClassId    ?? dto.seatClassId;
+    const retL2ClassId   = dto.returnLeg2SeatClassId ?? dto.seatClassId;
+
+    const [obL1Fare, obL2Fare, retL1Fare, retL2Fare] = await Promise.all([
+      this.getBaseFare(dto.scheduleId,           dto.seatClassId, `${obL1Origin.station.code}-${obL1Dest.station.code}`,   `${obL1Sched.originStation.code}-${obL1Sched.destinationStation.code}`,   nat),
+      this.getBaseFare(dto.leg2ScheduleId!,      obL2ClassId,     `${obL2Origin.station.code}-${obL2Dest.station.code}`,   `${obL2Sched.originStation.code}-${obL2Sched.destinationStation.code}`,   nat),
+      this.getBaseFare(dto.returnScheduleId!,    retL1ClassId,    `${retL1Origin.station.code}-${retL1Dest.station.code}`, `${retL1Sched.originStation.code}-${retL1Sched.destinationStation.code}`, nat),
+      this.getBaseFare(dto.returnLeg2ScheduleId!,retL2ClassId,    `${retL2Origin.station.code}-${retL2Dest.station.code}`, `${retL2Sched.originStation.code}-${retL2Sched.destinationStation.code}`, nat),
+    ]);
+
+    const combinedBase = (obL1Fare + obL2Fare + retL1Fare + retL2Fare) * adultCount +
+                         (obL1Fare + obL2Fare + retL1Fare + retL2Fare) * paidChildren;
+    let discountMinor = 0;
+    if (dto.promoCode) {
+      const promo = await this.prisma.promotion.findUnique({ where: { code: dto.promoCode } });
+      if (promo?.active && promo.validUntil > new Date()) {
+        discountMinor = promo.percentOff ? Math.round(combinedBase * promo.percentOff / 100) : (promo.amountOffMinor ?? 0);
+      }
+    }
+    const taxesMinor      = Math.round(combinedBase * 0.05);
+    const totalMinor      = Math.max(0, combinedBase - discountMinor + taxesMinor);
+    const displayCurrency = dto.displayCurrency || Currency.ETB;
+    const displayTotalMinor = displayCurrency !== Currency.ETB
+      ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
+      : totalMinor;
+
+    const { guestPassengerId, iamUserId, createdAccount } = await this.resolveGuestPassenger(dto, passengersData[0], req);
+
+    const makeSeat = (p: any, seatId: string, leg: number, scheduleId: string, fare: number) => ({
+      seat:              { connect: { id: seatId } },
+      leg,
+      scheduleId,
+      passengerName:     p.passengerName,
+      dateOfBirth:       p.dateOfBirth,
+      passengerCategory: p.category,
+      idDocumentType:    p.idDocumentType,
+      passportNumber:    p.passportNumber,
+      passportCountry:   p.passportCountry,
+      verifaydaVerified: p.verifaydaVerified,
+      verifaydaData:     p.verifaydaData || undefined,
+      fareMinor:         p.category === PassengerCategory.ADULT ? fare : (paidChildren > 0 ? fare : 0),
+      displayCurrency,
+    });
+
+    const booking = await this.prisma.booking.create({
+      data: {
+        bookingRef:                   generateRef(),
+        passengerId:                  guestPassengerId,
+        scheduleId:                   dto.scheduleId,
+        status:                       'PENDING_PAYMENT',
+        bookingType:                  'ROUND_TRIP_TRANSIT',
+        totalMinor, adultCount, childCount, displayCurrency, displayTotalMinor,
+        leg2ScheduleId:               dto.leg2ScheduleId,
+        leg2OriginStationId:          dto.transitStationId,
+        leg2DestinationStationId:     dto.leg2DestinationStationId,
+        leg2SeatClassId:              obL2ClassId,
+        returnScheduleId:             dto.returnScheduleId,
+        returnOriginStationId:        dto.returnOriginStationId,
+        returnDestinationStationId:   dto.returnDestinationStationId,
+        returnSeatClassId:            retL1ClassId,
+        returnLeg2ScheduleId:         dto.returnLeg2ScheduleId,
+        returnLeg2OriginStationId:    dto.returnTransitStationId,
+        returnLeg2DestStationId:      dto.returnLeg2DestinationStationId,
+        returnLeg2SeatClassId:        retL2ClassId,
+        returnLegStatus:              'NEITHER_USED',
+        userAgent:                    dto.deviceId,
+        seats: {
+          create: [
+            ...passengersData.map(p => makeSeat(p, p.seatId,          1, dto.scheduleId,            obL1Fare)),
+            ...passengersData.map(p => makeSeat(p, p.leg2SeatId!,     2, dto.leg2ScheduleId!,       obL2Fare)),
+            ...passengersData.map(p => makeSeat(p, p.returnSeatId!,   3, dto.returnScheduleId!,     retL1Fare)),
+            ...passengersData.map(p => makeSeat(p, p.returnLeg2SeatId!,4, dto.returnLeg2ScheduleId!,retL2Fare)),
+          ],
+        },
+      } as any,
+      include: {
+        seats:    { include: { seat: { include: { coach: true } } } },
+        schedule: { include: { originStation: true, destinationStation: true, train: true } },
+      },
+    });
+
+    await Promise.all([
+      this.seatsService.confirmSeats(dto.passengers.map(p => p.seatId)),
+      this.seatsService.confirmSeats(dto.passengers.map(p => p.leg2SeatId!)),
+      this.seatsService.confirmSeats(dto.passengers.map(p => p.returnSeatId!)),
+      this.seatsService.confirmSeats(dto.passengers.map(p => p.returnLeg2SeatId!)),
+    ]);
+    this.eventEmitter.emit('booking.created', { booking });
+
+    return {
+      ...booking,
+      createdAccount,
+      iamUserId,
+      fareBreakdown: {
+        outboundLeg1FareMinor: obL1Fare,
+        outboundLeg2FareMinor: obL2Fare,
+        returnLeg1FareMinor:   retL1Fare,
+        returnLeg2FareMinor:   retL2Fare,
+        adultCount, childCount,
+        freeChildrenCount: Math.min(childCount, 1),
+        paidChildrenCount: paidChildren,
+        combinedBaseFareMinor: combinedBase,
+        discountMinor, taxesFeesMinor: taxesMinor, totalMinor,
+        currency: 'ETB', displayCurrency, displayTotalMinor,
+      },
+    };
+  }
+
+  private async resolveGuestPassenger(
+    dto: Pick<CreateGuestBookingDto, 'createAccount' | 'password' | 'deviceId'>,
+    firstPassenger: any,
+    req?: any,
+  ): Promise<{ guestPassengerId: string; iamUserId: string | null; createdAccount: boolean }> {
+    if (dto.createAccount && firstPassenger.email && dto.password) {
+      const guestName = firstPassenger.passengerName ?? 'Guest';
+      const result = await this.passengerAuthService.register(
+        {
+          email: firstPassenger.email,
+          username: firstPassenger.email,
+          phoneNumber: firstPassenger.phone || `+251900000000`,
+          name: { en: guestName, am: guestName },
+          password: dto.password,
+          confirmPassword: dto.password,
+        },
+        req,
+      );
+      return { guestPassengerId: result.user.passengerId, iamUserId: result.user.iamUserId, createdAccount: true };
+    }
+
+    const guestPassenger = await this.prisma.passenger.create({ data: {} });
+    await this.prisma.loyaltyAccount.create({ data: { passengerId: guestPassenger.id, pointsBalance: 0, tier: 'BRONZE' } });
+    await this.prisma.walletAccount.create({ data: { passengerId: guestPassenger.id, balanceMinor: 0 } });
+    return { guestPassengerId: guestPassenger.id, iamUserId: null, createdAccount: false };
+  }
+
   async getSavedPassengers(userId?: string, deviceId?: string): Promise<SavedPassengerProfileDto[]> {
     if (!userId && !deviceId) {
       throw new BadRequestException('Either userId or deviceId is required');
@@ -300,6 +889,8 @@ export class GuestBookingService {
     nationality?: string,
   ): Promise<number> {
     const now = new Date();
+
+    // 1. FareRule table — explicit override rules
     const candidates = await this.prisma.fareRule.findMany({
       where: {
         seatClassId,
@@ -325,14 +916,34 @@ export class GuestBookingService {
 
     for (const priority of priorities) {
       const match = candidates.find(
-        (c) =>
-          c.tripId === priority.tripId &&
-          c.route === priority.route &&
-          c.nationality === priority.nationality,
+        (c) => c.tripId === priority.tripId && c.route === priority.route && c.nationality === priority.nationality,
       );
       if (match) return match.baseFareMinor;
     }
 
-    return 35000;
+    // 2. FareEngine — distance × rate-per-km from the schedule's route
+    const schedule = await this.prisma.trainSchedule.findUnique({
+      where: { id: scheduleId },
+      select: { routeId: true, originStationId: true, destinationStationId: true },
+    });
+
+    if (schedule?.routeId) {
+      try {
+        const fare = await this.fareEngine.calculate({
+          routeId: schedule.routeId,
+          originStationId: schedule.originStationId,
+          destinationStationId: schedule.destinationStationId,
+          seatClassId,
+          nationality,
+        });
+        return fare.baseFarePerPassengerMinor;
+      } catch {
+        // FareEngine throws if distanceKm is missing; fall through to error
+      }
+    }
+
+    throw new BadRequestException(
+      `No fare configured for this schedule and seat class. Please set up fare rules or route distances.`,
+    );
   }
 }