AvailableRooms.cpp

//
// Created by Seo on 11/8/2025.
//

#include "AvailableRooms.h"

#include <filesystem>

// Reference static variables from AvailableRooms.h
std::unordered_map<int, Room> AvailableRooms::master_room_list;
std::vector<int> AvailableRooms::available_roomIDs;
std::vector<int> AvailableRooms::occupied_roomIDs;

std::vector<int>& AvailableRooms::getAvailableRoomIDs()
{
    return AvailableRooms::available_roomIDs;
}

std::vector<int>& AvailableRooms::getOccupiedRoomIDs()
{
    return AvailableRooms::occupied_roomIDs;
}

std::unordered_map<int, Room>& AvailableRooms::getAllRoomLookups() {
    return master_room_list;
}


// whether argument r.roomID is present in any ID's listed in available_roomIDs
bool AvailableRooms::isAvailable(const Room& r)
{
    return r.isRoomAvailable();

    // DEPRECIATED
    //for (const auto& room: available_roomIDs)
    //{
    //    if (r.getRoomID() == room.getRoomID())
    //        return true;
    //}
    //return false;
}

bool AvailableRooms::isOccupied(const Room& r)
{
    return !(r.isRoomAvailable());

    // DEPRECIATED
    //for (const auto& room: occupied_roomIDs)
    //{
    //    if (r.getRoomID() == room.getRoomID())
    //        return true;
    //}
    //return false;
}

// remove possible instance from occupied_roomIDs and
// add instance to available_roomIDs without duplicates
void AvailableRooms::setRoomAvailable(Room& r)
{
    r.setAvailable(true);

    // find and remove from occupied_roomIDs
    auto iterator = occupied_roomIDs.begin();

    for (; iterator != occupied_roomIDs.end(); ++iterator)
    {
        if (*iterator == r.getRoomID())  // match roomID's
        {
            occupied_roomIDs.erase(iterator);
            break;
        }
    }

    // add room to available rooms IF needed
    for (const auto& roomID : available_roomIDs)
    {
        if (roomID == r.getRoomID())
            return;                     // room already exists in available_room list. Exit the function
    }

    // when r.roomID is not found
    available_roomIDs.push_back(r.getRoomID());       // via custom copy-constructor (IMPORTANT)
}

// remove possible instance from available_room and
// add instance to occupied_roomIDs without duplicates
void AvailableRooms::setRoomOccupied(Room& r)
{
    r.setAvailable(false);

    // find and remove from available_roomIDs
    auto iterator = available_roomIDs.begin();

    for (; iterator != available_roomIDs.end(); ++iterator)
    {
        if (*iterator == r.getRoomID())  // match roomID's
        {
            available_roomIDs.erase(iterator);
            break;
        }
    }

    // add room to occupied rooms IF needed
    for (const auto& roomID : occupied_roomIDs)
    {
        if (roomID == r.getRoomID())
            return;                     // room already exists in occupied_room list. Exit the function
    }

    occupied_roomIDs.push_back(r.getRoomID());        // via custom copy-constructor (IMPORTANT)
}

Room& AvailableRooms::lookup(const int id) {

    return master_room_list.at(id);
    // throws an exception if ID isn't found
}

int AvailableRooms::getAvailableCount() {
    return available_roomIDs.size();
}

int AvailableRooms::getOccupiedCount() {
    return occupied_roomIDs.size();
}

int AvailableRooms::getTotalCount() {
    return getAvailableCount() + getOccupiedCount();
}

// Very Expensive function. Please use with care
// Load room information in disk, into the available_roomIDs vectors list
void AvailableRooms::LoadRoomsFILE(const std::string& path) {

    // Open file logic
    std::ifstream file;


    // FILE PATH ON WINDOWS via CMAKE ../Folder
    try {
        file.open(path);
        if (!file.is_open())
            throw std::runtime_error("FAILED TO OPEN FILE " + path +
                " attempting to use current directory (Works for Linux/*nix)\n");
    }
    catch (const std::runtime_error& e) {
        std::cout << e.what();

        // FILE PATH ON LINUX via Bash ./Folder
        try {
            file.open(path.substr(1));
            if (!file.is_open())
                throw std::runtime_error("FAILED TO OPEN FILE " + path);
        }
        catch (const std::runtime_error& ee) {
            std::cout << ee.what();
        }
    }


    // reset containers
    master_room_list.clear();
    available_roomIDs.clear();
    occupied_roomIDs.clear();

    // Read file logic
    std::string line_input;
    while (std::getline(file, line_input)) {

        // filter out white space
        if (line_input.empty())
            continue;

        // filter out comments
        if (!line_input.empty() && line_input.at(0) == '#')
            continue;


        // get individual room info via c++ string-stream library
        std::stringstream ss(line_input);
        std::string token;

        while (getline(ss, token, ' ')) {   // singe white-space delimiter


            int ID_input = std::stoi(token);    // room ID

            ss >> token;
            int NO_input = std::stoi(token);    // room Number

            ss >> token;
            int FLOOR_input = std::stoi(token); // room Floor

            ss >> token;
            bool AVAILABLE_input = static_cast<bool>(std::stoi(token));

            ss >> token;
            int TYPEID_input = std::stoi(token);

            ss >> token;
            std::string NAME_input = token;

            ss >> token;
            int BED_input = std::stoi(token);

            ss >> token;
            int CAPACITY_input = std::stoi(token);

            ss >> token;
            double BASERATE_input = std::stod(token);


            // Create RoomType structure
            RoomType roomtype;
            roomtype.typeID = TYPEID_input;
            roomtype.name = NAME_input;
            roomtype.beds = BED_input;
            roomtype.capacity = CAPACITY_input;
            roomtype.baseRate = BASERATE_input;

            // Create a room object INSIDE the hashmap
            // C++17 is required for this to work
            master_room_list.emplace(
                std::piecewise_construct,               // wtf is this .... lol
                std::forward_as_tuple(ID_input),
                std::forward_as_tuple(
                    ID_input, NO_input, FLOOR_input, roomtype, AVAILABLE_input));   // Calling Room() constructor


            // append to either-list, depending on what we read in the file!
            if (AVAILABLE_input == true)
                available_roomIDs.push_back(ID_input);
            else
                occupied_roomIDs.push_back(ID_input);
        }
    }

    // make sure you close
    file.close();
}

void AvailableRooms::SaveRoomsFILE(const std::string& path) {

    // Open file logic
    std::ofstream file;
    file.open(path);

    if (!file.is_open())
        throw std::runtime_error("Could not open file " + path);


    // output comments
    const std::string multiline_comment =
        "# Comments appear like this!\n"
        "#\n"
        "# Room class (AS of Nov-12-2025)\n"
        "# private:\n"
        "#      int roomID;\n"
        "#      int roomNo;\n"
        "#      int roomFloor;\n"
        "#      RoomType roomType;\n"
        "#      bool isAvailable{true};\n"
        "#\n"
        "#\n"
        "#      int typeID;\n"
        "#      std::string name;\n"
        "#      int beds;\n"
        "#      int capacity;\n"
        "#      double baseRate;\n"
        "#\n"
        "# SCHEMA:\n"
        "# roomID roomNo roomFloor isAvailable typeID name beds capacity baseRate"
        "\n";

    file << multiline_comment << std::endl;

    // Save each room to the path
    for (const auto& pair : AvailableRooms::getAllRoomLookups()) {

        file << std::to_string(pair.second.getRoomID()) << " ";
        file << std::to_string(pair.second.getRoomNo()) << " ";
        file << std::to_string(pair.second.getRoomFloor()) << " ";
        file << std::to_string(pair.second.isRoomAvailable()) << " ";
        file << std::to_string(pair.second.getRoomType().typeID) << " ";
        file << pair.second.getRoomType().name << " ";
        file << std::to_string(pair.second.getRoomType().beds) << " ";
        file << std::to_string(pair.second.getRoomType().capacity) << " ";
        file << std::to_string(pair.second.getRoomType().baseRate) << std::endl;

    }

    // dont forget to close
    file.close();

}