AirlineSystem.cpp

#include "AirlineSystem.h"

#include <iostream>
#include <algorithm>

#include <fstream>
#include <sstream>

void AirlineSystem::showFlights() const
{
    if (flights.empty())
    {
        std::cout << "No flights available.\n";
        return;
    }

    for (const auto& flight : flights)
    {
        flight.displayInfo();
        std::cout << "---------------------\n";
    }
}

void AirlineSystem::showPassengers() const
{
    if (passengers.empty())
    {
        std::cout << "No passengers available.\n";
        return;
    }

    for (const auto& passenger : passengers)
    {
        passenger.displayInfo();
    }
}

void AirlineSystem::showReservations() const
{
    if (reservations.empty())
    {
        std::cout << "No reservations.\n";
        return;
    }

    for (const auto& reservation : reservations)
    {
        reservation.displayInfo();
    }
}

void AirlineSystem::addFlight()
{
    std::string flightNumber;
    std::string departureCity;
    std::string arrivalCity;
    std::string departureTime;
    int totalSeats;

    std::cout << "Flight number: ";
    std::cin >> flightNumber;

    std::cout << "Departure city: ";
    std::cin >> departureCity;

    std::cout << "Arrival city: ";
    std::cin >> arrivalCity;

    std::cout << "Departure time: ";
    std::cin >> departureTime;

    std::cout << "Total seats: ";
    std::cin >> totalSeats;

    flights.emplace_back(
        flightNumber,
        departureCity,
        arrivalCity,
        departureTime,
        totalSeats
    );

    saveFlights();
    std::cout << "Flight successfully added.\n";
}

void AirlineSystem::addPassenger()
{
    int id;
    std::string firstName;
    std::string lastName;

    std::cout << "Passenger ID: ";
    std::cin >> id;

    std::cout << "First name: ";
    std::cin >> firstName;

    std::cout << "Last name: ";
    std::cin >> lastName;

    passengers.emplace_back(
        id,
        firstName,
        lastName
    );
    savePassengers();
    std::cout << "Passenger successfully added.\n";
}

void AirlineSystem::searchFlightByDestination() const
{
    std::string destination;

    std::cout << "Enter destination city: ";
    std::cin >> destination;

    bool found = false;

    for (const auto& flight : flights)
    {
        if (flight.getArrivalCity() == destination)
        {
            flight.displayInfo();
            found = true;
        }
    }

    if (!found)
    {
        std::cout << "No flights found.\n";
    }
}

void AirlineSystem::makeReservation()
{
    int passengerId;
    std::string flightNumber;

    std::cout << "Passenger ID: ";
    std::cin >> passengerId;

    std::cout << "Flight number: ";
    std::cin >> flightNumber;

    Passenger* passengerPtr = nullptr;
    Flight* flightPtr = nullptr;

    for (auto& passenger : passengers)
    {
        if (passenger.getPassengerId() == passengerId)
        {
            passengerPtr = &passenger;
            break;
        }
    }

    for (auto& flight : flights)
    {
        if (flight.getFlightNumber() == flightNumber)
        {
            flightPtr = &flight;
            break;
        }
    }

    if (passengerPtr == nullptr)
    {
        std::cout << "Passenger not found.\n";
        return;
    }

    if (flightPtr == nullptr)
    {
        std::cout << "Flight not found.\n";
        return;
    }

    for (const auto& reservation : reservations)
    {
        if (reservation.getPassengerId() == passengerId &&
            reservation.getFlightNumber() == flightNumber)
        {
            std::cout << "Passenger already has a reservation for this flight.\n";
            return;
        }
    }

    int numberOfTickets;

    std::cout << "Available seats: "
          << flightPtr->getAvailableSeats()
          << "\n";

    std::cout << "Number of tickets: ";
    std::cin >> numberOfTickets;

    if (!flightPtr->reserveSeats(numberOfTickets)){
        std::cout << "Not enough available seats.\n";
        std::cout << "Only "
                  << flightPtr->getAvailableSeats()
                  << " seats are available.\n";
        return;
    }

    int reservationId =
    static_cast<int>(reservations.size()) + 1;

    for (int i = 0; i < numberOfTickets; i++){
        reservations.emplace_back(
            reservationId++,
            passengerId,
            flightNumber
        );
    }

    saveReservations();
    saveFlights(); // jer se promenio broj slobodnih mesta

    std::cout << "Reservation successfully created.\n";
}

void AirlineSystem::cancelReservation()
{
    int reservationId;

    std::cout << "Reservation ID: ";
    std::cin >> reservationId;

    auto reservationIt =
        std::find_if(
            reservations.begin(),
            reservations.end(),
            [reservationId](const Reservation& reservation)
            {
                return reservation.getReservationId() == reservationId;
            }
        );

    if (reservationIt == reservations.end())
    {
        std::cout << "Reservation not found.\n";
        return;
    }

    for (auto& flight : flights)
    {
        if (flight.getFlightNumber() ==
            reservationIt->getFlightNumber())
        {
            flight.cancelSeat();
            break;
        }
    }

    reservations.erase(reservationIt);

    saveReservations();
    saveFlights(); // zbog broja slobodnih mesta

    std::cout << "Reservation cancelled.\n";
}

void AirlineSystem::removeFlight()
{
    std::string flightNumber;

    std::cout << "Flight number: ";
    std::cin >> flightNumber;

    for (const auto& reservation : reservations)
    {
        if (reservation.getFlightNumber() == flightNumber)
        {
            std::cout << "Cannot delete flight with active reservations.\n";
            return;
        }
    }

    auto flightIt =
        std::find_if(
            flights.begin(),
            flights.end(),
            [&flightNumber](const Flight& flight)
            {
                return flight.getFlightNumber() == flightNumber;
            }
        );

    if (flightIt == flights.end())
    {
        std::cout << "Flight not found.\n";
        return;
    }

    flights.erase(flightIt);
    saveFlights();

    std::cout << "Flight removed.\n";
}

void AirlineSystem::removePassenger()
{
    int passengerId;

    std::cout << "Passenger ID: ";
    std::cin >> passengerId;

    for (const auto& reservation : reservations)
    {
        if (reservation.getPassengerId() == passengerId)
        {
            std::cout << "Cannot delete passenger with active reservations.\n";
            return;
        }
    }

    auto passengerIt =
        std::find_if(
            passengers.begin(),
            passengers.end(),
            [passengerId](const Passenger& passenger)
            {
                return passenger.getPassengerId() == passengerId;
            }
        );

    if (passengerIt == passengers.end())
    {
        std::cout << "Passenger not found.\n";
        return;
    }

    passengers.erase(passengerIt);
    savePassengers();

    std::cout << "Passenger removed.\n";
}

void AirlineSystem::saveFlights() const
{
    std::ofstream file("flights.txt");

    for (const auto& flight : flights)
    {
        file
            << flight.getFlightNumber() << ";"
            << flight.getDepartureCity() << ";"
            << flight.getArrivalCity() << ";"
            << flight.getDepartureTime() << ";"
            << flight.getTotalSeats() << ";"
            << flight.getAvailableSeats() << ";"
            << static_cast<int>(flight.getStatus())
            << "\n";
    }
}

void AirlineSystem::loadFlights()
{
    flights.clear();

    std::ifstream file("flights.txt");

    std::string line;

    while (getline(file, line))
    {
        std::stringstream ss(line);

        std::string flightNumber;
        std::string departureCity;
        std::string arrivalCity;
        std::string departureTime;
        std::string seatsString;
        std::string availableSeatsString;
        std::string statusString;

        getline(ss, flightNumber, ';');
        getline(ss, departureCity, ';');
        getline(ss, arrivalCity, ';');
        getline(ss, departureTime, ';');
        getline(ss, seatsString, ';');
        getline(ss, availableSeatsString, ';');
        getline(ss, statusString);

        Flight flight(
            flightNumber,
            departureCity,
            arrivalCity,
            departureTime,
            stoi(seatsString)
        );

        flight.setAvailableSeats(
            stoi(availableSeatsString)
        );

        flight.setStatus(
            static_cast<FlightStatus>(stoi(statusString))
        );

        flights.push_back(flight);
    }
}

void AirlineSystem::savePassengers() const
{
    std::ofstream file("passengers.txt");

    for (const auto& passenger : passengers)
    {
        file
            << passenger.getPassengerId() << ";"
            << passenger.getFirstName() << ";"
            << passenger.getLastName()
            << "\n";
    }
}

void AirlineSystem::loadPassengers()
{
    passengers.clear();

    std::ifstream file("passengers.txt");

    std::string line;

    while (getline(file, line))
    {
        std::stringstream ss(line);

        std::string idString;
        std::string firstName;
        std::string lastName;

        getline(ss, idString, ';');
        getline(ss, firstName, ';');
        getline(ss, lastName);

        passengers.emplace_back(
            stoi(idString),
            firstName,
            lastName
        );
    }
}

void AirlineSystem::saveReservations() const
{
    std::ofstream file("reservations.txt");

    for (const auto& reservation : reservations)
    {
        file
            << reservation.getReservationId() << ";"
            << reservation.getPassengerId() << ";"
            << reservation.getFlightNumber()
            << "\n";
    }
}

void AirlineSystem::loadReservations()
{
    reservations.clear();

    std::ifstream file("reservations.txt");

    std::string line;

    while (getline(file, line))
    {
        std::stringstream ss(line);

        std::string reservationId;
        std::string passengerId;
        std::string flightNumber;

        getline(ss, reservationId, ';');
        getline(ss, passengerId, ';');
        getline(ss, flightNumber);

        reservations.emplace_back(
            stoi(reservationId),
            stoi(passengerId),
            flightNumber
        );
    }

    
}

void AirlineSystem::changeFlightStatus()
{
    std::string flightNumber;

    std::cout << "Flight number: ";
    std::cin >> flightNumber;

    for (auto& flight : flights)
    {
        if (flight.getFlightNumber() == flightNumber)
        {
            int choice;

            std::cout << "\nChoose new status:\n";
            std::cout << "1. On Time\n";
            std::cout << "2. Delayed\n";
            std::cout << "3. Cancelled\n";
            std::cout << "Choice: ";

            std::cin >> choice;

            switch (choice)
            {
            case 1:
                flight.setStatus(FlightStatus::OnTime);
                break;

            case 2:
                flight.setStatus(FlightStatus::Delayed);
                break;

            case 3:
                flight.setStatus(FlightStatus::Cancelled);
                break;

            default:
                std::cout << "Invalid option.\n";
                return;
            }

            std::cout << "Flight status updated successfully.\n";
            return;
        }
    }

    std::cout << "Flight not found.\n";
}