TheAirline.Models.Airlines.Airline.AddAirliner C# (CSharp) Method

        public void AddAirliner(FleetAirliner airliner)
        {
            lock (Fleet)
            {
                Fleet.Add(airliner);
            }
        }

        private static void CreateComputerRoutes(Airline airline)
        {
            bool leaseAircraft = airline.Profile.PrimaryPurchasing == AirlineProfile.PreferedPurchasing.Leasing;

            Airport airportHomeBase = FindComputerHomeBase(airline);

            AirportFacility serviceFacility =
                AirportFacilities.GetFacilities(AirportFacility.FacilityType.Service).Find(f => f.TypeLevel == 1);
            AirportFacility checkinFacility =
                AirportFacilities.GetFacilities(AirportFacility.FacilityType.CheckIn).Find(f => f.TypeLevel == 1);
            AirportFacility cargoTerminal =
                AirportFacilities.GetFacilities(AirportFacility.FacilityType.Cargo).Find(f => f.TypeLevel > 0);

            airportHomeBase.AddAirportFacility(airline, serviceFacility, GameObject.GetInstance().GameTime);
            airportHomeBase.AddAirportFacility(airline, checkinFacility, GameObject.GetInstance().GameTime);

            if (airline.AirlineRouteFocus == Route.RouteType.Cargo)
            {
                airportHomeBase.AddAirportFacility(airline, cargoTerminal, GameObject.GetInstance().GameTime);
            }

            AirlineStartData startData = AirlineStartDatas.GetAirlineStartData(airline);

            //creates the start data for an airline
            if (startData != null)
            {
                AirportHelpers.RentGates(airportHomeBase, airline, AirportContract.ContractType.Full);

                CreateAirlineStartData(airline, startData);
            }
            else
            {
                List<Airport> airportDestinations = AIHelpers.GetDestinationAirports(airline, airportHomeBase);

                if (airportDestinations.Count == 0)
                {
                    airportDestinations =
                        Airports.GetAirports(
                            a =>
                            a.Profile.Country.Region == airportHomeBase.Profile.Country.Region
                            && a != airportHomeBase);
                }

                KeyValuePair<Airliner, bool>? airliner = null;
                Airport airportDestination = null;

                int counter = 0;

                while ((airportDestination == null || airliner == null || !airliner.HasValue)
                       && airportDestinations.Count > counter)
                {
                    airportDestination = airportDestinations[counter];

                    airliner = AIHelpers.GetAirlinerForRoute(
                        airline,
                        airportHomeBase,
                        airportDestination,
                        leaseAircraft,
                        airline.AirlineRouteFocus,
                        true);

                    counter++;
                }

                if (airportDestination == null || !airliner.HasValue)
                {
                    CreateComputerRoutes(airline);
                }
                else
                {
                    AirportHelpers.AddAirlineContract(
                        new AirportContract(
                            airline,
                            airportHomeBase,
                            AirportContract.ContractType.Full,
                            airline.AirlineRouteFocus == Route.RouteType.Cargo ? Terminal.TerminalType.Cargo : Terminal.TerminalType.Passenger,
                            GameObject.GetInstance().GameTime,
                            2,
                            25,
                            0,
                            true));

                    AirportHelpers.RentGates(airportDestination, airline, AirportContract.ContractType.LowService);
                    //airportDestination.addAirportFacility(airline, checkinFacility, GameObject.GetInstance().GameTime);

                    Guid id = Guid.NewGuid();

                    double price = PassengerHelpers.GetPassengerPrice(airportDestination, airline.Airports[0]);

                    Route route = null;
                    if (airline.AirlineRouteFocus == Route.RouteType.Passenger)
                    {
                        route = new PassengerRoute(
                            id.ToString(),
                            airportDestination,
                            airline.Airports[0],
                            GameObject.GetInstance().GameTime,
                            price);

                        RouteClassesConfiguration configuration = AIHelpers.GetRouteConfiguration((PassengerRoute) route);

                        foreach (RouteClassConfiguration classConfiguration in configuration.GetClasses())
                        {
                            ((PassengerRoute) route).GetRouteAirlinerClass(classConfiguration.Type).FarePrice = price
                                                                                                                *GeneralHelpers
                                                                                                                     .ClassToPriceFactor
                                                                                                                     (
                                                                                                                         classConfiguration
                                                                                                                             .Type);

                            foreach (RouteFacility rFacility in classConfiguration.GetFacilities())
                            {
                                ((PassengerRoute) route).GetRouteAirlinerClass(classConfiguration.Type)
                                                        .AddFacility(rFacility);
                            }
                        }
                    }
                    if (airline.AirlineRouteFocus == Route.RouteType.Helicopter)
                    {
                        route = new HelicopterRoute(
                            id.ToString(),
                            airportDestination,
                            airline.Airports[0],
                            GameObject.GetInstance().GameTime,
                            price);

                        RouteClassesConfiguration configuration = AIHelpers.GetRouteConfiguration((HelicopterRoute) route);

                        foreach (RouteClassConfiguration classConfiguration in configuration.GetClasses())
                        {
                            ((HelicopterRoute) route).GetRouteAirlinerClass(classConfiguration.Type).FarePrice = price
                                                                                                                 *GeneralHelpers
                                                                                                                      .ClassToPriceFactor
                                                                                                                      (
                                                                                                                          classConfiguration
                                                                                                                              .Type);

                            foreach (RouteFacility rFacility in classConfiguration.GetFacilities())
                            {
                                ((HelicopterRoute) route).GetRouteAirlinerClass(classConfiguration.Type)
                                                         .AddFacility(rFacility);
                            }
                        }
                    }
                    if (airline.AirlineRouteFocus == Route.RouteType.Cargo)
                    {
                        route = new CargoRoute(
                            id.ToString(),
                            airportDestination,
                            airline.Airports[0],
                            GameObject.GetInstance().GameTime,
                            PassengerHelpers.GetCargoPrice(airportDestination, airline.Airports[0]));

                        airportDestination.AddAirportFacility(airline, cargoTerminal, GameObject.GetInstance().GameTime);
                    }
                    if (leaseAircraft)
                    {
                        AirlineHelpers.AddAirlineInvoice(
                            airline,
                            GameObject.GetInstance().GameTime,
                            Invoice.InvoiceType.Rents,
                            -airliner.Value.Key.LeasingPrice*2);
                    }
                    else
                    {
                        AirlineHelpers.AddAirlineInvoice(
                            airline,
                            GameObject.GetInstance().GameTime,
                            Invoice.InvoiceType.Purchases,
                            -airliner.Value.Key.GetPrice());
                    }

                    var fAirliner =
                        new FleetAirliner(
                            leaseAircraft ? FleetAirliner.PurchasedType.Leased : FleetAirliner.PurchasedType.Bought,
                            GameObject.GetInstance().GameTime,
                            airline,
                            airliner.Value.Key,
                            airportHomeBase) {Status = FleetAirliner.AirlinerStatus.ToRouteStart};
                    fAirliner.AddRoute(route);
                    AirlinerHelpers.CreateAirlinerClasses(fAirliner.Airliner);
                    AirlineHelpers.HireAirlinerPilots(fAirliner);

                    airline.AddAirliner(fAirliner);

                    airline.AddRoute(route);
                    if (route != null)
                    {
                        route.LastUpdated = GameObject.GetInstance().GameTime;

                        if (route.Type == Route.RouteType.Passenger || route.Type == Route.RouteType.Mixed)
                        {
                            AIHelpers.CreateRouteTimeTable(route, fAirliner);
                        }
                        if (route.Type == Route.RouteType.Cargo)
                        {
                            AIHelpers.CreateCargoRouteTimeTable(route, fAirliner);
                        }
                    }
                }
            }
        }