main.cpp

#include <string>
#include <iostream>
#include <unordered_set>
#include <fstream>
#include <ctime>
#include <vector>
#include <algorithm>
#include <cctype>
#include <regex>
#include <stdexcept>

/* - CUSTOMER - */
class Customer{
    private:

        std::string ID;
        std::string name, surname;
        /*
            used_credentials is an unordered set used to avoid to have the same name-surname for two different Customers.
        */
        static std::unordered_set<std::string> used_credentials;

        std::string create_ID_customer(std::string _name, std::string _surname){
            std::string _ID = build_ID(_name, _surname);
            // check credentials uniqueness
            check_credentials_uniqueness( _name, _surname );
            // add to set
            add_to_used_credentials(_name, _surname);

            return _ID;
        }

    public:
        /*
            NOTE: method needed to re-build used_credentials from file.
        */
        static void clear_used_credentials() {
            used_credentials.clear();
        }

        // static to be used in load_from_file() too
        static std::string build_credentials(std::string _name, std::string _surname){
            return _name + "#" + _surname;
        }

        // static to be used in load_from_file() too
        static void check_credentials_uniqueness(std::string _name, std::string _surname){
            if ( used_credentials.find( build_credentials(_name, _surname) ) != used_credentials.end() ){
                throw std::runtime_error("Combination of name and surname already existing. Please try a new one.");
            }
        }

        void add_to_used_credentials(std::string _name, std::string _surname){
            used_credentials.insert( build_credentials(_name, _surname) );
        }
        void remove_from_used_credentials(std::string _name, std::string _surname) {
            used_credentials.erase( build_credentials(_name, _surname) );
        }

        std::string build_ID(std::string _name, std::string _surname){
            time_t tmstp;
            std::string readable_time = std::to_string(time(&tmstp));
            return build_credentials(_name, _surname) + "#" + readable_time;
        }


        /*
            Optional bool and _ID are needed to deal with Customer creation from file; in this case ID mustn't be created but passed.
        */
        Customer(std::string _name, std::string _surname, bool from_file=false, std::string _ID = ""){
            if (from_file == false) {
                ID = create_ID_customer(_name, _surname);
            }
            else {
                ID = _ID; // from file, you need to keep the same value, not create a new one.
            }
            name = _name;
            surname = _surname;
        }

        //std::string get_ID(){
        const std::string& get_ID() const {
            return ID;
        }

        //std::string get_name(){
        const std::string& get_name() const {
            return name;
        }
        void set_name(std::string _name){
            name = _name;
        }

        //std::string get_surname(){
        const std::string& get_surname() const {
            return surname;
        }
        void set_surname(std::string _surname){
            surname = _surname;
        }

        void print_customer() const {
            std::cout << "ID: " << ID << ", Name: " << name << ", Surname: " << surname << "\n" << std::endl;
        }
};
std::unordered_set<std::string> Customer::used_credentials;

/* - INTERACTION - */
class Interaction{
    protected:
        std::string customer_ID; // name+surname+timestamp
        std::string title; // info to recognise the interaction
        static std::unordered_set<std::string> used_titles;

    public:
        /*
            NOTE: method needed to re-build used_titles from file.
        */
        static void clear_used_titles() {
            used_titles.clear();
        }

        // static to be used in load_from_file() too
        static void check_title_uniqueness(std::string _title){
            if ( used_titles.find( _title ) != used_titles.end() ){
                throw std::runtime_error("Title already existing. Please try a new one.");
            }
        }

        void add_to_used_titles(std::string _title){
            used_titles.insert(_title);
        }
        void remove_from_used_titles(std::string _title){
            used_titles.erase(_title);
        }

        Interaction(std::string _customer_ID, std::string _title, bool from_file=false){
            // check title, not if from file
            if (!from_file) {
                check_title_uniqueness(_title);
            }
            // if ok proceed
            customer_ID = _customer_ID;
            title = _title;
            // add to set
            used_titles.insert(title);
        }
        Interaction(){
            customer_ID = "_customer_ID";
            title = "_title";
        }

        // get customer_ID method
        const std::string& get_customer_ID() const {
            return customer_ID;
        }
        // NO set customer_ID method to keep consistent the data

        // get/set title methods
        const std::string& get_title() const {
            return title;
        }
        /*
            set_title functions:
            - check title uniqueness
            - remove the old title from used_titles
            - update the title
            - add the new title to used_titles
        */
        void set_title(std::string _title){
            check_title_uniqueness(_title);
            remove_from_used_titles(title);
            title = _title;
            add_to_used_titles(title);
        }
};
std::unordered_set<std::string> Interaction::used_titles;

/* - APPOINTMENT - */
class Appointment : public Interaction{
    private:
        std::string date;

    public:
        Appointment(std::string _customer_ID, std::string _title, std::string _date, bool _from_file = false)
            : Interaction(_customer_ID, _title, _from_file), date(_date) {}

        // get/set date methods
        const std::string& get_date() const {
            return date;
        }
        void set_date(std::string _date){
            date = _date;
        }

        void print_appointment() const {
            std::cout << "Title: " << title << ", Date: " << date << "\n" << std::endl;
        }
};

/* - CONTRACT - */
class Contract : public Interaction{
    private:
        std::string contract_path;

    public:
        Contract(std::string _customer_ID, std::string _title, std::string _contract_path, bool _from_file = false)
            : Interaction(_customer_ID, _title, _from_file), contract_path(_contract_path) {}

        // get/set contract_path methods
        const std::string& get_contract_path() const {
            return contract_path;
        }
        void set_contract_path(std::string _contract_path){
            contract_path = _contract_path;
        }

        void print_contract() const {
            std::cout << "Title: " << title << ", Contract path: " << contract_path << "\n" << std::endl;
        }
};

/* - UTILITY acquire from user FUNCTIONS - */
struct Person{
    std::string customer_name;
    std::string customer_surname;
};

// cannot be empty message + minimum typed accepted (ex. '-' or '12/12/12')
void cannot_be_empty(const std::string& what, const std::string& minimum_typed) {
    std::cout << what << " cannot be empty. Minimum typed acceped is ' " << minimum_typed << " '" << std::endl;
}

Person acquire_name_surname(){
    Person p;

    while (true) {
        std::cout << "Enter customer name: " << std::endl;
        std::getline(std::cin, p.customer_name);

        if (!p.customer_name.empty())
            break;

        cannot_be_empty("Name","-");
    }

    while (true) {
        std::cout << "Enter customer surname: " << std::endl;
        std::getline(std::cin, p.customer_surname);

        if (!p.customer_surname.empty())
            break;

        cannot_be_empty("Surname","-");
    }

    return p;
}

std::string acquire_title(std:: string action_message="Enter interaction title: "){
    std::string t;

    while (true) {
        std::cout << action_message << std::endl;
        getline(std::cin, t);

        if (!t.empty())
            return t;

        cannot_be_empty("Title","-");
    }
}

/*
    Function to validate date. It checks for:
    - valid format
    - valid days, month, years (ex. you cannot type 37 as day-date)
    - leap year (28 february's days or more)
    It returns a string containing a valid date.
*/
std::string validate_date(const std::string& date) {
    /*
        Regex to check for:
        - format DD/MM/YY
        - valid input (if user types a something like "hello" it will not be accepted).
    */
    static const std::regex date_regex(
        R"(^(0[1-9]|[12][0-9]|3[01])/(0[1-9]|1[0-2])/([0-9]{2})$)"
    );

    if (!regex_match(date, date_regex)) {
        throw std::runtime_error("Invalid date format. Use DD/MM/YY.");
    }

    int day   = stoi(date.substr(0, 2));
    int month = stoi(date.substr(3, 2));
    int yy    = stoi(date.substr(6, 2));

    int days_in_month[] = {
        31, 28, 31, 30, 31, 30,
        31, 31, 30, 31, 30, 31
    };
 
   // standard disambiguation to check leap year
    int year = (yy <= 69) ? (2000 + yy) : (1900 + yy);
    bool is_leap =
        (year % 4 == 0 && year % 100 != 0) ||
        (year % 400 == 0);

    if (month == 2 && is_leap) {
        days_in_month[1] = 29;
    }

    // check real day
    if (day > days_in_month[month - 1]) {
        throw std::runtime_error("Invalid date: day exceeds days in month.");
    }

    return date;
}

std::string acquire_date(std::string action_message = "Enter interaction date (DD/MM/YY): ") {
    std::string d;

    while (true) {
        std::cout << action_message << std::endl;
        std::getline(std::cin, d);

        if (d.empty()) {
            cannot_be_empty("Date", "12/12/12");
            continue;
        }

        try {
            return validate_date(d);
        }
        catch (const std::runtime_error& e) {
            std::cout << "Invalid date: " << e.what() << std::endl;
        }
    }
}


std::string acquire_contract_path(std:: string action_message="Enter interaction contract path: "){
    std::string cp;

    while (true) {
        std::cout << action_message << std::endl;
        getline(std::cin, cp);

        if (!cp.empty())
            return cp;

        cannot_be_empty("Contract path","-");
    }
}

/*
    Function to set and check a limit of attempts to user input; it avoids infinite loop in extreme cases.
*/
bool attempt_counter(int& _counter) {
    ++_counter;
    return _counter <= 3;
}
/* - END - UTILITY acquire from user FUNCTIONS - */

/* - CustomerContainer - */
class CustomerContainer{
    public:
        /* - CUSTOMERS - */
        std::vector<Customer> customers_list;
        std::vector<Appointment> appointments_list;
        std::vector<Contract> contracts_list;

        // view all customers
        std::vector<Customer> get_customers_list(){
            return customers_list;
        }
        // print ID, name and surname of each customer.
        void print_all_customers(){
            const std::vector<Customer>& all_customers = get_customers_list();
            if (all_customers.empty()) {
                std::cout << "No customer exists yet.\n" << std::endl;
                return;
            }
            for (size_t i = 0; i < all_customers.size(); i++){
                all_customers[i].print_customer();
            }
        }

        // create a new customer - NOTE it does not just create but it also asks for name and surname.
        void create_customer(){
            int counter = 0;
            while(true){
                if (!attempt_counter(counter)) {
                    std::cout << "Too many attempts.\n";
                    break;
                }

                try{
                    Person p = acquire_name_surname();

                    Customer new_customer(p.customer_name, p.customer_surname);

                    customers_list.push_back(new_customer);
                    
                    std::cout << "New customer with name " << p.customer_name << " and surname " << p.customer_surname << " has been succesfully created.\n" << std::endl;
                    
                    break;                
                }
                catch (const std::runtime_error& e) {
                    std::cout << "Error: " << e.what() << std::endl;
                    // try again
                }
            }
        }

        // get a specific customer
        /* Asks name and surname through console and returns the related Customer */
        Customer* get_customer_by_name_surname(){
            Person p = acquire_name_surname();

            for (size_t i = 0; i < customers_list.size(); i++){
                if (customers_list[i].get_name() == p.customer_name && customers_list[i].get_surname() == p.customer_surname){
                    return &customers_list[i];
                }
            }
            // if no customer found
            std::cout << "No customer with name " << p.customer_name << " and surname " << p.customer_surname << " has been found.\n" << std::endl;
            return nullptr;
        }

        // edit a customer - NOTE it does not just edit but it also asks for name and surname.
        void edit_customer(){
            std::cout << "Enter the customer you want to edit details:" << std::endl;
            Customer* c = get_customer_by_name_surname();
            if (!c) {
                // addictional console message (a first "not found" message. is already in get_customer_by_name_surname()).
                std::cout << "Impossible to edit a not found customer.\n" << std::endl;
                return;
            }

            int counter = 0;
            while(true){
                if (!attempt_counter(counter)) {
                    std::cout << "Too many attempts.\n";
                    break;
                }

                try{
                    Person customer_new_details = acquire_name_surname();

                    // check uniqeness
                    // (NOTE: the customer ID does NOT update itself! this check only avoids to confirm new name-surname if already existing)
                    c->check_credentials_uniqueness( customer_new_details.customer_name, customer_new_details.customer_surname );

                    c->remove_from_used_credentials(c->get_name(), c->get_surname());

                    c->set_name(customer_new_details.customer_name);
                    c->set_surname(customer_new_details.customer_surname);

                    c->add_to_used_credentials(c->get_name(), c->get_surname());

                    std::cout << "New name is: " << c->get_name() << " and new surname is: " << c->get_surname() << "\n" << std::endl;

                    break;
                }
                catch (const std::runtime_error& e) {
                    std::cout << "Error: " << e.what() << std::endl;
                    // try again
                }
            }
        }

        /*
            Function to delete interactions related to a Customer once this customer is deleted.
        */
        void delete_cascade_interactions(std::string customer_ID){
            // appointments
            for (auto it = appointments_list.begin(); it != appointments_list.end(); ) {
                if (it->get_customer_ID() == customer_ID) {
                    // remove from used_titles
                    it->remove_from_used_titles(it->get_title());
                    // remove from appointments_list and delete object
                    it = appointments_list.erase(it);
                } else {
                    ++it;
                }
            }
            // contracts
            for (auto it = contracts_list.begin(); it != contracts_list.end(); ) {
                if (it->get_customer_ID() == customer_ID) {
                    // remove from used_titles
                    it->remove_from_used_titles(it->get_title());
                    // remove from appointments_list and delete object
                    it = contracts_list.erase(it);
                } else {
                    ++it;
                }
            }
        }

        // delete a customer - NOTE it does not just delete but it also asks for name and surname.
        void delete_customer(){
            std::cout << "Enter the customer you want to delete details:" << std::endl;
            Customer* c = get_customer_by_name_surname();
            if (!c) {
                // addictional console message (a first "not found" message. is already in get_customer_by_name_surname()).
                std::cout << "Impossible to delete a not found customer.\n" << std::endl;
                return;
            }

            std::string typed_confirmation;
            std::cout << "Are you sure you want to proceed to delete this customer ("<< c->get_name() << " " << c->get_surname() <<")? [Y/N]\n Type Y to proceed or N to stop it." << std::endl;
            getline(std::cin, typed_confirmation);
            if (typed_confirmation != "Y" && typed_confirmation != "y"){
                std::cout << "Delection stopped." << std::endl;
                return;
            }

            try {
                // save info before deleting object
                std::string name = c->get_name();
                std::string surname = c->get_surname();
                std::string customer_ID = c->get_ID();

                // delete interactions with that customer_id
                delete_cascade_interactions(customer_ID);

                // remove from used
                c->remove_from_used_credentials(name, surname);
                //remove element
                auto it = find_if(customers_list.begin(), customers_list.end(),
                    [c](const Customer& elem) {
                        return elem.get_ID() == c->get_ID();
                    });
                if (it != customers_list.end()) {
                    customers_list.erase(it);
                    std::cout << "Customer "<< name << " " << surname <<" succesfully deleted.\n" << std::endl;
                }
            }                
            catch (const std::runtime_error& e){
                std::cout << "Error: " << e.what() << std::endl;
                // try again
            }
        }


        /* - INTERACTIONS - */

        /* - Appointment - */
        void create_appointment(std::string _customer_ID){
            int counter = 0;
            while(true){
                if (!attempt_counter(counter)) {
                    std::cout << "Too many attempts.\n";
                    break;
                }

                try{
                    // acquire info
                    std::string title, date;

                    title = acquire_title("Enter a title for this Appointment: ");

                    date = acquire_date("Enter a date for this Appointment (standard format: DD/MM/YY) : ");

                    Appointment new_appointment(_customer_ID, title, date);

                    appointments_list.push_back(new_appointment);

                    std::cout << "New appointment with title " << title << " and date " << date << " has been succesfully created.\n" << std::endl;

                    break;
                }
                catch (const std::runtime_error& e){
                    std::cout << "Error: " << e.what() << std::endl;
                    // try again
                }
            }
        };

        /* Asks title through console and returns the related Appointment */
        Appointment* get_appointment_by_title(){
            std::string title = acquire_title();

            for (size_t i = 0; i < appointments_list.size(); i++){
                if (appointments_list[i].get_title() == title){
                    return &appointments_list[i];
                }
            }
            // if no customer found
            std::cout << "No appointment with title " << title << " has been found.\n" << std::endl;
            return nullptr;
        }

        // edit a appointment - NOTE it does not just edit but it also asks for title.
        void edit_appointment(Appointment* a){
            if (!a) {
                // addictional console message (a first "not found" message. is already in get_appointment_by_title()).
                std::cout << "Impossible to edit a not found appointment.\n" << std::endl;
                return;
            }

            int counter = 0;
            while(true){
                if (!attempt_counter(counter)) {
                    std::cout << "Too many attempts.\n";
                    break;
                }

                try{
                    std::string appointment_new_title = acquire_title();
                    std::string appointment_new_date = acquire_date();
                    a->set_title(appointment_new_title);
                    a->set_date(appointment_new_date);

                    std::cout << "New title is: " << a->get_title() << " and new date is: " << a->get_date() << "\n" << std::endl;

                    break;
                }
                catch (const std::runtime_error& e){
                    std::cout << "Error: " << e.what() << std::endl;
                    // try again
                }
            }
        }

        // delete a appointment - NOTE it does not just delete but it also asks for title.
        void delete_appointment(Appointment* a){
            if (!a) {
                // addictional console message (a first "not found" message. is already in get_appointment_by_title()).
                std::cout << "Impossible to delete a not found appointment.\n" << std::endl;
                return;
            }

            std::string typed_confirmation;
            std::cout << "Are you sure you want to proceed to delete this appointment ( "<< a->get_title() << " )? [Y/N]\n Type Y to proceed or N to stop it." << std::endl;
            getline(std::cin, typed_confirmation);
            if (typed_confirmation != "Y" && typed_confirmation != "y"){
                std::cout << "Delection stopped." << std::endl;
                return;
            }

            try{
                // save info before deleting object
                std::string title = a->get_title();

                // remove from used
                a->remove_from_used_titles(title);
                //remove element
                auto it = find_if(appointments_list.begin(), appointments_list.end(),
                    [a](const Appointment& elem) {
                        return elem.get_title() == a->get_title() && elem.get_customer_ID() == a->get_customer_ID();
                    });
                if (it != appointments_list.end()) {
                    appointments_list.erase(it);
                    std::cout << "Appointment " << title << " successfully deleted.\n" << std::endl;
                }
            }                
            catch (const std::runtime_error& e){
                std::cout << "Error: " << e.what() << std::endl;
                // try again
            }
        }

        /* - Contract - */
        void create_contract(std::string _customer_ID){
            int counter = 0;
            while(true){
                if (!attempt_counter(counter)) {
                    std::cout << "Too many attempts.\n";
                    break;
                }

                try{
                    // acquire info
                    std::string title, contract_path;

                    title = acquire_title("Enter a title for this Contract: ");
                    contract_path = acquire_contract_path("Enter a contract path for this Contract: ");

                    Contract new_contract(_customer_ID, title, contract_path);

                    contracts_list.push_back(new_contract);

                    std::cout << "New contract with title " << title << " and contract path " << contract_path << " has been succesfully created.\n" << std::endl;
                
                    break;
                }
                catch (const std::runtime_error& e){
                    std::cout << "Error: " << e.what() << std::endl;
                    // try again
                }
            }
        };

        /* Asks title through console and returns the related Contract */
        Contract* get_contract_by_title(){
            std::string title = acquire_title();

            for (size_t i = 0; i < contracts_list.size(); i++){
                if (contracts_list[i].get_title() == title){
                    return &contracts_list[i];
                }
            }
            // if no customer found
            std::cout << "No contract with title " << title << " has been found.\n" << std::endl;
            return nullptr;
        }

       // edit a contract - NOTE it does not just edit but it also asks for title.
        void edit_contract(Contract* c){
            if (!c) {
                // addictional console message (a first "not found" message. is already in get_contract_by_title()).
                std::cout << "Impossible to edit a not found contract.\n" << std::endl;
                return;
            }

            int counter = 0;
            while(true){
                if (!attempt_counter(counter)) {
                    std::cout << "Too many attempts.\n";
                    break;
                }

                try{
                    std::string contract_new_title = acquire_title();
                    std::string contract_new_contract_path = acquire_contract_path();

                    c->set_title(contract_new_title);
                    c->set_contract_path(contract_new_contract_path);

                    std::cout << "New title is: " << c->get_title() << " and new contract path is: " << c->get_contract_path() << "\n" << std::endl;

                    break;
                }
                catch (const std::runtime_error& e){
                    std::cout << "Error: " << e.what() << std::endl;
                    // try again
                }
            }
        }

        // delete a contract - NOTE it does not just delete but it also asks for title.
        void delete_contract(Contract* c){
            if (!c) {
                // addictional console message (a first "not found" message. is already in get_contract_by_title()).
                std::cout << "Impossible to delete a not found contract.\n" << std::endl;
                return;
            }

            std::string typed_confirmation;
            std::cout << "Are you sure you want to proceed to delete this contract ( "<< c->get_title() << " )? [Y/N]\n Type Y to proceed or N to stop it." << std::endl;
            getline(std::cin, typed_confirmation);
            if (typed_confirmation != "Y" && typed_confirmation != "y"){
                std::cout << "Delection stopped." << std::endl;
                return;
            }

            try{
                // save info before deleting object
                std::string title = c->get_title();

                // remove from used
                c->remove_from_used_titles(title);
                //remove element
                auto it = find_if(contracts_list.begin(), contracts_list.end(),
                    [c](const Contract& elem) {
                        return elem.get_title() == c->get_title() && elem.get_customer_ID() == c->get_customer_ID();
                    });
                if (it != contracts_list.end()) {
                    contracts_list.erase(it);
                    std::cout << "Contract " << title << " successfully deleted.\n" << std::endl;
                }
            }
            catch (const std::runtime_error& e){
                std::cout << "Error: " << e.what() << std::endl;
                // try again
            }
        }
};


/* - FILE - */
std::string const file_name = "file.csv";

std::string const file_customers_header = "---- CUSTOMERS ---- : customer_id,name,surname";

std::string const file_appointments_header = "---- APPOINTMENTS ---- : customer_id,title,date";

std::string const file_contracts_header = "---- CONTRACTS ---- : customer_id,title,contract_path";

// - UTILITY FILE
/*
    Function to avoid mishandling between csv comma and value comma.
    If std::string contains comma this functions it will double it otherwise nothing happens.
    Ex. "hello,world" >became> "hello,,world" while "no comma here" >became> "no comma here".
*/
std::string manage_escape_comma(const std::string& input){
    /*
        Quick trick of double comma, it should avoid any realistic typing.
        If comma in std::string it will be doubled otherwise nothing happens.
        This allows to check when rebuilding Objects to not have mistaken csv comma with value comma or other way.
    */
    std::string result;
    for (char c : input) {
        if (c == ',')
            result += ",,";
        else
            result += c;
    }
    return result;
}

/*
    Reverse for std::string manage_escape_comma(const std::string& input) function BUT:
    - splits ONLY if there's a single comma,
    - if double comma it reduces it to a single one.
    Ex. "a,b,c" >became> ["a","b","c"] while "a,,b,c,d" >became> ["a,b","c","d"]
*/
std::vector<std::string> manage_unescape_single_comma(const std::string& line) {
    std::vector<std::string> fields;
    std::string current;

    for (size_t i = 0; i < line.size(); i++) {
        if (line[i] == ',') {
            if (i + 1 < line.size() && line[i + 1] == ',') {
                // escaped comma
                current += ',';
                i++; // skip second comma
            } else {
                // real separator
                fields.push_back(current);
                current.clear();
            }
        } else {
            current += line[i];
        }
    }

    fields.push_back(current); // last field
    return fields;
}
// - end - UTILITY FILE

/*
    Function to save on a csv file all customers, appointments and contracts.
    - it opens a file (or creates it if not existing) and manage to close it ones the job is finished
    - then it writes all the customers, appointments and contracts.
*/
void save_to_file(CustomerContainer& _main_CustomerContainer){
    std::ofstream file( file_name, std::ios::out );

    if (!file) {
        std::cerr << "Error opening the file.";
        return;
    }

    if (_main_CustomerContainer.customers_list.size() > 0) {
        file << file_customers_header << "\n";
        for (const Customer& c : _main_CustomerContainer.customers_list) {
            file << manage_escape_comma( c.get_ID() ) << "," << manage_escape_comma( c.get_name() ) << "," << manage_escape_comma( c.get_surname() ) << '\n';
        }
        file << "\n"; // readability
    }

    if (_main_CustomerContainer.appointments_list.size() > 0) {
        file << file_appointments_header << "\n";
        for (const Appointment& a : _main_CustomerContainer.appointments_list) {
            file << manage_escape_comma( a.get_customer_ID() ) << "," << manage_escape_comma( a.get_title() ) << "," << manage_escape_comma( a.get_date() ) << '\n';
        }
        file << "\n"; // readability
    }

    if (_main_CustomerContainer.contracts_list.size() > 0) {
        file << file_contracts_header << "\n";
        for (const Contract& c : _main_CustomerContainer.contracts_list) {
            file << manage_escape_comma( c.get_customer_ID() ) << "," << manage_escape_comma( c.get_title() ) << "," << manage_escape_comma( c.get_contract_path() ) << '\n';
        }
    }

    std::cout << "File saved.\n" << std::endl;
}

/*
    Function to load data from file:
    - clears used_credentials and used_titles
    - clears lists (customers, appointments, contracts)
    - open file (and manage to close it)
    - (line by line) re-writes each customer, appointment and contract
    - (line by line) fills used_credentials and used_titles
    - (line by line) fills lists (customers, appointments, contracts).
*/
void load_from_file(CustomerContainer& _main_CustomerContainer){
    // clear used_credentials and titles
    Customer::clear_used_credentials();
    Interaction::clear_used_titles();

    // clear lists (customers, appointments, contracts)
    _main_CustomerContainer.customers_list.clear();
    _main_CustomerContainer.appointments_list.clear();
    _main_CustomerContainer.contracts_list.clear();

    enum class Section {default_section, customers_section, appointments_section, contracts_section};

    std::ifstream file( file_name );
    if (!file.is_open()) {
        std::cerr << "File not found.\n";
        return;
    }

    Section current_section = Section::default_section;
    std::string line;

    while (getline(file, line)) {
        if (line.empty()) continue;

        if (line == file_customers_header) {
            current_section = Section::customers_section;
            continue;
        }
        if (line == file_appointments_header) {
            current_section = Section::appointments_section;
            continue;
        }
        if (line == file_contracts_header) {
            current_section = Section::contracts_section;
            continue;
        }

        if (current_section == Section::customers_section) {
            std::vector<std::string> fields_from_line = manage_unescape_single_comma(line);
            // check to have a correct amount of fields
            if (fields_from_line.size() != 3) {
                std::cout << "\nCorrupted data for line: " << line << "\n" << std::endl;
                continue;
            }

            try {
                // check for duplicates
                Customer::check_credentials_uniqueness(fields_from_line[1],fields_from_line[2]);

                // build customer
                Customer c(fields_from_line[1], fields_from_line[2], true, fields_from_line[0]);
                // push into used_credentials
                c.add_to_used_credentials(fields_from_line[1], fields_from_line[2]);
                // push to customers_list
                _main_CustomerContainer.customers_list.push_back(c);
            }
            catch (const std::runtime_error& e) {
                std::cout << ". Error: " << e.what() << "\nSkipping line: " << line << std::endl;
                continue;
            }

            continue;
        }
        if (current_section == Section::appointments_section) {
            std::vector<std::string> fields_from_line = manage_unescape_single_comma(line);
            // check to have a correct amount of fields
            if (fields_from_line.size() != 3) {
                std::cout << "\nCorrupted data for line: " << line << "\n" << std::endl;
                continue;
            }

            try {
                // check for duplicates
                Appointment::check_title_uniqueness(fields_from_line[1]);

                // check for valid date
                validate_date(fields_from_line[2]);

                // build appointment
                Appointment a(fields_from_line[0], fields_from_line[1], fields_from_line[2], true);
                // push to appointments_list
                _main_CustomerContainer.appointments_list.push_back(a);
            }
            catch (const std::runtime_error& e) {
                std::cout << ". Error: " << e.what() << "\nSkipping line: " << line << std::endl;
                continue;
            }

            continue;
        }
        if (current_section == Section::contracts_section) {
            std::vector<std::string> fields_from_line = manage_unescape_single_comma(line);
            // check to have a correct amount of fields
            if (fields_from_line.size() != 3) {
                std::cout << "\nCorrupted data for line: " << line << "\n" << std::endl;
                continue;
            }

            try {
                // check for duplicates
                Contract::check_title_uniqueness(fields_from_line[1]);

                // build contract
                Contract c(fields_from_line[0], fields_from_line[1], fields_from_line[2], true);
                // push to contracts_list
                _main_CustomerContainer.contracts_list.push_back(c);
            }
            catch (const std::runtime_error& e) {
                std::cout << ". Error: " << e.what() << "\nSkipping line: " << line << std::endl;
                continue;
            }

            continue;
        }
    }
}
/* - end - FILE - */


/* - UTILITY FLOW - */
// message if std::string typed does not match an existing one.
void typed_not_existing_match_messagge(){
    std::cout << "What you typed does not match any of the options, please try again.\n" << std::endl;
}

/*
    Helper function to convert a string from lowercase to uppercase.
    Used to get each input from user in selection flow (both base_UI_flow() and interactions_flow()).
    (ex. user typing 'nc' instead of 'NC' it will be allowed thanks to this function).
*/
std::string to_uppercase_if_lower(const std::string& input_to_check) {
    std::string to_upper_input = input_to_check;
    for (size_t i = 0; i < to_upper_input.size(); ++i) {
        if (std::islower(to_upper_input[i])) {
            to_upper_input[i] = std::toupper(to_upper_input[i]);
        }
    }
    return to_upper_input;
}

/* - end - UTILITY FLOW - */

void interactions_flow(CustomerContainer& _main_CustomerContainer, Customer& c);
/*
    Function to manage the main console-input-user flow
*/
void base_UI_flow(CustomerContainer& _main_CustomerContainer){
    while(true){
        std::string typed_selection;
        std::cout << "Select your action:\n"
                "1) See all customers - type S\n"
                "2) Create a new customer - type NC\n"
                "3) Edit an existing customer - type E\n"
                "4) Delete an existing customer - type D\n"
                "5) Find a customer (by name and surname) and manage its interactions - type F\n"
                "6) Save all the existing customers into a file - type SF\n"
                "7) Exit program - type Q\n";
        // get input
        getline(std::cin, typed_selection);

        typed_selection = to_uppercase_if_lower(typed_selection);

        if (typed_selection == "S") _main_CustomerContainer.print_all_customers();
        else if(typed_selection == "NC") _main_CustomerContainer.create_customer();
        else if(typed_selection == "E") _main_CustomerContainer.edit_customer();
        else if(typed_selection == "D") _main_CustomerContainer.delete_customer();
        else if(typed_selection == "F"){
            // find = (method CRM get customer by name and surname)
            Customer* c = _main_CustomerContainer.get_customer_by_name_surname();
            if (!c) {
                std::cout << "Customer not found.\n" << std::endl;
                continue;
            }
            std::cout << "The Customer you selected is:" << std::endl;
            c->print_customer();

            // customer's interactions flow
            interactions_flow(_main_CustomerContainer, *c);
        }
        else if(typed_selection == "SF"){
            std::string confirm_exit;
            std::cout << "Are you sure you want to update the file? [Y/N]: ";
            getline(std::cin, confirm_exit);
            if (confirm_exit == "Y" || confirm_exit == "y") {
                std::cout << "Saving file...\n" << std::endl;
                save_to_file(_main_CustomerContainer);
            }
            else {
                std::cout << "Save file cancelled. Returning to menu.\n" << std::endl;
            }
        }
        else if(typed_selection == "Q"){
            std::string confirm_exit;
            std::cout << "Are you sure you want to exit the program? [Y/N]: ";
            getline(std::cin, confirm_exit);
            if (confirm_exit == "Y" || confirm_exit == "y") {
                std::cout << "Exiting program.\n" << std::endl;
                break;
            }
            else {
                std::cout << "Exit cancelled. Returning to menu.\n" << std::endl;
            }
        }
        else{
            typed_not_existing_match_messagge();
        }
    }
}

/*
    Function to manage the entire console-input-user flow related to customer's interactions
*/
void interactions_flow(CustomerContainer& _main_CustomerContainer, Customer& c){
    while(true){
        std::string typed_selection;
        // offer new options to interactions -> create, get - view, edit interactions
        std::cout << "Select your action:\n"
            "1) See all the interactions for this customer - type S\n"
            "2) Create a new interaction - type NI\n"
            "3) Find, Edit or Delete an existing interaction - type F\n" // find, edit, delete
            "4) Exit (go back to starting selection) - type Q\n";
        getline(std::cin, typed_selection);

        typed_selection = to_uppercase_if_lower(typed_selection);

        std::string customer_ID = c.get_ID();

        if(typed_selection == "S"){
            // view all interactions
            std::vector<Appointment> all_appointments = _main_CustomerContainer.appointments_list;
            std::vector<Contract> all_contracts = _main_CustomerContainer.contracts_list;

            std::cout << "\n---- Customer " << c.get_name() << " " << c.get_surname() << " Interactions: ----" << std::endl;
            if ( all_appointments.size() == 0 && all_contracts.size() == 0 ){
                std::cout << "There's no existing interactions for this customer.\n" << std::endl;
                continue;
            }

            // Appointments
            if (all_appointments.size() > 0){
                std::cout << "List of all the Appointments:\n" << std::endl;
                for (size_t i = 0; i < all_appointments.size(); i++){
                    if (all_appointments[i].get_customer_ID() == customer_ID){
                        all_appointments[i].print_appointment();
                    }
                }
            }
            // Contracts
            if (all_contracts.size() > 0){
                std::cout << "List of all the Contracts:\n" << std::endl;
                for (size_t i = 0; i < all_contracts.size(); i++){
                    if (all_contracts[i].get_customer_ID() == customer_ID){
                        all_contracts[i].print_contract();
                    }
                }
            }

            std::cout << "\n---- END - Customer " << c.get_name() << " " << c.get_surname() << " Interactions. ----" << std::endl;

        }
        else if (typed_selection == "NI"){
            std::cout << "Select your action:\n"
                "1) Create a new Appointment - type A\n"
                "2) Create a new Contract - type C\n";
            getline(std::cin, typed_selection);
            typed_selection = to_uppercase_if_lower(typed_selection);

            if (typed_selection == "A") _main_CustomerContainer.create_appointment(customer_ID);
            else if (typed_selection == "C") _main_CustomerContainer.create_contract(customer_ID);
            else typed_not_existing_match_messagge();
        }
        else if (typed_selection == "F"){
            // get_appointment/contract by title - ask if edit - edit
            std::cout << "Select your action:\n"
                "1) Find (see/edit/delete) an Appointment - type A\n"
                "2) Find (see/edit/delete) a Contract - type C\n";
            getline(std::cin, typed_selection);
            typed_selection = to_uppercase_if_lower(typed_selection);

            if (typed_selection == "A"){
                // print
                Appointment* a = _main_CustomerContainer.get_appointment_by_title();
                if (!a) return;
                std::cout << "The Appointment you selected is:" << std::endl;
                a->print_appointment();
                // next selection : edit or delete
                std::cout << "Select your action:\n"
                    "1) Edit appointment - type E\n"
                    "2) Delete appointment - type D\n";

                getline(std::cin, typed_selection);
                typed_selection = to_uppercase_if_lower(typed_selection);

                if (typed_selection == "E") _main_CustomerContainer.edit_appointment(a);
                else if (typed_selection == "D") _main_CustomerContainer.delete_appointment(a);
                else typed_not_existing_match_messagge();
            }
            else if (typed_selection == "C"){
                // print
                Contract* c = _main_CustomerContainer.get_contract_by_title();
                if (!c) return;
                std::cout << "The Contract you selected is:" << std::endl;
                c->print_contract();
                // next selection : edit or delete
                std::cout << "Select your action:\n"
                    "1) Edit contract - type E\n"
                    "2) Delete contract - type D\n";

                getline(std::cin, typed_selection);
                typed_selection = to_uppercase_if_lower(typed_selection);

                if (typed_selection == "E") _main_CustomerContainer.edit_contract(c);
                else if (typed_selection == "D") _main_CustomerContainer.delete_contract(c);
                else typed_not_existing_match_messagge();
            }
            else typed_not_existing_match_messagge();
        }
        else if (typed_selection == "Q"){
            std::cout << "Exit selection flow complete.\n" << std::endl;
            // restart base_UI_flow
            break;
        }
        else typed_not_existing_match_messagge();
    }
}


int main(){
    try{
        CustomerContainer main_CustomerContainer;

        load_from_file(main_CustomerContainer);

        base_UI_flow(main_CustomerContainer);

        return 0;
    }
    catch (const std::exception& e) {
        std::cerr << "Fatal error: " << e.what() << '\n';
        return 1;
    }
}