// SchedFlight.hxx
//
// Written by Durk Talsma, started May 5, 2004.
//
// SPDX-License-Identifier: GPL-2.0-or-later
// SPDX-FileCopyrightText: 2004 Durk Talsma

/**************************************************************************
 * ScheduledFlight is a class that is used by FlightGear's Traffic Manager
 * A scheduled flight can be assigned to a schedule, which can be assigned
 * to an aircraft. The traffic manager decides for each schedule which
 * scheduled flight (if any) is currently active. I no scheduled flights
 * are found active, it tries to position the aircraft associated with this
 * schedule at departure airport of the next scheduled flight.
 * The class ScheduledFlight is a software implementation of this.
 * In summary, this class stores arrival and departure information, as well
 * as some administrative data, such as the callsign of this particular
 * flight (used in future ATC scenarios), under which flight rules the
 * flight is taking place, as well as a requested initial cruise altitude.
 * Finally, the class contains a repeat period, which indicates after how
 * many seconds a flight should repeat in this schedule (which is usually
 * after either a day or a week). If this value is zero, this flight won't
 * repeat.
 **************************************************************************/

#pragma once


class FGAirport;

class FGScheduledFlight
{
private:
    static std::map<std::string, std::string> missingAirports;

    std::string callsign;
    std::string fltRules;

    FGAirport* departurePort;
    FGAirport* arrivalPort;

    std::string depId;
    std::string arrId;
    std::string requiredAircraft;

    time_t departureTime;
    time_t arrivalTime;
    time_t repeatPeriod;

    int cruiseAltitude;
    bool initialized;
    bool available;

public:
    FGScheduledFlight();
    FGScheduledFlight(const FGScheduledFlight& other);
    //  FGScheduledFlight(const std::string);
    FGScheduledFlight(const std::string& cs,
                      const std::string& fr,
                      const std::string& depPrt,
                      const std::string& arrPrt,
                      int cruiseAlt,
                      const std::string& deptime,
                      const std::string& arrtime,
                      const std::string& rep,
                      const std::string& reqAC);
    ~FGScheduledFlight();

    void update();
    bool initializeAirports();

    void adjustTime(time_t now);

    time_t getDepartureTime() { return departureTime; };
    time_t getArrivalTime() { return arrivalTime; };

    void setDepartureAirport(const std::string& port) { depId = port; };
    void setArrivalAirport(const std::string& port) { arrId = port; };
    FGAirport* getDepartureAirport();
    FGAirport* getArrivalAirport();

    int getCruiseAlt() { return cruiseAltitude; };

    bool operator<(const FGScheduledFlight& other) const
    {
        return (departureTime < other.departureTime);
    };
    const std::string& getFlightRules() { return fltRules; };

    time_t processTimeString(const std::string& time);
    const std::string& getCallSign() { return callsign; };
    const std::string& getRequirement() { return requiredAircraft; }

    void lock() { available = false; };
    void release() { available = true; };

    bool isAvailable() { return available; };

    void setCallSign(const std::string& val) { callsign = val; };
    void setFlightRules(const std::string& val) { fltRules = val; };

    static bool compareScheduledFlights(const FGScheduledFlight* a, const FGScheduledFlight* b);
};

typedef std::vector<FGScheduledFlight*> FGScheduledFlightVec;
typedef std::vector<FGScheduledFlight*>::iterator FGScheduledFlightVecIterator;

typedef std::map<std::string, FGScheduledFlightVec> FGScheduledFlightMap;
