@sabstravtech/obtservices 0.0.0

package/projects/obtservices/base/src/lib/vendor/classes/irl-enterprise-search.ts

@@ -0,0 +1,1380 @@
+import moment, { Moment } from 'moment';
+import { of, Observable, BehaviorSubject } from 'rxjs';
+import { map, take, tap } from 'rxjs/operators';
+import { BaseEnterpriseSearch } from './base-enterprise';
+import { BaseStorageService } from '../services/storage.service';
+import { BaseHelperRoutines } from './helpers';
+import { RailTicketGroups } from '../interfaces/rail-ticket-groups.interface';
+import {
+  RailResultIndifiers,
+  RailTicketGroup,
+  TicketGroups
+} from '../interfaces/rail-ticket-group.interface';
+import { RailDirection } from './rail-direction.enum';
+import { ValueDisplay } from '../interfaces/value-display';
+import {
+  NgbDateStruct,
+  IrlQuoteResultArray,
+  RecursivePartial,
+  RecentSearch
+} from '../types/types';
+import {
+  BasketItem,
+  CurrencyCode,
+  IrlClass,
+  IrlJourneyOption,
+  IrlJourneyOptions,
+  IrlProvider,
+  IrlTicketOption,
+  SearchIrlQueryVariables,
+  ServiceType,
+  IrlJourneyType, IrlSupplier
+} from '../types/graphql.types';
+import {
+  BaseIrlQuoteFetcher,
+  IrlQuoteFetcherType
+} from '../fetchers/irl-quote-fetcher';
+import {
+  BaseGetRailStationFetcher,
+  GetRailStationFetcherType
+} from '../fetchers/get-rail-station.fetcher';
+import {
+  EnterpriseBasketServiceInterface,
+  InternalBasketInterface
+} from '../interfaces/Ienterprise-basket.service';
+import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
+import {
+  IRLEnterpriseSearchInterface,
+  IrlTempParams
+} from '../interfaces/Iirl-enterprise-search';
+import { Traveller } from '../models/traveller.object';
+import { ICheapestPrice } from '../interfaces/cheapest-price';
+
+export enum IrlSearchCriteria {
+  Depart = 'Depart After',
+  Arrive = 'Arrive Before'
+}
+
+export class IRLEnterpriseSearch<
+    Q extends IrlQuoteFetcherType
+    // ,
+    // GRS_Q extends GetRailStationFetcherType
+  >
+  extends BaseEnterpriseSearch<
+    IrlTempParams,
+    IrlQuoteResultArray,
+    IrlQuoteResultArray
+  >
+  implements IRLEnterpriseSearchInterface
+{
+  static readonly STORAGE_SESSION_PARAMS = 'search_irl';
+  static readonly STORAGE_SESSION_RESULTS = 'irl_results';
+  static readonly PASSING_POINT = 'Passing';
+  private travellers: Traveller[];
+
+  protected resultsSessionName = IRLEnterpriseSearch.STORAGE_SESSION_RESULTS;
+
+  public searchTypes = [
+    { display: 'Return', value: IrlJourneyType.ReturnJourney },
+    { display: 'One-Way', value: IrlJourneyType.SingleJourney }
+    // { display: 'Open Return', value: IrlJourneyType.OpenReturnJourney },
+    // { display: 'Dual Singles', value: IrlJourneyType.DualSingleJourney },
+  ];
+
+  public classTypes = [
+    { display: 'Any', value: IrlClass.All },
+    { display: 'Standard', value: IrlClass.Standard },
+    { display: 'First', value: IrlClass.First }
+  ];
+
+  public ageRanges = [{ key: 'child', value: 'Child (0-3)' }, { key: 'child', value: 'Child (4-5)' }, { key: 'child', value: 'Child (6-11)' }, { key: 'youth', value: 'Youth (12-14)' }, { key: 'youth', value: 'Youth (15-25)' }, { key: 'adult', value: 'Adult (26-59)' }, { key: 'senior', value: 'Senior (60+)'}];
+
+
+
+  public railCriteria = [IrlSearchCriteria.Depart, IrlSearchCriteria.Arrive];
+
+  public travelCards = [
+    { display: 'Young persons railcard', value: 'YNG' },
+    { display: 'Disability railcard', value: 'DIS' },
+    { display: 'Family railcard', value: 'FAM' },
+    { display: 'Forces railcard', value: 'HMF' },
+    { display: 'Travel agency discount', value: 'TAD' }
+  ];
+
+
+  public type: ServiceType = ServiceType.InternationalRail;
+  public minOutboundDate: NgbDateStruct = {
+    year: moment().year(),
+    month: moment().month() + 1,
+    day: moment().date()
+  };
+  public minInboundDate: NgbDateStruct = {
+    year: moment().year(),
+    month: moment().month() + 1,
+    day: moment().date()
+  };
+  private _timeArray: ValueDisplay[];
+  private _canCombine: any;
+  // private _chosenOutboundTicket: RecursivePartial<IrlTicketOption>;
+  // private _chosenInboundTicket: RecursivePartial<IrlTicketOption>;
+  // private _chosenOutboundJourney: RecursivePartial<IrlJourneyOption>;
+  // private _chosenInboundJourney: RecursivePartial<IrlJourneyOption>;
+  private _viaLocation: any;
+  private _travellingFrom: string;
+  private _travellingTo: string;
+  protected _originalUserSearch: IrlTempParams;
+
+  // get chosenTotalPrice(): number {
+  //   if (this._chosenOutboundTicket) {
+  //     if (this._chosenInboundTicket) {
+  //       // now check if they are returns or dual
+  //       if (
+  //         this._chosenOutboundTicket.singleOrReturn === 'Return' &&
+  //         this._chosenInboundTicket.singleOrReturn === 'Return'
+  //       ) {
+  //         // they should both have the same price
+  //         return this._chosenOutboundTicket.price;
+  //       }
+  //       return (
+  //         this._chosenOutboundTicket.price + this._chosenInboundTicket.price
+  //       );
+  //     }
+
+  //     return this._chosenOutboundTicket.price;
+  //   }
+
+  //   return 0;
+  // }
+
+  // get chosenTickets(): any {
+  //   return {
+  //     Outbound: this._chosenOutboundTicket,
+  //     Inbound: this._chosenInboundTicket
+  //   };
+  // }
+
+  // get chosenOutboundJourney(): RecursivePartial<RailJourneyOption> {
+  //   return this._chosenOutboundJourney;
+  // }
+
+  // get chosenInboundJourney(): RecursivePartial<RailJourneyOption> {
+  //   return this._chosenInboundJourney;
+  // }
+
+  // get openReturn(): boolean {
+  //   return this.tempParams.openReturn;
+  // }
+
+  // set openReturn(newVal: boolean) {
+  //   this.tempParams.openReturn = newVal;
+
+  //   if (newVal) {
+  //     this.tempParams.chosenSearchType = IrlJourneyType.OpenReturnJourney;
+  //   }
+  //   this._isValid();
+  // }
+
+  // get chosenSearchType(): IrlJourneyType {
+  //   return this.tempParams.chosenSearchType;
+  // }
+
+  // set chosenSearchType(newType: IrlJourneyType) {
+  //   this.tempParams.chosenSearchType = newType;
+  //   this._isValid();
+  // }
+
+  get noOfAdults(): number {
+    return this.tempParams.adults;
+  }
+
+  set noOfAdults(adults: number) {
+    this.tempParams.adults = adults;
+    this._isValid();
+  }
+
+  get noOfChildren(): number {
+    return this.tempParams.children;
+  }
+
+  set noOfChildren(children: number) {
+    this.tempParams.children = children;
+    this._isValid();
+  }
+
+  get travellingTo(): any {
+    return this.tempParams.arrivalLocationId;
+  }
+
+  set travellingTo(tt: any) {
+    this.tempParams.arrivalLocationId = tt;
+
+    this._travellingTo = '';
+    if (tt?.railstation?.id) {
+      this._travellingTo = tt.railstation.id;
+    }
+
+    this._isValid();
+  }
+
+  get travellingFrom(): any {
+    return this.tempParams.departureLocationId;
+  }
+
+  set travellingFrom(tt: any) {
+    this.tempParams.departureLocationId = tt;
+    this._travellingFrom = '';
+    if (tt?.railstation?.id) {
+      this._travellingFrom = tt.railstation.id;
+    }
+
+    this._isValid();
+  }
+
+  private _supplier: IrlSupplier = null
+  get supplier():IrlSupplier {
+    return this._supplier;
+  }
+  set supplier(data: IrlSupplier) {
+    this._supplier = data;
+  }
+
+  private _countryCode: string = null
+  get countryCode():string {
+    return this._countryCode;
+  }
+  set countryCode(data: string) {
+    this._countryCode = data;
+  }
+
+  private _class: IrlClass = null
+  get class():IrlClass {
+    return this._class;
+  }
+  set class(data: IrlClass) {
+    this._class = data;
+  }
+
+  private _outboundDepartureDateTime: Moment = null
+  get outboundDepartureDateTime():Moment {
+    return this._outboundDepartureDateTime;
+  }
+  set outboundDepartureDateTime(data: Moment) {
+    this._outboundDepartureDateTime = data;
+  }
+
+  private _departureLocationId: string = null
+  get departureLocationId():string {
+    return this._departureLocationId;
+  }
+  set departureLocationId(data: string) {
+    this._departureLocationId = data;
+  }
+
+  private _arrivalLocationId: string = null
+  get arrivalLocationId():string {
+    return this._arrivalLocationId;
+  }
+  set arrivalLocationId(data: string) {
+    this._arrivalLocationId = data;
+  }
+
+  private _adults: number = 0
+  get adults():number {
+    return this._adults;
+  }
+  set adults(data: number) {
+    this._adults = data;
+  }
+
+  private _children: number = 0
+  get children():number {
+    return this._children;
+  }
+  set children(data: number) {
+    this._children = data;
+  }
+
+  private _returnDepartureDateTime: Moment = null
+  get returnDepartureDateTime():Moment {
+    return this._returnDepartureDateTime;
+  }
+  set returnDepartureDateTime(data: Moment) {
+    this._returnDepartureDateTime = data;
+  }
+
+  private _ageRange: string = null
+  get ageRange():string {
+    return this._ageRange;
+  }
+  set ageRange(data: string) {
+    this._ageRange = data;
+  }
+
+
+
+
+  // get chosenRailClass(): RailClass {
+  //   return this.tempParams.chosenSearchClass;
+  // }
+
+  get chosenSearchClass(): IrlClass {
+    return this.tempParams.class;
+  }
+
+  set chosenSearchClass(classR: IrlClass) {
+    this.tempParams.class = classR;
+    this._isValid();
+  }
+
+  get outBoundDateTime(): moment.Moment {
+    return this.tempParams.outboundDepartureDateTime;
+  }
+
+  set outBoundDateTime(newDateTime: moment.Moment) {
+    this.tempParams.outboundDepartureDateTime = moment(newDateTime);
+
+    this.minInboundDate = {
+      year: newDateTime.year(),
+      month: newDateTime.month() + 1,
+      day: newDateTime.date()
+    };
+
+    // if (
+    //   this.outBoundDateTime &&
+    //   // this.inBoundDateTime &&
+    //   this.outBoundDateTime.isAfter(this.inBoundDateTime)
+    // ) {
+    //   this.inBoundDateTime = this.outBoundDateTime.clone().add(1, 'day');
+    // }
+
+    this._isValid();
+  }
+
+  // get outboundCriteria(): IrlSearchCriteria {
+  //   return this.tempParams.outboundCriteria;
+  // }
+
+  // set outboundCriteria(newCrit: IrlSearchCriteria) {
+  //   // console.warn(`+++ Setting New Criteria: ${newCrit} +++`);
+  //   this.tempParams.outboundCriteria = newCrit;
+
+  //   this._isValid();
+  // }
+
+  // ! might not need this?
+  // get inBoundDateTime(): moment.Moment {
+  //   return this.tempParams.inBoundDateTime;
+  // }
+
+  // set inBoundDateTime(newDateTime: moment.Moment) {
+  //   this.tempParams.inBoundDateTime = moment(newDateTime);
+  //   this._isValid();
+  // }
+
+  // !date and time is handled differently for LU
+  private _outbound_date: NgbDateStruct = null;
+
+  get outbound_date(): NgbDateStruct {
+    return this._outbound_date;
+  }
+
+  set outbound_date(value: NgbDateStruct) {
+    this._outbound_date = value;
+    this._updateOutboundDateTime();
+  }
+
+  private _outbound_time: string = null;
+  get outbound_time(): string {
+    return this._outbound_time;
+  }
+
+  set outbound_time(value: string) {
+    this._outbound_time = value;
+    this._updateOutboundDateTime();
+  }
+
+  private _return_date: NgbDateStruct = null;
+
+  get return_date(): NgbDateStruct {
+    return this._return_date;
+  }
+
+  set return_date(value: NgbDateStruct) {
+    this._return_date = value;
+    this._updateReturnDateTime();
+  }
+
+  private _return_time: string = null;
+  get return_time(): string {
+    return this._return_time;
+  }
+
+  set return_time(value: string) {
+    this._return_time = value;
+    this._updateReturnDateTime();
+  }
+
+  // get returnCriteria(): IrlSearchCriteria {
+  //   return this.tempParams.returnCriteria;
+  // }
+
+  // set returnCriteria(newCrit: IrlSearchCriteria) {
+  //   this.tempParams.returnCriteria = newCrit;
+  //   this._isValid();
+  // }
+
+  // set railCards(newRailCards: string[]) {
+  //   this.tempParams.railCards = newRailCards;
+  //   this._isValid();
+  // }
+
+  // get carnetTicket(): boolean {
+  //   return this.tempParams.carnetTicket;
+  // }
+
+  // set carnetTicket(newCarnet: boolean) {
+  //   this.tempParams.carnetTicket = newCarnet;
+  //   this._isValid();
+  // }
+
+  // get disableAutoDiscounts(): boolean {
+  //   return this.tempParams.disableAutoDiscounts;
+  // }
+
+  // set disableAutoDiscounts(newDis: boolean) {
+  //   this.tempParams.disableAutoDiscounts = newDis;
+  //   this._isValid();
+  // }
+
+  // get prioritiseByPrice(): boolean {
+  //   return this.tempParams.prioritiseByPrice;
+  // }
+
+  // set prioritiseByPrice(newPriority: boolean) {
+  //   this.tempParams.prioritiseByPrice = newPriority;
+  //   this._isValid();
+  // }
+
+
+  public get timeArray(): ValueDisplay[] {
+    this._timeArray =
+      this._timeArray ||
+      Array(48)
+        .fill(0)
+        .map((_, index: number) => {
+          return {
+            value:
+              Math.floor(index / 2)
+                .toString()
+                .padStart(2, '0') +
+              ((index % 2) * 30).toString().padStart(2, '0'),
+            display:
+              Math.floor(index / 2)
+                .toString()
+                .padStart(2, '0') +
+              ':' +
+              ((index % 2) * 30).toString().padStart(2, '0')
+          };
+        });
+    return this._timeArray;
+  }
+
+
+  private _cheapestStandard: IrlTicketOption = null;
+  get cheapestStandard(): IrlTicketOption {
+    return this._cheapestStandard;
+  }
+  private _cheapestFirst: IrlTicketOption = null;
+  get cheapestFirst(): IrlTicketOption {
+    return this._cheapestFirst;
+  }
+
+  private _irlClass: IrlClass = null;
+  get irlClass(): IrlClass {
+    return this._irlClass
+  }
+
+  set irlClass(data : IrlClass) {
+    this._irlClass = data;
+  }
+
+  private _journeytype: IrlJourneyType = null;
+  get journeyType(): IrlJourneyType {
+    return this._journeytype
+  }
+
+  set journeyType(data : IrlJourneyType) {
+    this._journeytype = data;
+  }
+
+  constructor(
+    private Irlfetcher: BaseIrlQuoteFetcher<Q>,
+    // private getRailStationFetcher: BaseGetRailStationFetcher<GRS_Q>, // doesnt exist yet
+    private helpers: BaseHelperRoutines,
+    private basketService: EnterpriseBasketServiceInterface,
+    storageService: BaseStorageService,
+    private searchService: EnterpriseSearchServiceInterface
+  ) {
+    super(storageService);
+
+    const data: {
+      query: {};
+      tempParams: IrlTempParams;
+      originalUserSearch: IrlTempParams;
+    } = storageService.getSessionItem(
+      IRLEnterpriseSearch.STORAGE_SESSION_PARAMS
+    ) || {
+      query: {},
+      tempParams: {} as IrlTempParams,
+      originalUserSearch: {} as IrlTempParams
+    };
+
+    this.updateTempParams(this.searchService.makeIrlQuery(data.tempParams));
+    this._originalUserSearch = data.originalUserSearch;
+
+    if (searchService.shouldAddTravellerSubscription()) {
+      searchService.travellerInformation.subscribe(
+        (travellers: Traveller[]) => {
+          this.travellers = travellers;
+          const splitTravellers = this.helpers.selectedTravellers(
+            travellers,
+            ServiceType.Rail
+          );
+          this.tempParams.adults = splitTravellers.adults.length;
+          this.tempParams.children = splitTravellers.children.length;
+          this.travellers = travellers;
+          this._isValid();
+        }
+      );
+    }
+    this._isValid();
+    const results =
+      storageService.getSessionItemAsList<IrlQuoteResultArray>(
+        this.resultsSessionName
+      ) || [];
+    // if (results == null && this.isValid) {
+    //   searchService.startSearches();
+    // }
+    this._cheapestResultPrice = this.updateLowestPrice(results);
+    this.results.next(results || []);
+  }
+
+  protected resetQuery(): void {
+    this.updateTempParams(this.searchService.makeIrlQuery());
+    this._isValid();
+  }
+
+  private _isValid() {
+    this.storageService.setSessionItem(
+      IRLEnterpriseSearch.STORAGE_SESSION_PARAMS,
+      {
+        tempParams: this.tempParams,
+        originalUserSearch: this.originalUserSearch
+      }
+    );
+
+    this.validationMessages = [];
+
+    const now = moment();
+
+    if (!this._travellingFrom) {
+      this.validationMessages.push('Please Enter a From Location.');
+    }
+
+    if (!this._travellingTo) {
+      this.validationMessages.push('Please Enter a To Location.');
+    }
+
+    if (this.outBoundDateTime?.isBefore(now)) {
+      this.validationMessages.push(
+        'Departure Date/Time cannot be in the past.'
+      );
+    }
+
+    // if (
+    //   this.chosenSearchType === IrlJourneyType.ReturnJourney
+    // ) {
+    //   // check for return specific validations in here
+
+    //   if (this.inBoundDateTime?.isSameOrBefore(this.outBoundDateTime)) {
+    //     this.validationMessages.push(
+    //       'Return Date/Time must be after Departure Date/Time'
+    //     );
+    //   }
+    // }
+
+    // if (this.via) {
+    //   if (!this.tempParams.viaLocation) {
+    //     this.validationMessages.push('Please enter a via location.');
+    //   }
+    // }
+
+    if (this.tempParams.adults + this.tempParams.children < 1) {
+      this.validationMessages.push('There must be at least 1 traveller');
+    }
+
+    this.isValid.next(this.validationMessages.length === 0);
+    this.messages.next(this.validationMessages);
+  }
+
+  startSearch(): Promise<boolean> {
+    this.results.next([]);
+
+    if (this.isValid.value) {
+      this._originalUserSearch = Object.freeze({ ...this.tempParams });
+      this.storageService.setSessionItem(
+        IRLEnterpriseSearch.STORAGE_SESSION_PARAMS,
+        {
+          tempParams: this.tempParams,
+          originalUserSearch: this.originalUserSearch
+        }
+      );
+      return this._startSearch(
+        this.Irlfetcher.fetchList(this.getSearchQuery()).pipe(
+          map(result => result)
+        )
+      );
+    } else {
+      return Promise.resolve(false);
+    }
+  }
+
+  public startRecentSearch(recentSearch: RecentSearch): void {
+    this.startSearch();
+  }
+
+  private _updateOutboundDateTime(): void {
+    if (this._outbound_date && this._outbound_time) {
+      const time = this.helpers.ngDateToMoment(
+        this._outbound_date,
+        this._outbound_time
+      );
+      this.outBoundDateTime = time.isValid() ? time : null;
+      this._isValid();
+    }
+  }
+
+  private _updateReturnDateTime(): void {
+    if (this._return_date && this._return_time) {
+      const time = this.helpers.ngDateToMoment(
+        this._return_date,
+        this._return_time
+      );
+      // this.inBoundDateTime = time.isValid() ? time : null;
+      this._isValid();
+    }
+  }
+
+  getSearchQuery(): SearchIrlQueryVariables {
+    const query: SearchIrlQueryVariables = {
+      supplier: this.supplier, // IRLSupplier!
+      countryCode: 'GB',
+      // journeyType: this.journeyType, // IRLJourneyType!
+      class: this.irlClass, // IRLClass
+      outboundDepartureDateTime: this.tempParams.outboundDepartureDateTime,
+      departureLocationId: this._travellingFrom,
+      arrivalLocationId: this._travellingTo,
+      adults: this.tempParams.adults,
+      children: this.tempParams.children,
+      returnDepartureDateTime: this.tempParams.returnDepartureDateTime,
+
+      journeyType: this.tempParams.journeyType,
+      // class: this.tempParams.chosenSearchClass,
+      // extraTimeToChange: this.tempParams.extraTime,
+      // outboundArrivalDateTime: this.tempParams.outBoundDateTime,
+      // returnArrivalDateTime: this.tempParams.inBoundDateTime,
+      // viaLocationCode: this.tempParams.viaLocation
+    };
+
+    if (this.tempParams.children === 0) {
+      query.children = null;
+    }
+
+    // switch (this.tempParams.outboundCriteria) {
+    //   case IrlSearchCriteria.Depart:
+    //     query.outboundArrivalDateTime = null;
+    //     break;
+    //   case IrlSearchCriteria.Arrive:
+    //     query.outboundDepartureDateTime = null;
+    //     break;
+    //   default:
+    //     console.warn(
+    //       `+++ Unknown Criteria: ${this.tempParams.outboundCriteria} +++`
+    //     );
+    // }
+
+    // switch (this.tempParams.returnCriteria) {
+    //   case IrlSearchCriteria.Depart:
+    //     query.returnArrivalDateTime = null;
+    //     break;
+    //   case IrlSearchCriteria.Arrive:
+    //     query.returnDepartureDateTime = null;
+    //     break;
+    //   default:
+    //     console.warn(
+    //       `+++ Unknown Criteria: ${this.tempParams.returnCriteria} +++`
+    //     );
+    // }
+
+    switch (this.tempParams.journeyType) {
+      case IrlJourneyType.SingleJourney:
+        query.returnDepartureDateTime = null;
+        break;
+    }
+    return this.helpers.removeNulls<SearchIrlQueryVariables>(query);
+  }
+
+  // createTicketGroups(results: IRLJourneyOptions[]): RailTicketGroups {
+  //   let tickets: RailTicketGroups = {};
+  //   let ticketId = '';
+  //   this._canCombine = {};
+
+  //   let ticketGroupsOutbound = this.setTicketsGroups(results[0].outbound);
+  //   let ticketGroupsReturn = this.setTicketsGroups(results[0].return);
+  //   ticketGroupsOutbound = this.sortTicketPrices(ticketGroupsOutbound);
+  //   ticketGroupsReturn = this.sortTicketPrices(ticketGroupsReturn);
+
+  //   Object.keys(ticketGroupsOutbound).map((key) => {
+  //     ticketGroupsOutbound[key].map((tkt: RailTicketOption) => {
+  //       ticketId = `${tkt.type}${tkt.singleOrReturn}`;
+  //       const identifier = tkt.identifiers.journeyIdentifier;
+  //       const identifierObj: RailResultIndifiers = {};
+  //       identifierObj[identifier] = {
+  //         price: tkt.price,
+  //         isChild: false,
+  //         fareIdentifier: tkt.identifiers.fareIdentifier
+  //       };
+  //       if (tickets[key]) {
+  //         this.updateCanCombine(tkt);
+  //         identifierObj[tkt.identifiers.journeyIdentifier].isChild = false;
+  //         if (tickets[tkt.type].header.price === tkt.price) {
+  //           tickets[tkt.type].resultIndifiers.push(identifier);
+  //           tickets[tkt.type].resultIndifiersPrices = {
+  //             ...tickets[tkt.type].resultIndifiersPrices,
+  //             ...identifierObj
+  //           };
+  //         } else if (tkt.price) {
+  //           identifierObj[identifier].isChild = true;
+  //           const childTicket = {
+  //             header: tkt,
+  //             children: [],
+  //             open: false,
+  //             direction: RailDirection.Outbound,
+  //             resultIndifiers: [identifier],
+  //             resultIndifiersPrices: identifierObj,
+  //             child: true,
+  //             ticketId,
+  //             selectedIndicies: [],
+  //             disabledIndicies: []
+  //           } as RailTicketGroup;
+  //           tickets[tkt.type].children.push(childTicket);
+  //         }
+  //       } else {
+  //         this._canCombine[tkt.type] = {};
+  //         this.updateCanCombine(tkt);
+  //         tickets[tkt.type] = {
+  //           header: tkt,
+  //           children: [],
+  //           open: false,
+  //           direction: RailDirection.Outbound,
+  //           resultIndifiers: [identifier],
+  //           resultIndifiersPrices: identifierObj,
+  //           child: false,
+  //           ticketId,
+  //           selectedIndicies: [],
+  //           disabledIndicies: []
+  //         } as RailTicketGroup;
+  //       }
+  //     });
+  //   });
+
+  //   Object.keys(ticketGroupsReturn).map((key) => {
+  //     ticketGroupsReturn[key].map((tkt: RailTicketOption) => {
+  //       ticketId = `${tkt.type}${tkt.singleOrReturn}`;
+  //       const identifier = tkt.identifiers.journeyIdentifier;
+  //       const identifierObj: RailResultIndifiers = {};
+  //       identifierObj[identifier] = {
+  //         price: tkt.price,
+  //         isChild: true,
+  //         fareIdentifier: tkt.identifiers.fareIdentifier
+  //       };
+  //       if (
+  //         tickets[tkt.type] &&
+  //         tkt.price &&
+  //         tkt.price !== tickets[tkt.type].header.price
+  //       ) {
+  //         this.updateCanCombine(tkt);
+  //         identifierObj[identifier].isChild = true;
+  //         const childTicket = {
+  //           header: tkt,
+  //           children: [],
+  //           open: false,
+  //           direction: RailDirection.Inbound,
+  //           resultIndifiers: [identifier],
+  //           resultIndifiersPrices: identifierObj,
+  //           child: true,
+  //           ticketId,
+  //           selectedIndicies: [],
+  //           disabledIndicies: []
+  //         } as any;
+  //         tickets[tkt.type].children.push(childTicket);
+  //       } else if (!tickets[tkt.type]) {
+  //         this.updateCanCombine(tkt);
+  //         tickets[tkt.type] = {
+  //           header: tkt,
+  //           children: [],
+  //           open: false,
+  //           direction: RailDirection.Inbound,
+  //           resultIndifiers: [identifier],
+  //           resultIndifiersPrices: identifierObj,
+  //           child: false,
+  //           ticketId,
+  //           selectedIndicies: [],
+  //           disabledIndicies: []
+  //         } as any;
+  //       } else if (!tkt.price || tkt.price === tickets[tkt.type].header.price) {
+  //         this.updateCanCombine(tkt);
+  //         tickets[tkt.type].resultIndifiers.push(identifier);
+  //         identifierObj[identifier].isChild = false;
+  //         tickets[tkt.type].resultIndifiersPrices = {
+  //           ...tickets[tkt.type].resultIndifiersPrices,
+  //           ...identifierObj
+  //         };
+  //       }
+  //     });
+  //   });
+
+  //   let combineTickets = { ...tickets };
+  //   tickets = this.combineChildTickets(combineTickets);
+
+  //   // console.log('groups: ', tickets);
+  //   // console.log('Can Combine: ', this._canCombine);
+  //   return tickets;
+  // }
+
+  combineChildTickets(tickets: RailTicketGroups): RailTicketGroups {
+    const values = Object.values(tickets);
+    for (let i = 0; i < values.length; i++) {
+      const childObject: { [key: string]: RailTicketGroup } = {};
+
+      for (let j = 0; j < values[i].children.length; j++) {
+        const child = values[i].children[j];
+        const fareIdentifier = child.header.identifiers.fareIdentifier;
+        if (childObject[fareIdentifier]) {
+          childObject[fareIdentifier].resultIndifiers.push(
+            child.resultIndifiers[0]
+          );
+          childObject[fareIdentifier].resultIndifiersPrices = {
+            ...childObject[fareIdentifier].resultIndifiersPrices,
+            ...child.resultIndifiersPrices
+          };
+        } else {
+          childObject[fareIdentifier] = child;
+        }
+      }
+      // console.log(childObject);
+      // console.log(values[i]['header']['type']);
+      tickets[values[i].header.type].children = Object.values(childObject);
+    }
+    // tickets = this.sortTicketChildrenPrices(tickets);
+    return tickets;
+  }
+  setTicketsGroups(results: IrlJourneyOption[]): any {
+    let ticketGroups: any = {};
+    results.forEach((out: IrlJourneyOption) => {
+      out.providers.forEach((prov: IrlProvider) => {
+        prov.ticketOptions.forEach((tkt: IrlTicketOption) => {
+          ticketGroups[tkt.type]
+            ? ticketGroups[tkt.type].push(tkt)
+            : (ticketGroups[tkt.type] = [tkt]);
+        });
+      });
+    });
+    return ticketGroups;
+  }
+
+  updateFromPreviousSearches(
+    previousItems: Record<ServiceType, BasketItem>
+  ): void {}
+
+  updateCanCombine(tkt: IrlTicketOption): void {
+    (tkt.identifiers.allowedWith || []).forEach((allowed) => {
+      if (!this._canCombine[tkt.type][allowed.journeyIdentifier]) {
+        this._canCombine[tkt.type][allowed.journeyIdentifier] = [
+          allowed.fareIdentifier
+        ];
+      } else {
+        this._canCombine[tkt.type][allowed.journeyIdentifier].push(
+          allowed.fareIdentifier
+        );
+      }
+    });
+  }
+
+  // toggleTicketSelect(
+  //   ticket: IrlTicketGroup,
+  //   way: 'departs' | 'returns',
+  //   timeSlotId: string,
+  //   ticketId: string,
+  //   fareIdentifier: string,
+  //   ticketsGroups: IrlTicketGroups
+  // ): IrlTicketGroups {
+  //   if (!ticket) {
+  //     return;
+  //   }
+  //   const keys = Object.keys(ticketsGroups);
+  //   let selectedTicket = null;
+  //   let departsTicket: IrlTicketOption[] = [];
+  //   let returnTicket: IrlTicketOption[] = [];
+  //   let isUnselected = false;
+  //   keys.forEach((key) => {
+  //     let group = ticketsGroups[key] as RailTicketGroup;
+
+  //     if (
+  //       group.ticketId === ticketId &&
+  //       group.selectedIndicies.includes(timeSlotId)
+  //     ) {
+  //       if (way === 'departs') {
+  //         group.selectedIndicies = [];
+  //         departsTicket = [];
+  //         returnTicket = [];
+  //         this._chosenInboundTicket = null;
+  //         this._chosenInboundJourney = null;
+  //         group.children.forEach((child) => {
+  //           child.selectedIndicies = [];
+  //         });
+  //       } else {
+  //         group.selectedIndicies = group.selectedIndicies.filter(
+  //           (Indicies) => Indicies !== timeSlotId
+  //         );
+  //         returnTicket = returnTicket.filter(
+  //           (Indicies) => Indicies !== group.header
+  //         );
+  //       }
+  //     } else {
+  //       if (
+  //         group.ticketId === ticketId &&
+  //         group.header.identifiers.fareIdentifier === fareIdentifier &&
+  //         way === 'departs'
+  //       ) {
+  //         group = this.clearUnneededTickets(way, group, timeSlotId);
+  //         group.selectedIndicies.push(timeSlotId);
+  //         way === 'departs'
+  //           ? departsTicket.push(group.header)
+  //           : returnTicket.push(group.header);
+  //         selectedTicket = group.header;
+  //       } else {
+  //         // may have to modify this for dual singles
+  //         if (way === 'departs') {
+  //           group.selectedIndicies = [];
+  //         } else {
+  //           selectedTicket = group.header;
+  //         }
+  //       }
+
+  //       group.children.forEach((child) => {
+  //         if (child.selectedIndicies.includes(timeSlotId)) {
+  //           if (way === 'departs') {
+  //             child.selectedIndicies = [];
+  //             departsTicket = [];
+  //             returnTicket = [];
+  //             this._chosenInboundTicket = null;
+  //             this._chosenInboundJourney = null;
+  //             isUnselected = true;
+  //           } else {
+  //             child.selectedIndicies = child.selectedIndicies.filter(
+  //               (Indicies) => Indicies !== timeSlotId
+  //             );
+  //             returnTicket = returnTicket.filter(
+  //               (Indicies) => Indicies !== group.header
+  //             );
+  //           }
+  //         } else {
+  //           if (
+  //             child.ticketId === ticketId &&
+  //             child.header.identifiers.fareIdentifier === fareIdentifier
+  //           ) {
+  //             if (
+  //               (way === 'departs' &&
+  //                 child.direction !== RailDirection.Inbound) ||
+  //               (way !== 'departs' && child.direction === RailDirection.Inbound)
+  //             ) {
+  //               child = this.clearUnneededTickets(way, child, timeSlotId);
+  //               child.selectedIndicies.push(timeSlotId);
+  //               way === 'departs'
+  //                 ? departsTicket.push(child.header)
+  //                 : returnTicket.push(child.header);
+  //               selectedTicket = child.header;
+  //             } else if (isUnselected) {
+  //               child.selectedIndicies = [];
+  //             }
+  //           } else {
+  //             child.selectedIndicies = [];
+  //           }
+  //         }
+  //       });
+  //     }
+  //   });
+
+  //   // now we need to mark tickets as disabled if they are returns that do not match the selected return
+  //   // or on overlapping times
+  //   if (way === 'departs') {
+  //     this._chosenOutboundTicket = this.helpers.clone(selectedTicket);
+
+  //     // now go over the full results and find the matching timeslot
+  //     departsTicket.length
+  //       ? (this._chosenOutboundJourney = this.results.value[0].outbound.find(
+  //           (out: RailJourneyOption) => {
+  //             return out.identifiers.journeyIdentifier === timeSlotId;
+  //           }
+  //         ))
+  //       : (this._chosenOutboundJourney = null);
+
+  //     if (
+  //       this._chosenInboundTicket &&
+  //       this._chosenOutboundTicket.singleOrReturn === 'Return' &&
+  //       this._chosenOutboundTicket.identifiers.fareIdentifier !==
+  //         this._chosenInboundTicket.identifiers.fareIdentifier
+  //     ) {
+  //       console.warn('+++ Cannot combine fares, clearing inbound... +++');
+  //       this._chosenInboundTicket = null;
+  //       this._chosenInboundJourney = null;
+  //     }
+  //   } else if (way === 'returns') {
+  //     this._chosenInboundTicket = this.helpers.clone(selectedTicket);
+
+  //     this._chosenInboundTicket
+  //       ? (this._chosenInboundJourney = this.results.value[0].return.find(
+  //           (inT: RailJourneyOption) => {
+  //             return inT.identifiers.journeyIdentifier === timeSlotId;
+  //           }
+  //         ))
+  //       : (this._chosenInboundJourney = null);
+  //   }
+
+  //   console.log(this.chosenOutboundJourney);
+  //   console.log(this._chosenInboundJourney);
+  //   return ticketsGroups;
+  // }
+
+  /**
+   * @description - determine if a fare can be combined with what we currently have selected
+   */
+  // canCombine(journeyIdentifier: string, fareIdentifier: string): boolean {
+  //   // may have to modify this for dual singles later on
+  //   if (
+  //     this._chosenOutboundTicket &&
+  //     this._chosenOutboundTicket.singleOrReturn === 'Return' &&
+  //     Number(journeyIdentifier) > 5
+  //   ) {
+  //     // greater than 5 only as we are not going to restrict outbounds
+  //     if (
+  //       this._canCombine[this._chosenOutboundTicket.type][
+  //         Number(journeyIdentifier)
+  //       ]?.includes(fareIdentifier) &&
+  //       this._chosenOutboundTicket.identifiers.fareIdentifier === fareIdentifier
+  //     ) {
+  //       return true;
+  //     }
+  //     return false;
+  //   }
+
+  //   return false;
+  // }
+
+  clearUnneededTickets(
+    way: string,
+    group: RailTicketGroup,
+    timeSlotId: string
+  ): RailTicketGroup {
+    if (way === 'returns') {
+      group.selectedIndicies = group.selectedIndicies.filter(
+        (indicie: string) => {
+          return Number(indicie) <= 5 || indicie === timeSlotId;
+        }
+      );
+    } else {
+      group.selectedIndicies = group.selectedIndicies.filter(
+        (indicie: string) => {
+          return Number(indicie) > 5 || indicie === timeSlotId;
+        }
+      );
+    }
+
+    return group;
+  }
+
+  // getRailStation(
+  //   code: string,
+  //   isLoading: BehaviorSubject<boolean>
+  // ): Observable<IrlStation> {
+  //   if (code.length === 3) {
+  //     isLoading?.next(true);
+  //     return this.getRailStationFetcher.fetchList({ code }).pipe(
+  //       tap(() => isLoading?.next(false)),
+  //       take(1)
+  //     );
+  //   } else {
+  //     return of();
+  //   }
+  // }
+
+  // getSelectedirlTicketOption(
+  //   irlJourneyOption: IrlJourneyOption,
+  //   irlTicketGroup: IrlTicketGroup,
+  //   providerIndex: number
+  // ): IrlTicketOption {
+  //   return irlJourneyOption.providers[providerIndex].ticketOptions.find(
+  //     (ticketOption) =>
+  //       ticketOption.type === irlTicketGroup.header.type &&
+  //       ticketOption.price === irlTicketGroup.header.price
+  //   );
+  // }
+
+  getLegsFromRailJourneyOption(railJourneyOption: IrlJourneyOption): any[] {
+    let legs: any[] = [];
+    if (railJourneyOption?.segments.length) {
+      legs = railJourneyOption.segments.map((segment) => {
+        return {
+          operator: segment.operator,
+          departureDateTime: segment.departDateTime,
+          departureStationName: segment.depart,
+          arrivalDateTime: segment.arriveDateTime,
+          arrivalStationName: segment.arrive
+        };
+      });
+    }
+    return legs;
+  }
+
+  // async addSingleJourneyToBasket(
+  //   serviceId: string,
+  //   railQuery: SearchRailQueryVariables,
+  //   railJourneyOption: RailJourneyOption,
+  //   railTicketGroup: RailTicketGroup
+  // ): Promise<boolean> {
+  //   if (railJourneyOption.unsellable) {
+  //     return Promise.resolve(false);
+  //   }
+  //   const intBasket: InternalBasketInterface =
+  //     await this.basketService.getDefaultBasket();
+  //   const basket = intBasket?.subject.value;
+  //   if (basket) {
+  //     const selectedRailTicketOption = this.getSelectedRailTicketOption(
+  //       railJourneyOption,
+  //       railTicketGroup,
+  //       0
+  //     );
+  //     const legs = this.getLegsFromRailJourneyOption(railJourneyOption);
+  //     const ticketQueueList = selectedRailTicketOption.ticketQueueList.map(
+  //       (ticketQueueList) => {
+  //         return {
+  //           id: ticketQueueList.id,
+  //           name: ticketQueueList.name,
+  //           type: ticketQueueList.type
+  //         };
+  //       }
+  //     );
+
+  //     return this.basketService.addToBasket(
+  //       {
+  //         basket: basket.id,
+  //         service: serviceId,
+  //         detail: {
+  //           outwardDetail: {
+  //             arrivalDateTime: railJourneyOption.arriveDateTime,
+  //             arrivalStationName: railJourneyOption.to,
+  //             departureDateTime: railJourneyOption.departDateTime,
+  //             departureStationName: railJourneyOption.from,
+  //             supplierTickets: [
+  //               {
+  //                 supplierName: railJourneyOption.providers[0].name,
+  //                 ticketDescription: selectedRailTicketOption.type,
+  //                 price: selectedRailTicketOption.price,
+  //                 legs
+  //               }
+  //             ]
+  //           },
+  //           transactionIdentifier:
+  //             railJourneyOption.identifiers.transactionIdentifier,
+  //           outbound: {
+  //             fareIdentifiers: [
+  //               selectedRailTicketOption.identifiers.fareIdentifier
+  //             ],
+  //             journeyIdentifier:
+  //               selectedRailTicketOption.identifiers.journeyIdentifier
+  //           },
+  //           ticketQueueList
+  //         },
+  //         adults: railQuery.adults,
+  //         price: selectedRailTicketOption.price,
+  //         currency: selectedRailTicketOption.currency as CurrencyCode,
+  //         searchQuery: railQuery,
+  //         co2PerItem: railJourneyOption.co2PerItem,
+  //         co2PerPassenger: railJourneyOption.co2PerPassenger
+  //       },
+  //       intBasket,
+  //       this.searchService,
+  //       this.travellers
+  //     );
+  //   }
+  //   return Promise.resolve(false);
+  // }
+
+  // async addReturnJourneyToBasket(
+  //   serviceId: string,
+  //   railQuery: SearchRailQueryVariables,
+  //   outbound: RailJourneyOption,
+  //   inbound: RailJourneyOption,
+  //   railTicketGroup: RailTicketGroup
+  // ): Promise<boolean> {
+  //   if (outbound.unsellable) {
+  //     return Promise.resolve(false);
+  //   }
+  //   const intBasket: InternalBasketInterface =
+  //     await this.basketService.getDefaultBasket();
+  //   const basket = intBasket?.subject.value;
+  //   if (basket) {
+  //     const selectedRailTicketOption = this.getSelectedRailTicketOption(
+  //       outbound,
+  //       railTicketGroup,
+  //       0
+  //     );
+  //     const outboundLegs = this.getLegsFromRailJourneyOption(outbound);
+  //     const inboundLegs = this.getLegsFromRailJourneyOption(inbound);
+  //     const ticketQueueList = selectedRailTicketOption.ticketQueueList.map(
+  //       (ticketQueueList1: RailTicketQueue) => {
+  //         return {
+  //           id: ticketQueueList1.id,
+  //           name: ticketQueueList1.name,
+  //           type: ticketQueueList1.type
+  //         };
+  //       }
+  //     );
+
+  //     return this.basketService.addToBasket(
+  //       {
+  //         basket: basket.id,
+  //         service: serviceId,
+  //         detail: {
+  //           outwardDetail: {
+  //             arrivalDateTime: outbound.arriveDateTime,
+  //             arrivalStationName: outbound.to,
+  //             departureDateTime: outbound.departDateTime,
+  //             departureStationName: outbound.from,
+  //             supplierTickets: [
+  //               {
+  //                 supplierName: outbound.providers[0].name,
+  //                 ticketDescription: selectedRailTicketOption.type,
+  //                 price: selectedRailTicketOption.price,
+  //                 legs: outboundLegs
+  //               }
+  //             ]
+  //           },
+  //           inwardDetail: {
+  //             arrivalDateTime: inbound.arriveDateTime,
+  //             arrivalStationName: inbound.to,
+  //             departureDateTime: inbound.departDateTime,
+  //             departureStationName: inbound.from,
+  //             supplierTickets: [
+  //               {
+  //                 supplierName: inbound.providers[0].name,
+  //                 ticketDescription: selectedRailTicketOption.type,
+  //                 legs: inboundLegs
+  //               }
+  //             ]
+  //           },
+  //           transactionIdentifier: outbound.identifiers.transactionIdentifier,
+  //           outbound: {
+  //             fareIdentifiers: [
+  //               selectedRailTicketOption.identifiers.fareIdentifier
+  //             ],
+  //             journeyIdentifier:
+  //               selectedRailTicketOption.identifiers.journeyIdentifier
+  //           },
+  //           ticketQueueList
+  //         },
+  //         adults: railQuery.adults,
+  //         price: railTicketGroup.header.price,
+  //         currency: selectedRailTicketOption.currency as CurrencyCode,
+  //         searchQuery: railQuery,
+  //         co2PerItem: outbound.co2PerItem,
+  //         co2PerPassenger: outbound.co2PerPassenger
+  //       },
+  //       intBasket,
+  //       this.searchService,
+  //       this.travellers
+  //     );
+  //   }
+  //   return Promise.resolve(false);
+  // }
+
+  // sortTicketPrices(tickets: TicketGroups): TicketGroups {
+  //   const sortTicketPrices = { ...tickets };
+  //   Object.keys(sortTicketPrices).map((key) => {
+  //     sortTicketPrices[key].sort((a: IrlTicketOption, b: IrlTicketOption) => {
+  //       const priceA = a.price,
+  //         priceB = b.price;
+  //       return priceA < priceB ? -1 : priceA > priceB ? 1 : 0;
+  //     });
+  //   });
+  //   return sortTicketPrices;
+  // // }
+  // sortTicketChildrenPrices(tickets: RailTicketGroups): RailTicketGroups {
+  //   const sortTicketPrices = { ...tickets };
+  //   Object.keys(sortTicketPrices).map((key) => {
+  //     sortTicketPrices[key].children.sort(
+  //       (a: RailTicketGroup, b: RailTicketGroup) => {
+  //         const priceA = a.header.price,
+  //           priceB = b.header.price;
+  //         return priceA < priceB ? -1 : priceA > priceB ? 1 : 0;
+  //       }
+  //     );
+  //   });
+  //   return sortTicketPrices;
+  // }
+  updateLowestPrice(results: IrlJourneyOptions[]): ICheapestPrice {
+    if (!results.length) return null;
+    const currency =
+      results[0].outbound[0].providers[0].cheapestTicket.currency;
+    const price = this.findCheapestTicket(results);
+    return {
+      amount: price,
+      currencyCode: currency
+    };
+  }
+  findCheapestTicket(results: IrlJourneyOptions[]): number {
+    this._cheapestFirst = null;
+    this._cheapestStandard = null;
+    if (!results.length) return null;
+    let cheapestArr: number[] = [];
+
+    results.map((result) => {
+      result.outbound.map((out) => {
+        out.providers.map((tkt) => {
+          let cheapestTicket: number = tkt.cheapestTicket.price;
+          tkt.ticketOptions.map((tktOption) => {
+            let tktPrice = tktOption.price;
+            let tktClass = tktOption.class;
+            if (
+              tktClass === 'First' &&
+              (this._cheapestFirst?.price > tktPrice || !this._cheapestFirst)
+            ) {
+              this._cheapestFirst = tktOption;
+            } else if (
+              tktClass === 'Standard' &&
+              (this._cheapestStandard?.price > tktPrice ||
+                !this._cheapestStandard)
+            ) {
+              this._cheapestStandard = tktOption;
+            }
+            if (tktPrice === cheapestTicket) {
+              cheapestArr.push(cheapestTicket);
+            }
+          });
+        });
+      });
+    });
+    return Math.min(...cheapestArr);
+  }
+}