main.cpp

#include <iostream>
#include <fstream>
#include <sstream>
#include <unistd.h>
#include <sys/wait.h>
#include <vector>
#include <string>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <fcntl.h>
#include <errno.h>
#include <algorithm>


#include "utils.hpp"  
#include "logger.hpp" 
#include "const.hpp"

using namespace std;

vector<pair<string, string>> list_city_files(const string &stores_dir, Logger &log)
{
    vector<pair<string, string>> stores; // pair of city name and file path
    DIR *dir;
    struct dirent *ent;
    if ((dir = opendir(stores_dir.c_str())) != NULL)
    {
        while ((ent = readdir(dir)) != NULL)
        {
            string filename = ent->d_name;

            // Check if the file is a CSV and not Parts.csv
            if (filename.length() > 4 && filename.substr(filename.length() - 4) == ".csv" && filename != "Parts.csv")
            {
                string city_name = filename.substr(0, filename.length() - 4);
                string file_path = stores_dir + "/" + filename;
                stores.emplace_back(city_name, file_path);
                log.minfo("Found store: " + city_name + " with file: " + file_path);
            }
        }
        closedir(dir);
    }
    else
    {
        log.error("Could not open stores directory: " + stores_dir);
    }
    return stores;
}

int main(int argc, char *argv[])
{
    (void)argc;
    Logger log("Main");

    if (argc != 2)
    {
        cerr << "Usage: " << argv[0] << " <stores_directory>" << endl;
        return 1;
    }

    string stores_dir = argv[1];

    // List all city CSV files in the stores directory
    vector<pair<string, string>> stores = list_city_files(stores_dir, log);
    if (stores.empty())
    {
        log.error("No city CSV files found in the stores directory.");
        return 1;
    }
    log.minfo("All city store files scanned successfully.");

    // Read Parts.csv from the stores directory
    string parts_file = stores_dir + "/Parts.csv";
    ifstream parts_fs(parts_file);
    if (!parts_fs.is_open())
    {
        log.error("Failed to open Parts.csv file.");
        return 1;
    }
    string parts_line;
    getline(parts_fs, parts_line);
    parts_fs.close();

    vector<string> all_items = tokenize(parts_line, ',');
    if (all_items.empty())
    {
        log.error("No items found in Parts.csv.");
        return 1;
    }
    log.minfo("Parts file read successfully.");

    // Get user input: select items to report
    cout << "Available items:" << endl;
    for (size_t i = 0; i < all_items.size(); i++)
    {
        cout << i + 1 << ". " << all_items[i] << endl;
    }
    cout << "Enter the numbers of items you want to report, separated by space: ";
    string input;
    getline(cin, input);
    vector<string> selected_items;
    string selected_items_all_in_str = "";
    vector<string> input_tokens = tokenize(input, ' ');
    for (auto &tok : input_tokens)
    {
        try
        {
            int num = stoi(tok);
            if (num >= 1 && num <= (int)all_items.size())
            {
                selected_items.push_back(all_items[num - 1]);
                selected_items_all_in_str = selected_items_all_in_str + all_items[num - 1] + ',';
            }
            else
            {
                log.warning("Invalid item number entered: " + tok);
            }
        }
        catch (exception &e)
        {
            log.warning("Invalid input detected: " + tok);
        }
    }
    if (selected_items.empty())
    {
        log.error("No valid items selected for reporting.");
        return 1;
    }
    log.minfo("User selected items for reporting.");

    for (string item_name : selected_items)
    {
        string pipe_path = GOODS_PIPE_PREFIX + item_name;
        if (mkfifo(pipe_path.c_str(), 0666) == -1)
        {
            if (errno != EEXIST)
            {
                log.error("Failed to create named pipe: " + pipe_path);
                return 1;
            }
        }
        log.minfo("Named pipe created for good: " + item_name);
    }
    // --- Create two unnamed pipes for each city (to_child and from_child) ---
    vector<pair<int, int>> city_pipes_parent; // (to_child_write, from_child_read)
    vector<pair<int, int>> city_pipes_child;  // (to_child_read, from_child_write)
    for (size_t i = 0; i < stores.size(); i++)
    {
        int to_child[2], from_child[2];
        if (pipe(to_child) == -1 || pipe(from_child) == -1)
        {
            log.error("Failed to create pipes for city: " + stores[i].first);
            return 1;
        }
        city_pipes_parent.emplace_back(to_child[1], from_child[0]); // Parent writes to_child_write, reads from_child_read
        city_pipes_child.emplace_back(to_child[0], from_child[1]);  // Child reads to_child_read, writes from_child_write
    }

    // --- Create two unnamed pipes for each good (to_child and from_child) ---
    vector<pair<int, int>> good_pipes_parent; // (to_child_write, from_child_read)
    vector<pair<int, int>> good_pipes_child;  // (to_child_read, from_child_write)
    for (size_t i = 0; i < selected_items.size(); i++)
    {
        int to_child[2], from_child[2];
        if (pipe(to_child) == -1 || pipe(from_child) == -1)
        {
            log.error("Failed to create pipes for good: " + selected_items[i]);
            return 1;
        }
        good_pipes_parent.emplace_back(to_child[1], from_child[0]); // Parent writes to_child_write, reads from_child_read
        good_pipes_child.emplace_back(to_child[0], from_child[1]);  // Child reads to_child_read, writes from_child_write
    }

    // --- Fork City Processes and one write on it with unnammed pipe ---
    vector<pid_t> city_pids;
    vector<int> read_from_city_fds, write_to_city_fds;
    for (size_t i = 0; i < stores.size(); i++)
    {
        const pair<string, string> &store = stores[i];
        pid_t pid = fork();
        if (pid < 0)
        {
            log.error("Failed to fork city process for store: " + store.first);
            return 1;
        }
        if (pid == 0)
        {
            // --- Child Process: City ---
            close(city_pipes_parent[i].first);
            close(city_pipes_parent[i].second);
            string child_read_head = to_string(city_pipes_child[i].first);

            vector<char *> args;
            args.push_back(const_cast<char *>(EXE_CITY.c_str()));        // argv[0] exe file name for store process
            args.push_back(const_cast<char *>(child_read_head.c_str())); // argv[1] read head of store
            args.push_back(const_cast<char *>(store.first.c_str()));     // argv[2] name of store city
            args.push_back(nullptr);                                     // NULL terminator

            // Execute the city process
            execvp(EXE_CITY.c_str(), args.data());

            // If execvp returns, it failed
            log.error("Failed to execute city process for store: " + store.first);
            exit(1);
        }
        else
        {
            // --- Parent Process ---
            close(city_pipes_child[i].first);
            close(city_pipes_child[i].second);

            city_pids.push_back(pid);
            read_from_city_fds.push_back(city_pipes_parent[i].second);
            int write_to_city_fd = city_pipes_parent[i].first;

            // string args;
            string args = "";
            args = args + store.first + '!';  // name of city
            args = args + store.second + '!'; // file of city
            string num_items_str = to_string(selected_items.size());
            args = args + num_items_str + '!';                         // number of selected items
            args = args + to_string(city_pipes_child[i].second) + '!'; // write end of store pipe
            args = args + selected_items_all_in_str + '!';             // coded string of name of selected items

            // args example : Mashhad!stores/Mashhad.csv!2!14!shekar,berenj,!
            // Execute the city process
            write(city_pipes_parent[i].first, args.c_str(), args.size());
            close(write_to_city_fd);

            log.minfo("City process spawned for store: " + store.first);
        }
    }

    // --- Fork good Processes and one write on it with unnammed pipe ---
    vector<pid_t> good_pids;
    vector<int> read_from_good_fds, write_to_good_fds;
    for (size_t i = 0; i < selected_items.size(); i++)
    {
        pid_t pid = fork();
        string item = selected_items[i];

        if (pid < 0)
        {
            log.error("Failed to fork goods process for item: " + item);
            return 1;
        }
        if (pid == 0)
        {
            // --- Child Process: good ---
            close(good_pipes_parent[i].first);
            close(good_pipes_parent[i].second);

            // string child_write_head = to_string(city_pipes_child[i].second);
            string child_read_head = to_string(good_pipes_child[i].first);

            vector<char *> args;
            args.push_back(const_cast<char *>(EXE_GOODS.c_str()));       // argv[0]  .exe file name
            args.push_back(const_cast<char *>(child_read_head.c_str())); // argv[1]  read end of good process pipe
            args.push_back(const_cast<char *>(item.c_str()));            // argv[2]  name of good
            args.push_back(nullptr);                                     // NULL terminator

            // Execute the city process
            execvp(EXE_GOODS.c_str(), args.data());

            // If execvp returns, it failed
            log.error("Failed to execute good process for item: " + item);
            exit(1);
        }
        else
        {
            // --- Parent Process ---
            close(city_pipes_child[i].first);
            close(city_pipes_child[i].second);

            good_pids.push_back(pid);
            read_from_good_fds.push_back(good_pipes_parent[i].second);

            int write_to_good_fd = good_pipes_parent[i].first;
            string args = "";
            args = args + item + '!';
            args = args + to_string(good_pipes_child[i].second) + '!';
            string size_str = to_string(stores.size());
            args = args + size_str + '!'; // count of cities

            write(good_pipes_parent[i].first, args.c_str(), args.size());
            close(write_to_good_fd);

            log.minfo("Good process spawned for item: " + item);
        }
    }

    // -- one read on every city unnamed pipes --
    char buffer[MAX_BUFFER_SIZE];
    int total_final_profit = 0;
    for (auto fd : read_from_city_fds)
    {
        ssize_t bytes_read = read(fd, buffer, sizeof(buffer) - 1);
        if (bytes_read > 0)
        {
            string msg = buffer;
            total_final_profit += stoi(msg);
        }
        else
        {
            log.error("Empry message from a city");
        }
        close(fd);
    }

    // -- one read on every good unnamed pipes --
    for (auto fd : read_from_good_fds)
    {
        ssize_t bytes_read = read(fd, buffer, sizeof(buffer) - 1);
        string total_leftover_of_this_item = buffer;
        if (bytes_read > 0)
        {
            log.output(total_leftover_of_this_item);
        }
        else
        {
            log.error("Empry message from a good");
        }
        close(fd);
    }

    log.output("Total profits of all stores is " + to_string(total_final_profit)+ "\n");

    // --- Cleanup: Remove Named Pipes ---
    for (string item_name : selected_items)
    {
        string pipe_path = GOODS_PIPE_PREFIX + item_name;

        if (unlink(pipe_path.c_str()) == 0)
        {
            log.minfo("Named pipe removed for good: " + item_name);
        }
        else
        {
            log.warning("Failed to remove named pipe for good: " + item_name);
        }
    }

    while (wait(NULL) != -1);

    log.minfo("Program completed successfully.");
    return 0;
}