public static object ShowPopUp(Airline airline)
        {
            PopUpWindow window = new PopUpCodeshareAgreement(airline);
            window.ShowDialog();

            return window.Selected;
        }

 public Scenario(
     string name,
     string description,
     Airline airline,
     Airport homebase,
     int startyear,
     int endyear,
     long startcash,
     DifficultyLevel difficulty)
 {
     Name = name;
     Airline = airline;
     Homebase = homebase;
     StartYear = startyear;
     StartCash = startcash;
     Description = description;
     Difficulty = difficulty;
     EndYear = endyear;
     OpponentAirlines = new List<ScenarioAirline>();
     Destinations = new List<Airport>();
     Fleet = new Dictionary<AirlinerType, int>();
     Routes = new List<ScenarioAirlineRoute>();
     Failures = new List<ScenarioFailure>();
     PassengerDemands = new List<ScenarioPassengerDemand>();
 }

 public AirlineStartData(Airline airline)
 {
     Airline = airline;
     Routes = new List<StartDataRoute>();
     Airliners = new List<StartDataAirliners>();
     OriginRoutes = new List<StartDataRoutes>();
 }

        public PopUpCreateSubsidiary(Airline airline)
        {
            this.Airline = airline;

            this.DataContext = this.Airline;

            this.MaxSubsidiaryMoney = this.Airline.Money / 2;

            this.IATAOk = false;

            this.Colors = new List<PropertyInfo>();

            foreach (PropertyInfo c in typeof(Colors).GetProperties())
            {
                this.Colors.Add(c);
            }

            this.AllAirports = new ObservableCollection<Airport>();
            /*
            foreach (
                Airport airport in
                    this.Airline.Airports.FindAll(
                    a => a.Terminals.getFreeSlotsPercent(this.Airline,this.Airline.AirlineRouteFocus == Route.RouteType.Passenger ? Terminal.TerminalType.Passenger : Terminal.TerminalType.Cargo) > 50))
            {
                this.AllAirports.Add(airport);
            }*/

            this.Loaded += PopUpCreateSubsidiary_Loaded;

            InitializeComponent();
        }

 //changes the demand for all airports belonging to an airline with a factor
 public static void ChangePaxDemand(Airline airline, double factor)
 {
     foreach (Airport a in airline.Airports)
     {
         ChangePaxDemand(a, factor);
     }
 }

        public static object ShowPopUp(Airline airline,Airport airport)
        {
            PopUpWindow window = new PopUpAddCooperation(airline,airport);
            window.ShowDialog();

            return window.Selected;
        }

 public AirportContract(
     Airline airline,
     Airport airport,
     ContractType type,
     Terminal.TerminalType terminaltype,
     DateTime date,
     int numberOfGates,
     int length,
     double yearlyPayment,
     bool autorenew,
     bool payFull = false,
     bool isExclusiveDeal = false,
     Terminal terminal = null)
 {
     Type = type;
     PayFull = payFull;
     Airline = airline;
     Airport = airport;
     ContractDate = date;
     Length = length;
     YearlyPayment = yearlyPayment;
     NumberOfGates = numberOfGates;
     IsExclusiveDeal = isExclusiveDeal;
     Terminal = terminal;
     ExpireDate = ContractDate.AddYears(Length);
     AutoRenew = autorenew;
     TerminalType = terminaltype;
 }

 public AirlineAirportFacility(Airline airline, Airport airport, AirportFacility facility, DateTime date)
 {
     Airline = airline;
     Facility = facility;
     FinishedDate = date;
     Airport = airport;
 }

        public FleetAirliner(
            PurchasedType purchased,
            DateTime purchasedDate,
            Airline airline,
            Airliner airliner,
            Airport homebase)
        {
            Airliner = airliner;
            Purchased = purchased;
            PurchasedDate = purchasedDate;
            Airliner.Airline = airline;
            Homebase = homebase;
            Name = airliner.TailNumber;
            Statistics = new AirlinerStatistics(this);
            LastCMaintenance = Airliner.BuiltDate;
            LastAMaintenance = Airliner.BuiltDate;
            LastBMaintenance = Airliner.BuiltDate;
            LastDMaintenance = Airliner.BuiltDate;
            Status = AirlinerStatus.Stopped;
            MaintRoutes = new List<Route>();

            CurrentPosition = Homebase;
            //new GeoCoordinate(this.Homebase.Profile.Coordinates.Latitude,this.Homebase.Profile.Coordinates.Longitude);

            Routes = new List<Route>();
            Pilots = new List<Pilot>();
            InsurancePolicies = new List<AirlinerInsurance>();
            MaintenanceHistory = new Dictionary<Invoice, string>();

            Data = new OperatingData();

            if (Purchased == PurchasedType.Bought || Purchased == PurchasedType.BoughtDownPayment)
                Airliner.Owner = Airliner.Airline;
        }

 public SpecialContract(SpecialContractType type, DateTime date, Airline airline)
 {
     Airline = airline;
     Type = type;
     Date = date;
     IsOk = true;
     Routes = new List<Route>();
 }

        public PopUpCodeshareAgreement(Airline airline)
        {
            this.Airline = airline;
            this.DataContext = this.Airline;
            this.Price = AirlineHelpers.GetCodesharingPrice(this.Airline,GameObject.GetInstance().HumanAirline);
            this.TicketSalePercent = CodeshareAgreement.TicketSalePercent;

            InitializeComponent();
        }

        public Gates(int numberOfGates, DateTime deliveryDate, Airline airline)
        {
            _terminalGates = new List<Gate>();
            for (int i = 0; i < numberOfGates; i++)
            {
                var gate = new Gate(deliveryDate) {Airline = airline};

                _terminalGates.Add(gate);
            }
        }

        public static long GetAvgSubValue(Airline airline)
        {
            if (!airline.Subsidiaries.Any())
            {
                return 0;
            }

            return GetTotalSubValues(GameObject.GetInstance().HumanAirline)
                   /GameObject.GetInstance().HumanAirline.Subsidiaries.Count();
        }

        public Terminal(Airport airport, Airline airline, string name, int gates, DateTime deliveryDate, TerminalType type)
        {
            Airport = airport;
            Airline = airline;
            Name = name;
            DeliveryDate = new DateTime(deliveryDate.Year, deliveryDate.Month, deliveryDate.Day);
            Type = type;

            Gates = new Gates(gates, DeliveryDate, airline);
        }

        public static void GenerateEvents(Airline airline)
        {
            var rnd = new Random();
            var eventOccurences = new Dictionary<RandomEvent.EventType, double>();
            int eFreq;

            //sets an overall event frequency based on an airlines total overall rating
            int totalRating = airline.Ratings.CustomerHappinessRating + airline.Ratings.EmployeeHappinessRating
                              + airline.Ratings.SafetyRating + airline.Ratings.SecurityRating;
            if (totalRating < 300)
            {
                eFreq = rnd.Next(1, 6);
            }
            else if (totalRating < 200)
            {
                eFreq = rnd.Next(4, 10);
            }
            else if (totalRating < 100)
            {
                eFreq = rnd.Next(8, 16);
            }
            else
            {
                eFreq = rnd.Next(0, 4);
            }

            //gets the event proportions and multiplies them by total # events to get events per type
            List<double> probs = GetEventProportions(airline);
            double custEvents = eFreq*probs[0];
            double empEvents = eFreq*probs[1];
            double secEvents = eFreq*probs[2];
            double safEvents = eFreq*probs[3];
            double maintEvents = eFreq*probs[4];
            double polEvents = eFreq - custEvents - empEvents - secEvents - maintEvents;
            eventOccurences.Add(RandomEvent.EventType.Customer, custEvents);
            eventOccurences.Add(RandomEvent.EventType.Employee, empEvents);
            eventOccurences.Add(RandomEvent.EventType.Maintenance, maintEvents);
            eventOccurences.Add(RandomEvent.EventType.Safety, safEvents);
            eventOccurences.Add(RandomEvent.EventType.Security, secEvents);
            eventOccurences.Add(RandomEvent.EventType.Political, polEvents);

            /*
            //generates the given number of events for each type
            foreach (KeyValuePair<RandomEvent.EventType, double> v in eventOccurences)
            {
                int k = (int)v.Value;
                List<RandomEvent> list = RandomEvents.GetEvents(v.Key, k, airline);
                foreach (RandomEvent e in list)
                {
                    airline.EventLog.Add(e);
                }
            }
            */
        }

        //returns the value for a statistics type for an airline for a year
        public double GetStatisticsValue(int year, Airline airline, StatisticsType type)
        {
            AirportStatisticsValue item =
                Stats.Find(s => s.Year == year && s.Airline == airline && s.Stat.Shortname == type.Shortname);

            if (item == null)
            {
                return 0;
            }
            return item.Value;
        }

 public static void AddPassengerHappiness(Airline airline)
 {
     /*
     lock (HappinessPercent)
     {
         if (HappinessPercent.ContainsKey(airline))
             HappinessPercent[airline] += 1;
         else
             HappinessPercent.Add(airline, 1);
     }
      * */
 }

        public void AddStatisticsValue(int year, Airline airline, StatisticsType type, int value)
        {
            AirportStatisticsValue item =
                Stats.Find(s => s.Year == year && s.Airline == airline && s.Stat.Shortname == type.Shortname);

            if (item == null)
            {
                Stats.Add(new AirportStatisticsValue(airline, year, type, value));
            }
            else
            {
                item.Value += value;
            }
        }

        public PopUpAddCooperation(Airline airline, Airport airport)
        {
            this.Types = new List<CooperationType>();

            this.Airline = airline;
            this.Airport = airport;

            foreach (CooperationType type in CooperationTypes.GetCooperationTypes())
            {
                if (!this.Airport.Cooperations.Exists(c => c.Airline == airline && c.Type == type) && type.AirportSizeRequired<=this.Airport.Profile.Size)
                    this.Types.Add(type);
            }

            InitializeComponent();
        }

        //returns all airline luxury levels
        //calculates employee happiness as a function of wages, discounts, and free pilots (relative to workload)
        public static double GetEmployeeHappiness(Airline airline)
        {
            Dictionary<Airline, double> wages = StatisticsHelpers.GetEmployeeWages();
            Dictionary<Airline, double> discounts = StatisticsHelpers.GetEmployeeDiscounts();
            Dictionary<Airline, double> unassignedPilots = StatisticsHelpers.GetUnassignedPilots();
            IDictionary<Airline, double> scaleWages = StatisticsHelpers.GetRatingScale(wages);
            IDictionary<Airline, double> scaleDiscounts = StatisticsHelpers.GetRatingScale(discounts);
            IDictionary<Airline, double> scaleUPilots = StatisticsHelpers.GetRatingScale(unassignedPilots);

            double airlineWages = scaleWages[airline];
            double airlineDiscounts = scaleDiscounts[airline];
            double airlineUnassignedPilots = scaleUPilots[airline];

            return (airlineWages*0.7) + (airlineUnassignedPilots*0.2) + (airlineDiscounts*0.1);
        }