dsproject.cpp

#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#include <conio.h> 
#include <climits>
using namespace std;

void restaurantsLocation() {
    cout << "\nLOCATIONS: \n";
    cout << "0 F-5  |  8 G-5  | 18 H-8  | 22 I-8" << endl;
    cout << "1 F-6  |  9 G-6  | 19 H-9  | 23 I-9" << endl;
    cout << "2 F-7  | 10 G-7  | 20 H-10 | 24 I-10" << endl;
    cout << "3 F-8  | 11 G-8  | 21 H-11 | 25 I-11" << endl;
    cout << "4 F-9  | 12 G-9  |         | 26 I-12" << endl;
    cout << "5 F-10 | 13 G-10 |         | 27 I-14" << endl;
    cout << "6 F-11 | 14 G-11 |         | 28 I-15" << endl;
    cout << "       | 15 G-12 |         | 29 I-16" << endl;
    cout << "       | 16 G-13 |         |" << endl;
    cout << "       | 17 G-14 |         |" << endl;
}
void convertToLoc(int index) {
    if (index >= 0 && index <= 7) {
        cout << "F-" << (5 + index) << endl; // Start at F-5 and add the index to get the right value
    }
    else if (index >= 8 && index <= 17) {
        cout << "G-" << (index - 3) << endl;
    }
    else if (index >= 18 && index <= 21) {
        cout << "H-" << (index - 10) << endl;
    }
    else if (index >= 22 && index <= 29) {
        cout << "I-";
        index -= 14;
        if (index >= 13) cout << (index + 1) << endl;
        else cout << (index) << endl;
    }
    else {
        cout << "Invalid ";
    }
}
class Graph {
    int V;
    int** adj;

public:
    Graph(int vertices) {
        V = vertices;
        adj = new int* [V];
        for (int i = 0; i < V; i++) {
            adj[i] = new int[V];
            for (int j = 0; j < V; j++) {
                adj[i][j] = (i == j) ? 0 : INT_MAX;
            }
        }
    }

    void addEdge(int u, int v, int weight) {
        if (u < 0 || u >= V || v < 0 || v >= V || weight < 0) {
            cout << "Invalid edge or weight!" << endl;
            return;
        }
        adj[u][v] = weight;
        adj[v][u] = weight;
    }

    void printPath(int predecessors[], int current) {
        if (current == -1) return; // Base case: no predecessor
        //predecessor akaparent node storing array
        printPath(predecessors, predecessors[current]);
        convertToLoc(current);
    }
    void shortestPath(int src, int dests[], int destCount) {
        int* dist = new int[V];  // Distance array
        bool* visited = new bool[V];  // Visited array
        int* predecessors = new int[V]; // To store the path


        for (int i = 0; i < V; i++) {
            dist[i] = INT_MAX;
            visited[i] = false;
            predecessors[i] = -1; // -1 indicates no predecessor
        }

        dist[src] = 0;

        for (int count = 0; count < V - 1; count++) {
            int u = -1;

            // Find the minimum distance vertex not yet visited
            for (int i = 0; i < V; i++) {
                if (!visited[i] && (u == -1 || dist[i] < dist[u])) {
                    u = i;
                }
            }

            // If no vertex was found, break 
            if (u == -1) break;

            // Mark the chosen vertex as visited
            visited[u] = true;

            // Update distances of adjacent vertices
            for (int v = 0; v < V; v++) {
                // Check if v is reachable from u
                if (!visited[v] && adj[u][v] != INT_MAX && dist[u] != INT_MAX &&
                    dist[u] + adj[u][v] < dist[v]) {
                    dist[v] = dist[u] + adj[u][v];
                    predecessors[v] = u; // Set predecessor of v to u
                }
            }
        }

        // Sorting the destinations based on their distance from src (bubble sort)
        for (int i = 0; i < destCount - 1; i++) {
            for (int j = i + 1; j < destCount; j++) {
                if (dist[dests[i]] > dist[dests[j]]) {
                    int temp = dests[i];
                    dests[i] = dests[j];
                    dests[j] = temp;
                }
            }
        }

        for (int i = 0; i < destCount; i++) {
            int dest = dests[i];
            if (dist[dest] == INT_MAX) {
                cout << "No path to node " << dest << "\n";
            }
            else {
                cout << "Shortest path to node " << dest << ": ";
                printPath(predecessors, dest);
                cout << "\nTotal weight: " << dist[dest] << "\n\n";
            }
        }

        delete[] dist;
        delete[] visited;
        delete[] predecessors;
    }

    ~Graph() {
        for (int i = 0; i < V; i++) {
            delete[] adj[i];
        }
        delete[] adj;
    }
};



void initializeGraph(Graph& g) {
    g.addEdge(0, 3, 15); //f-5 to f-8
    g.addEdge(0, 5, 2);  //f-5 to f-10
    g.addEdge(0, 29, 7); //f-5 to i-16
    g.addEdge(0, 7, 2);  //f-5 to f-12
    g.addEdge(0, 24, 15);//f-5 to i-10

    g.addEdge(1, 7, 13);//f-6 to f-12
    g.addEdge(1, 28, 8);//f-6 to i-15
    g.addEdge(1, 23, 3);//f-6 to i-9
    g.addEdge(1, 26, 9);//f-6 to i-12
    g.addEdge(1, 5, 3);//f-6 to f-10 
    g.addEdge(1, 3, 7);//f-6 to f-8
    g.addEdge(1, 19, 12);//f-6 to h-9

    g.addEdge(2, 12, 15);//f-7 tp g-9
    g.addEdge(2, 29, 5);//f-7 tp i-16
    g.addEdge(2, 5, 6);//f-7 tp f-10

    g.addEdge(3, 15, 4);//f-8 to g-12
    g.addEdge(3, 25, 4);//f-8 to i-11
    g.addEdge(3, 7, 6);//f-8 to f-12
    g.addEdge(3, 12, 4);//f-8 to g-9

    g.addEdge(4, 7, 9);//f-9 to f-12
    g.addEdge(4, 21, 10);//f-9 to h-11
    g.addEdge(4, 13, 3);//f-9 to g-10
    g.addEdge(4, 25, 8);//f-9 to i-11
    g.addEdge(4, 19, 11);//f-9 to h-9
    g.addEdge(4, 9, 15);//f-9 to g-6
    g.addEdge(4, 28, 7);//f-9 to i-15
    g.addEdge(4, 29, 9);//f-9 to i-16

    g.addEdge(5, 6, 6);//f-10 to f-11
    g.addEdge(5, 13, 13);//f-10 to g-10
    g.addEdge(5, 14, 5);//f-10 to g-11

    g.addEdge(6, 23, 14);//f-11 to i-9
    g.addEdge(6, 8, 1);//f-11 to g-5
    g.addEdge(6, 13, 1);//f-11 to g-10
    g.addEdge(6, 12, 11);//f-11 to g-9
    g.addEdge(6, 19, 5);//f-11 to h-9

    g.addEdge(7, 9, 12); //f-12 to g-6
    g.addEdge(7, 11, 7); //f-12 to g-8
    g.addEdge(7, 29, 1); //f-12 to i-16
    g.addEdge(7, 27, 13); //f-12 to i-14
    g.addEdge(7, 13, 5); //f-12 to g-10
    g.addEdge(7, 28, 14); //f-12 to i-15
    g.addEdge(7, 21, 3); //f-12 to h-11


    g.addEdge(8, 18, 11);//g-5 to h-8
    g.addEdge(8, 27, 12);//g-5 to i-14

    g.addEdge(9, 27, 2);//g-6 to i-14

    g.addEdge(10, 21, 1);//g-7 to h-11
    g.addEdge(10, 19, 2);//g-7 to h-9
    g.addEdge(10, 11, 2);//g-7 to g-8

    g.addEdge(11, 19, 6);//g-8 to h-9
    g.addEdge(11, 23, 5);//g-8 to i-9
    g.addEdge(11, 22, 10);//g-8 to i-8

    g.addEdge(12, 17, 12);//g-9 to g-14
    g.addEdge(12, 21, 7);//g-9 to h-11

    // g-10 == 13

    g.addEdge(14, 27, 1);//g-11 to i-14
    g.addEdge(14, 22, 10);//g-11 to i-8
    g.addEdge(14, 18, 6);//g-11 to h-8
    g.addEdge(14, 23, 9);//g-11 to i-9

    g.addEdge(15, 19, 8);//g-12 to h-9
    g.addEdge(15, 28, 3);//g-12 to i-15
    g.addEdge(15, 17, 14);//g-12 to g-14
    g.addEdge(15, 26, 15);//g-12 to i-12
    g.addEdge(15, 21, 4);//g-12 to h-11
    g.addEdge(15, 23, 7);//g-12 to i-9
    g.addEdge(15, 25, 12);//g-12 to i-11

    g.addEdge(16, 21, 1);//g-13 to h-11

    g.addEdge(17, 29, 2);//g-14 to i-16
    g.addEdge(17, 26, 8);//g-14 to i-12

    g.addEdge(18, 24, 2);//h-8 to i-10
    g.addEdge(18, 26, 9);//h-8  to i-12
    g.addEdge(18, 29, 13);//h-8 to i-16

    g.addEdge(19, 22, 3);//h-9 to i-8
    g.addEdge(19, 24, 3);//h-9 to i-10

    g.addEdge(20, 23, 4);//h-10 to i-9
    g.addEdge(20, 24, 5);//h-10 to i-10
    g.addEdge(20, 22, 5);//h-10 to i-8

    g.addEdge(21, 27, 2);//h-11 to i-14
    g.addEdge(21, 28, 5);//h-11 to i-15
    g.addEdge(21, 26, 9);//h-11 to i-12

    g.addEdge(22, 28, 2);//i-8 to i-15

    g.addEdge(23, 25, 7);//i-9 to i-11
    g.addEdge(23, 26, 8);//i-9 to i-12

    g.addEdge(24, 29, 14);//i-10 to i-16

    //i-11 == 25

    g.addEdge(26, 28, 6);//i-12 to i-15
    g.addEdge(26, 27, 8);//i-12 to i-14

    //i-14 == 27

    //i-15 == 28

    //i-16 == 29
}
struct Promotion;
class PromotionStack;
class Employee;
class Restaurant;
class EmployeeHashTable;
class Customer;
class CustomerHashTable;
class Order;
void applyPromotion(PromotionStack* promo, Order* newOrder);
struct Dish {
    string ID;
    string name;
    string type;
    int cost;
    Dish* left;
    Dish* right;

    Dish(int ID, string name, string type, int cost)
        : name(name), type(type), cost(cost), left(nullptr), right(nullptr) {
        this->ID = to_string(ID);
        while (this->ID.length() < 5) {
            this->ID = "0" + this->ID;
        }
    }
};
class Menu {
    string resName;
    Dish* root;

public:
    Menu() : root(nullptr) {}

    Menu(string restaurantName) : resName(restaurantName), root(nullptr) {}

    // Add a dish to the tree
    void addDish() {
        string dishName, type;
        int cost;

        cout << "Enter Dish Name: ";
        cin.ignore();
        getline(cin, dishName);

        // Check if dish with this name already exists.
        if (isNameDuplicate(root, dishName)) {
            cout << "Dish with the name \"" << dishName << "\" already exists.\n";
            return;
        }

        cout << "Enter Dish Type: ";
        getline(cin, type);

        cout << "Enter Dish Cost: ";
        cin >> cost;

        int newID = getNextID();
        Dish* newDish = new Dish(newID, dishName, type, cost);

        if (!root) {
            root = newDish;
        }
        else {
            addDishToTree(root, newDish);
        }

        cout << "Dish added successfully with ID: " << newDish->ID << endl;
    }

    // Edit a dish in the tree
    void editDish() {
        string ID;
        cout << "Enter Dish ID to edit: ";
        cin >> ID;

        Dish* dish = findDish(root, ID);
        if (dish) {
            cout << "Editing Dish - ID: " << dish->ID << ", Name: " << dish->name
                << ", Type: " << dish->type << ", Cost: " << dish->cost << endl;

            string newName, newType;
            int newCost;

            cout << "Enter new Dish Name: ";
            cin.ignore();
            getline(cin, newName);

            // Check for duplicate name if changed
            if (newName != dish->name && isNameDuplicate(root, newName)) {
                cout << "Dish with the name \"" << newName << "\" already exists.\n";
                return;
            }

            cout << "Enter new Dish Type: ";
            getline(cin, newType);
            cout << "Enter new Dish Cost: ";
            cin >> newCost;

            dish->name = newName;
            dish->type = newType;
            dish->cost = newCost;

            cout << "Dish updated successfully.\n";
        }
        else {
            cout << "Dish with ID " << ID << " not found.\n";
        }
    }

    // Delete a dish from the tree
    void deleteDish() {
        string ID;
        cout << "Enter Dish ID to delete: ";
        cin >> ID;
        root = deleteDishFromTree(root, ID);
    }

    // Display dishes (In-Order Traversal)
    void displayDishes() const {

        if (!root) {
            cout << "No dishes to display.\n";
            return;
        }

        cout << "Restaurant: " << resName << "\nDish Menu:\n";
        displayTreeInOrder(root);
    }

    Dish* searchDish(const string& dishID) const {
        return findDish(root, dishID);
    }

    // Helper to get the next unique ID
    int getNextID() {
        static int currentID = 1;
        return currentID++;
    }

    // Check for duplicate dish names
    bool isNameDuplicate(Dish* node, const string& name) const {
        if (!node) return false;
        if (node->name == name) return true;
        return isNameDuplicate(node->left, name) || isNameDuplicate(node->right, name);
    }

    // Recursive helper to add a dish to the tree
    void addDishToTree(Dish* node, Dish* newDish) {
        if (newDish->ID < node->ID) {
            if (node->left) {
                addDishToTree(node->left, newDish);
            }
            else {
                node->left = newDish;
            }
        }
        else {
            if (node->right) {
                addDishToTree(node->right, newDish);
            }
            else {
                node->right = newDish;
            }
        }
    }
    // Recursive helper to find a dish by ID
    Dish* findDish(Dish* node, const string& ID) const {
        if (!node) return nullptr;
        if (node->ID == ID) return node;
        if (ID < node->ID) return findDish(node->left, ID);
        return findDish(node->right, ID);
    }

    // Recursive helper to delete a dish from the tree
    Dish* deleteDishFromTree(Dish* node, const string& ID) {
        if (!node) return nullptr;

        if (ID < node->ID) {
            node->left = deleteDishFromTree(node->left, ID);
        }
        else if (ID > node->ID) {
            node->right = deleteDishFromTree(node->right, ID);
        }
        else {
            // Node to be deleted found
            if (!node->left) {
                Dish* rightChild = node->right;
                delete node;
                return rightChild;
            }

            else if (!node->right) {
                Dish* leftChild = node->left;
                delete node;
                return leftChild;
            }

            else {
                // Find the smallest node in the right subtree
                Dish* successor = node->right;
                while (successor && successor->left) {
                    successor = successor->left;
                }
                // Copy successor data
                node->ID = successor->ID;
                node->name = successor->name;
                node->type = successor->type;
                node->cost = successor->cost;

                // Delete successor
                node->right = deleteDishFromTree(node->right, successor->ID);
            }
        }
        return node;
    }

    // Recursive In-Order Traversal
    void displayTreeInOrder(Dish* node) const {
        if (!node) return;
        displayTreeInOrder(node->left);
        cout << "ID: " << node->ID << ", Dish: " << node->name
            << ", Type: " << node->type << ", Cost: " << node->cost << endl;
        displayTreeInOrder(node->right);
    }
};
class Employee {
public:
    int nextID = 0;
    string ID;
    string name;
    string role;
    string password;

    Employee* next;
    Employee(int ID = 0, string name = "", string role = "", string password = "") : name(name), password(password), role(role), next(nullptr) {
        this->ID = to_string(ID);
        while (this->ID.length() < 5) {
            this->ID = "0" + this->ID;
        }
    }

    Employee(string id = "", const string& name = "", const string& role = "", const string& password = "")
        : ID(id), name(name), role(role), password(password), next(nullptr) {}


    void display() {
        cout << "ID: " << ID << ", Name: " << name << ", Role: " << role << endl;
    }
};
class EmployeeHashTable {
public:
    static const int table_size = 100;
    Employee* hashTable[table_size];
    int nextID;

    // Constructor
    EmployeeHashTable() : nextID(1) {
        for (int i = 0; i < table_size; i++) {
            hashTable[i] = nullptr;
        }
    }

    // Generate a new unique employee ID
    string generateID() {
        string id = to_string(nextID++);
        while (id.length() < 5) {
            id = "0" + id;
        }
        return id;
    }

    // Hash function to map ID to table index
    int hashFunction(string id) {
        int num = stoi(id);
        return (num % table_size);
    }

    // Add an employee to the hash table
    void addEmployee(string id, const string& name, const string& role, const string& password) {
        cout << "Adding Employee with ID: " << id << endl;
        int index = hashFunction(id);
        Employee* newEmployee = new Employee(id, name, role, password);

        if (hashTable[index] == nullptr) {
            hashTable[index] = newEmployee;
        }
        else {
            Employee* current = hashTable[index];
            while (current->next != nullptr) {
                current = current->next;
            }
            current->next = newEmployee;
        }

    }


    // Search for an employee by ID
    Employee* searchEmployee(string id) {
        int index = hashFunction(id);
        Employee* current = hashTable[index];

        while (current != nullptr) {
            if (current->ID == id) {
                return current;  // Employee found
            }
            current = current->next;
        }

        return nullptr;  // Employee not found
    }

    // Delete an employee by ID
    void deleteEmployee(string id) {
        int index = hashFunction(id);
        Employee* current = hashTable[index];
        Employee* prev = nullptr;

        // Search for the employee to delete
        while (current != nullptr) {
            if (current->ID == id) {
                if (prev == nullptr) {  // Employee is the first in the chain
                    hashTable[index] = current->next;
                }
                else {
                    prev->next = current->next;
                }

                delete current;
                cout << "Employee with ID " << id << " deleted." << endl;
                return;
            }
            prev = current;
            current = current->next;
        }

        cout << "Employee with ID " << id << " not found." << endl;
    }


};
class Customer {
public:
    string ID;
    string name;
    string email;
    string password;
    Customer* next;

    Customer(string n, string e, string p) : name(n), email(e), password(p), next(nullptr) {
        static int idCounter = 00000;
        ID = to_string(idCounter++);
    }

    Customer(string id = "", const string& name = "", const string& email = "", const string& password = "")
        : ID(id), name(name), email(email), password(password), next(nullptr) {}

    void editName(string newName) {
        this->name = newName;
    }

    bool isValidPassword(string password) {
        if (password.length() < 8 || password.length() > 12) { return false; }
        //make bools to check all chars
        bool hasUpper = false, hasLower = false, hasDigit = false, hasSpecial = false;
        for (int i = 0; i < password.length(); i++) {
            char ch = password[i];
            if (isupper(ch)) hasUpper = true;
            else if (islower(ch)) hasLower = true;
            else if (isdigit(ch)) hasDigit = true;
            else if (ispunct(ch)) hasSpecial = true;
        }

        return hasUpper && hasLower && hasDigit && hasSpecial;
    }

    void resetPassword(string oldPassword, string newPassword) {
        if (password == oldPassword) {
            if (isValidPassword(newPassword)) {
                password = newPassword;
                cout << "Password successfully updated." << endl;
            }
            else {
                cout << "New password does not meet criteria." << endl;
            }
        }
        else {
            cout << "Password is incorrect." << endl;
        }
    }

    string getId() const { return ID; }

    string getEmail() const { return email; }

};
class CustomerHashTable {
public:
    int nextID;
    static const int table_size = 100;
    Customer* chashTable[table_size];

    // Constructor
    CustomerHashTable() : nextID(1) {
        for (int i = 0; i < table_size; i++) {
            chashTable[i] = nullptr;
        }
    }
    // Generate a new unique employee ID
    string generateID() {
        string id = to_string(nextID++);
        while (id.length() < 5) {
            id = "0" + id;
        }
        return id;
    }
    // Hash function to map ID to table index
    int hashFunction(string id) {
        int num = stoi(id);
        return (num % table_size);
    }

    //to change name via hash
    void editCustomerName(string customerID, const string& newName) {
        Customer* customer = searchCustomer(customerID); // Locate the customer
        if (customer) {
            customer->editName(newName);
        }
        else {
            cout << "Customer not found!" << std::endl;
        }
    }

    //reset password thru hash
    void resetPassword(string customerID, const string& oldPassword, const string& newPassword) {
        Customer* customer = searchCustomer(customerID); // Locate the customer
        if (customer) {
            customer->resetPassword(oldPassword, newPassword);
        }
        else {
            cout << "Customer not found!" << std::endl;
        }
    }

    bool isEmailUnique(const string& email) {
        for (int i = 0; i < table_size; ++i) {
            Customer* current = chashTable[i];
            while (current != nullptr) {
                if (current->email == email) {
                    return false; // Email already exists
                }
                current = current->next;
            }
        }
        return true;
    }

    // Add an employee to the hash table
    void addCustomer(string id, const string& name, const string& email, const string& password) {
        cout << "Adding Customer with ID: " << id << endl;
        int index = hashFunction(id);
        Customer* newCustomer = new Customer(id, name, email, password);

        if (chashTable[index] == nullptr) {
            chashTable[index] = newCustomer;
        }
        else {
            Customer* current = chashTable[index];
            while (current->next != nullptr) {
                current = current->next;
            }
            current->next = newCustomer;
        }
    }


    // Search for an employee by ID
    Customer* searchCustomer(string id) {
        int index = hashFunction(id);
        Customer* current = chashTable[index];

        while (current != nullptr) {
            if (current->ID == id) {
                return current;  // Employee found
            }
            current = current->next;
        }

        return nullptr;  // Employee not found
    }

    // Delete an employee by ID
    void deleteCustomer(string id) {
        int index = hashFunction(id);
        Customer* current = chashTable[index];
        Customer* prev = nullptr;

        // Search for the employee to delete
        while (current != nullptr) {
            if (current->ID == id) {
                if (prev == nullptr) {  // Employee is the first in the chain
                    chashTable[index] = current->next;
                }
                else {
                    prev->next = current->next;
                }

                delete current;
                cout << "Customer with ID " << id << " deleted." << endl;
                return;
            }
            prev = current;
            current = current->next;
        }

        cout << "Customer with ID " << id << " not found." << endl;
    }

    // Display all customers in the hash table (for testing purposes)
    void displayAllCustomers() {
        bool hasCustomers = false;
        for (int i = 0; i < table_size; i++) {
            Customer* current = chashTable[i];
            while (current != nullptr) {
                cout << "ID: " << current->ID << ", Name: " << current->name << ", Role: " << current->email << endl;
                current = current->next;
                hasCustomers = true;
            }
        }

        if (!hasCustomers) {
            cout << "No employees found." << endl;
        }
    }
    void signup() {
        string name, email, password;

        cout << "Enter your name: ";
        cin.ignore();
        getline(cin, name);

        cout << "Enter your email: ";
        cin >> email;

        // Check if the email is unique
        if (!isEmailUnique(email)) {
            cout << "This email is already in use. Please try a different one." << endl;
            return;
        }

        // Prompt for a valid password
        while (true) {
            cout << "Enter a password (8-12 characters, must include uppercase, lowercase, digit, and special character): ";
            //password = getPassword();
            cin.ignore();
            getline(cin, password);
            // Check if the password meets the criteria
            Customer tempCustomer;
            if (tempCustomer.isValidPassword(password)) {
                break;
            }
            else {
                cout << "Password does not meet the criteria. Please try again." << endl;
            }
        }

        string id = generateID();

        // Add the new customer to the hash table
        addCustomer(id, name, email, password);

        cout << "Signup successful! Your Customer ID is: " << id << endl;
    }
};
class OrderDishNode {
public:
    Dish* dish;
    OrderDishNode* next;

    OrderDishNode(Dish* d) : dish(d), next(nullptr) {}
};
class Order {
public:
    string ID;
    string customerName;
    int customerLocation;
    double baseCost;
    int priority; // 1 = Premium, 2 = Express, 3 = Normal
    OrderDishNode* dishHead;
    bool isProcessed;
    bool isDelivered;
    Order(string customerName, double baseCost, int priority, string ID, int customerLocation)
        : customerName(customerName), baseCost(baseCost), priority(priority), ID(ID), dishHead(nullptr), isProcessed(false), isDelivered(false), customerLocation(customerLocation) {
        applyDeliveryCharges();
        applyPriorityCost();
    }
    void addDish(Dish* dish) {
        OrderDishNode* newNode = new OrderDishNode(dish);
        if (!dishHead) {
            dishHead = newNode;
        }
        else {
            OrderDishNode* temp = dishHead;
            while (temp->next) {
                temp = temp->next;
            }
            temp->next = newNode;
        }
    }
    void displayOrder() {
        cout << "Order ID: " << ID << "\nCustomer: " << customerName << "\nPriority: ";
        if (priority == 1) cout << "Premium\n";
        else if (priority == 2) cout << "Express\n";
        else cout << "Normal\n";

        cout << "Dishes:\n";
        OrderDishNode* current = dishHead;
        while (current) {
            cout << "- " << current->dish->name << " (Price: " << current->dish->cost << ")\n";
            current = current->next;
        }
        cout << "Total Cost: " << baseCost << "\n";
        cout << "Order Status: " << (isProcessed ? "Processed" : "Not Processed") << "\n";
        cout << "Delivery Status: " << (isDelivered ? "Delivered" : "Not Delivered") << "\n";

    }
    void markAsProcessed() {
        isProcessed = true;
    }
    void markAsDelivered() {
        isDelivered = true;
    }
    void applyPriorityCost() {
        if (priority == 1) {
            baseCost += 500; // Premium
        }
        else if (priority == 2) {
            baseCost += baseCost * 0.1; // Express
        }
        // Normal has no extra cost
    }
    void applyDeliveryCharges() {
        //premium has no delivery charges
        if (priority == 2) {
            baseCost += 200; // Express
        }
        else if (priority == 3) {
            baseCost += 100; // Normal
        }

    }
};


class OrderNode {
public:
    Order* ord;
    OrderNode* next;

    OrderNode(Order* o) : ord(o), next(nullptr) {}
};
class OrderQueue {
private:
    OrderNode* head;
    int idCounter;

public:
    OrderQueue() : head(nullptr), idCounter(10000) {}

    string generateOrderID() {
        return to_string(idCounter++);
    }
    OrderNode* getHead() {
        return head;
    }
    void enqueue(Order* newOrder) {
        OrderNode* newNode = new OrderNode(newOrder);
        //1,2,3
        if (!head || newOrder->priority < head->ord->priority) {
            newNode->next = head;
            head = newNode;
        }
        else {
            OrderNode* current = head;
            while (current->next && current->next->ord->priority <= newOrder->priority) {
                current = current->next;
            }
            newNode->next = current->next;
            current->next = newNode;
        }
    }

    Order* dequeue() {
        OrderNode* temp = head;

        // Iterate through the list to find the first unprocessed order
        while (temp != nullptr) {
            if (temp->ord->isProcessed == false) {
                temp->ord->markAsProcessed();
                return temp->ord;  // Return the first unprocessed order
            }
            temp = temp->next;  // Move to the next node
        }

        cout << "All orders are processed.\n";
        return nullptr;  // Return nullptr if all orders are processed



    }

    bool isEmpty() {
        return head == nullptr;
    }

    //wil show processed unproceesed based on the argumment
    void displayQueue(bool showProcessed = false) {
        if (!head) {
            cout << "No orders in the queue.\n";
            return;
        }

        OrderNode* current = head;
        cout << (showProcessed ? "Processed Orders:\n" : "Current Orders:\n");
        while (current) {
            if (current->ord->isProcessed == showProcessed) {
                current->ord->displayOrder();
                cout << "--------------------\n";
            }
            current = current->next;
        }
    }
    Order* peek() {
        if (!head) return nullptr; // Return null if the queue is empty
        return head->ord;
    }

};
struct ResNode {
    int location;
    int nextID = 0;
    string ID;
    string name;
    string type;
    ResNode* next;
    Menu* menu;
    Employee* manager;
    int staffNum;
    Employee* headEmp;
    OrderQueue orderQueue;

    ResNode(int ID, string name, string type, int location) : name(name), type(type), next(nullptr), manager(nullptr), orderQueue(), location(location) {
        this->ID = to_string(ID);
        while (this->ID.length() < 5) {
            this->ID = "0" + this->ID;
        }
        menu = nullptr;
        headEmp = nullptr;
        staffNum = 0;
    }

};
class Restaurant {
public:
    ResNode* head;
    EmployeeHashTable employeeTable;
    int nextResID = 1;

    Restaurant() : head(nullptr), nextResID(1) {}
    ResNode* getRestaurantByManager(string ID) {
        if (head == nullptr) {
            cout << "No restaurants in the system.\n";
            return nullptr;
        }
        ResNode* temp = head; // Traverse the restaurants
        while (temp != nullptr) {
            if (temp->manager->ID == ID) {
                return temp;
            }
            temp = temp->next; // Move to the next restaurant
        }

        cout << "Manager not associated with any restaurant.\n";
        return nullptr; // No match found
        // traverse through head-
    }
    ResNode* searchResturant(string ID) {
        if (head == nullptr) {
            cout << "No restaurants in the system.\n";
            return nullptr;
        }

        ResNode* temp = head; // Traverse the restaurants
        while (temp != nullptr) {
            Employee* empHead = temp->headEmp; // Traverse the employees of the current restaurant
            while (empHead != nullptr) {
                if (empHead->ID == ID) {
                    return temp; // Found the restaurant
                }
                empHead = empHead->next; // Move to the next employee
            }
            temp = temp->next; // Move to the next restaurant
        }

        cout << "Employee not associated with any restaurant.\n";
        return nullptr; // No match found
    }
    Order* searchOrderByID(const string& orderID) {
        if (head == nullptr) {
            cout << "No restaurants in the system.\n";
            return nullptr;
        }
        ResNode* temp = head;

        while (temp != nullptr) {
            OrderNode* current = temp->orderQueue.getHead();
            while (current) {
                if (current->ord->ID == orderID) {
                    return current->ord;  // Return the order if found
                }
                current = current->next;
            }
            temp = temp->next; // Move to the next restaurant
        }

        return nullptr;  // Return nullptr if the order is not found in either queue
    }
    void processNextOrder(Employee* emp) {
        ResNode* r = searchResturant(emp->ID);
        if (!r) { cout << "invaid resturant" << endl; }
        else {
            cout << "Restaurant : " << r->name << endl;
            if (r->orderQueue.isEmpty()) {
                cout << "No orders to process.\n";
                return;
            }

            Order* nextOrder = r->orderQueue.dequeue();
            if (nextOrder) {
                cout << "Processing the following order:\n";
                nextOrder->displayOrder();
            }
            //nextOrder->markAsProcessed();

            // Mark the employee responsible for processing the order
            cout << "Processed by: " << emp->name << "\n";

            cout << "Order processed successfully!\n";
        }

    }
    void updateStaffName(const string& empID, const string& newName) {
        ResNode* current = head;

        // Traverse the restaurant list
        while (current) {
            Employee* staff = current->headEmp;

            // Traverse the staff list within each restaurant
            while (staff) {
                if (staff->ID == empID) {
                    staff->name = newName; // Update the employee's name
                    cout << "Staff name updated successfully for restaurant: " << current->name << "\n";
                    return;
                }
                staff = staff->next; // Move to the next staff member
            }

            current = current->next; // Move to the next restaurant
        }

        // If no matching employee is found
        cout << "Error: Employee with ID " << empID << " not found in any restaurant.\n";
    }
    void updateStaffPassword(const string& empID, const string& newPassword) {
        ResNode* current = head;

        // Traverse the restaurant list
        while (current) {
            Employee* staff = current->headEmp;

            // Traverse the staff list within each restaurant
            while (staff) {
                if (staff->ID == empID) {
                    staff->password = newPassword; // Update the employee's name
                    cout << "Staff name updated successfully for restaurant: " << current->name << "\n";
                    return;
                }
                staff = staff->next; // Move to the next staff member
            }

            current = current->next; // Move to the next restaurant
        }

        // If no matching employee is found
        cout << "Error: Employee with ID " << empID << " not found in any restaurant.\n";
    }
    void menuManagement(Employee* emp) {
        // Find the restaurant managed by the employee
        ResNode* current = head;
        while (current) {
            if (current->manager && current->manager->ID == emp->ID) {
                break;
            }
            current = current->next;
        }

        if (!current) {
            cout << "No restaurant found for this manager.\n";
            return;
        }

        // Ensure the restaurant has a menu
        if (!current->menu) {
            current->menu = new Menu(current->name);
        }

        Menu* menu = current->menu;
        cout << "Menu Management for Restaurant: " << current->name << endl;

        int choice;
        do {
            cout << "\n1. Add Dish\n2. Edit Dish\n3. Delete Dish\n4. Display Dishes\n5. Exit\n";
            cout << "Enter your choice: ";
            cin >> choice;

            switch (choice) {
            case 1:
                menu->addDish();
                break;
            case 2:
                menu->editDish();
                break;
            case 3:
                menu->deleteDish();
                break;
            case 4:
                menu->displayDishes();
                break;
            case 5:
                cout << "Exiting Menu Management.\n";
                return;
            default:
                cout << "Invalid choice. Please try again.\n";
            }
        } while (true);
    }
    ResNode* gethead() {
        return head;
    }
    void updateManagerName(string ID, string newName) {
        ResNode* current = head;

        // Traverse the linked list to find the restaurant with the given manager ID
        while (current != nullptr) {
            if (current->manager != nullptr && current->manager->ID == ID) {
                current->manager->name = newName; // Update the manager's name
                cout << "Manager's name updated successfully for restaurant: " << current->name << "\n";
                return;
            }
            current = current->next; // Move to the next node
        }

        // If no matching manager is found
        cout << "Error: Manager with ID " << ID << " not found in any restaurant.\n";
    }
    void displayRestaurant() {
        if (!head) {
            cout << "No restaurants to display.\n";
            return;
        }
        ResNode* temp = head;
        while (temp) {
            cout << "Restaurant ID: " << temp->ID
                << ", Name: " << temp->name
                << ", Type: " << temp->type
                << ", Location: "; convertToLoc(temp->location);
            cout << "\n-----------------------------------------\n";
            temp = temp->next;
        }
    }
    void updateManagerPassword(string ID, string newPassword) {
        ResNode* current = head;

        // Traverse the linked list to find the restaurant with the given manager ID
        while (current != nullptr) {
            if (current->manager != nullptr && current->manager->ID == ID) {
                current->manager->password = newPassword; // Update the manager's name
                cout << "Manager's password updated successfully for restaurant: " << "\n";
                return;
            }
            current = current->next; // Move to the next node
        }

        // If no matching manager is found
        cout << "Error: Manager with ID " << ID << " not found in any restaurant.\n";
    }
    string generateResID() {
        string id = to_string(nextResID++);
        while (id.length() < 5) {
            id = "0" + id;
        }
        return id;
    }
    EmployeeHashTable getemployeeTable() {
        return employeeTable;
    }
    Employee getManager() {
        return *head->manager;
    }
    bool isValidPassword(const string& password) {
        if (password.length() < 8 || password.length() > 12) return false;

        bool hasUpper = false, hasLower = false, hasDigit = false, hasSpecial = false;
        for (char ch : password) {
            if (ch >= 'A' && ch <= 'Z') hasUpper = true;
            if (ch >= 'a' && ch <= 'z') hasLower = true;
            if (ch >= '0' && ch <= '9') hasDigit = true;
            if ((ch >= 33 && ch <= 47) || (ch >= 58 && ch <= 64) || (ch >= 91 && ch <= 96) || (ch >= 123 && ch <= 126)) {
                hasSpecial = true;
            }
        }
        return hasUpper && hasLower && hasDigit && hasSpecial;
    }
    void addRestaurant() {
        string name, type, managerName, managerPassword;

        cout << "Enter restaurant name: ";
        cin.ignore();
        getline(cin, name);
        if (isNameUnique(name)) {
            cout << "Restaurant name already exists. Please enter a different name.\n";
            return;
        }

        cout << "Enter restaurant type: ";
        getline(cin, type);

        int location;
        restaurantsLocation();

        do {
            cout << "Enter restaurant location: ";
            cin >> location;
        } while (location < 0 || location > 29);

        cout << "Enter manager's name for the restaurant: ";
        cin.ignore();
        getline(cin, managerName);

        // Create and assign manager
        do {
            cout << "Enter manager's password: ";
            getline(cin, managerPassword);
        } while (!isValidPassword(managerPassword));

        if (isEmployeeUnique(managerName, managerPassword)) {
            cout << "Manager name already assigned to another restaurant. Please enter a different manager name.\n";
            return;
        }

        string resID = generateResID();
        ResNode* newRes = new ResNode(stoi(resID), name, type, location);

        string empID = employeeTable.generateID();
        newRes->manager = new Employee(stoi(empID), managerName, "manager", managerPassword);
        employeeTable.addEmployee(empID, managerName, "manager", managerPassword);

        // Add restaurant to the list
        if (!head) {
            head = newRes;
        }
        else {
            ResNode* temp = head;
            while (temp->next) {
                temp = temp->next;
            }
            temp->next = newRes;
        }

        cout << "Restaurant added successfully! ID: " << newRes->ID << endl;
    }
    ResNode* searchRestaurantByID(string id) {
        ResNode* temp = head;
        while (temp != nullptr) {
            if (temp->ID == id) {
                return temp;
            }
            temp = temp->next;
        }
        return nullptr; // Restaurant not found
    }
    bool isNameUnique(const string& name) {
        ResNode* temp = head;
        while (temp) {
            if (temp->name == name) {
                return true;
            }
            temp = temp->next;
        }
        return false;
    }
    bool isEmployeeUnique(const string& employeeName, const string& employeePassword) {
        ResNode* temp = head;
        while (temp) {
            // Check the manager of the current restaurant
            if (temp->manager && temp->manager->name == employeeName && temp->manager->password == employeePassword) {
                return true;
            }

            // Check all staff members in the current restaurant
            Employee* staff = temp->headEmp;
            while (staff) {
                if (staff->name == employeeName && staff->password == employeePassword) {
                    return true;
                }
                staff = staff->next;
            }

            temp = temp->next;
        }
        return false; // No duplicate found
    }
    void editRestaurant(const string& ID) {
        ResNode* temp = head;

        while (temp) {
            if (temp->ID == ID) {
                string newName, newType, newManagerName, newManagerPassword;

                cout << "Enter new name for the restaurant: ";
                cin.ignore();
                getline(cin, newName);

                if (isNameUnique(newName)) {
                    cout << "Restaurant name already exists. Please enter a different name.\n";
                    return;
                }

                cout << "Enter new type for the restaurant: ";
                getline(cin, newType);

                cout << "Enter new location for the restaurant: ";
                int location;
                restaurantsLocation();
                do {
                    cout << "Enter restaurant location: ";
                    cin >> location;
                } while (location < 0 || location > 29);

                cout << "Enter new manager's name for the restaurant: ";
                cin.ignore();
                getline(cin, newManagerName);

                do {
                    cout << "Enter manager's password for the restaurant: ";
                    getline(cin, newManagerPassword);

                    if (!isValidPassword(newManagerPassword)) {
                        cout << "Invalid password. Ensure it includes:\n"
                            << "- At least one uppercase letter\n"
                            << "- At least one lowercase letter\n"
                            << "- At least one digit\n"
                            << "- At least one special character (!@#$%^&*)\n"
                            << "- Length between 8 and 12 characters\n";
                    }
                } while (!isValidPassword(newManagerPassword));

                if (isEmployeeUnique(newManagerName, newManagerPassword)) {
                    cout << "Manager name already assigned to another restaurant. Please enter a different manager name.\n";
                    return;
                }

                // Update restaurant details
                temp->name = newName;
                temp->type = newType;

                // Update manager details in the hash table
                if (temp->manager != nullptr) {
                    Employee* manager = employeeTable.searchEmployee(temp->manager->ID);
                    if (manager) {
                        manager->name = newManagerName;
                        manager->password = newManagerPassword;
                    }
                }

                cout << "Restaurant edited successfully.\n";
                return;
            }
            temp = temp->next;
        }

        cout << "Restaurant with ID " << ID << " not found.\n";
    }
    void deleteRestaurant(const string& ID) {
        if (!head) {
            cout << "No restaurants to delete.\n";
            return;
        }

        // If the restaurant to delete is the head node
        if (head->ID == ID) {
            ResNode* temp = head;

            // Call deleteEmployee for the restaurant manager
            if (!temp->manager->ID.empty()) {
                employeeTable.deleteEmployee(temp->manager->ID);
            }

            head = head->next;  // Move the head to the next node
            delete temp;  // Clean up memory
            cout << "Restaurant deleted successfully.\n";
            return;
        }

        ResNode* temp = head;
        while (temp->next) {
            if (temp->next->ID == ID) {
                ResNode* toDelete = temp->next;

                // Call deleteEmployee for the restaurant manager
                if (!toDelete->manager->ID.empty()) {
                    employeeTable.deleteEmployee(toDelete->manager->ID);
                }

                temp->next = temp->next->next;  // Skip the node to delete
                delete toDelete;  // Clean up memory
                cout << "Restaurant deleted successfully.\n";
                return;
            }
            temp = temp->next;
        }
        cout << "Restaurant with ID " << ID << " not found.\n";
    }
    void displayRestaurants() {
        if (!head) {
            cout << "No restaurants to display.\n";
            return;
        }

        ResNode* temp = head;
        while (temp) {
            cout << "Restaurant ID: " << temp->ID
                << ", Name: " << temp->name
                << ", Type: " << temp->type
                << ", Location: ";
            convertToLoc(temp->location);
            if (temp->manager) {
                cout << ", Manager: ID " << temp->manager->ID
                    << ", Name: " << temp->manager->name
                    << ", Password: " << temp->manager->password;
            }
            else {
                cout << ", Manager: None";
            }

            cout << "\nNumber of Staff: " << temp->staffNum << "\n";

            if (temp->headEmp) {
                cout << "Staff Details:\n";
                Employee* staff = temp->headEmp;
                while (staff) {
                    cout << "  - ID: " << staff->ID
                        << ", Name: " << staff->name
                        << ", Role: " << staff->role
                        << ", Password: " << staff->password << "\n";
                    staff = staff->next;
                }
            }
            else {
                cout << "No staff assigned.\n";
            }

            cout << "-----------------------------------------\n";
            temp = temp->next;
        }
    }
    ResNode* findRestaurant(const string& name) {
        ResNode* current = head;
        while (current) {
            if (current->name == name) {
                return current;
            }
            current = current->next;
        }
        return nullptr; // Not found
    }
};
string getPassword() {
    string password;
    char ch;
    cout << "Enter your password: ";
    while (true) {
        ch = _getch();
        if (ch == '\r') {
            cout << endl;
            break;
        }
        else if (ch == '\b') {
            if (!password.empty()) {
                password.pop_back();
                cout << "\b \b";
            }
        }
        else {
            password += ch; // Add character to password
            cout << '*';    // Display * on the console
        }
    }
    return password;
}
void placeOrder(Customer* cus, ResNode* res, OrderQueue* queue, PromotionStack* promoStack) {
    int location;
    cout << "Welcome, " << cus->name << "! Please select your Delivery Location:\n";
    restaurantsLocation();
    do {
        cout << "Enter Location: ";
        cin >> location;
    } while (location < 0 || location>29);

    cout << "\nPlease select dishes:\n";
    res->menu->displayDishes();

    char addMore = 'y';
    double baseCost = 0.0;
    Order* newOrder = new Order(cus->name, 0.0, 0, queue->generateOrderID(), location);

    while (addMore == 'y') {
        cout << "Enter Dish ID: ";
        string dishID;
        cin >> dishID;

        Dish* selectedDish = res->menu->searchDish(dishID);
        if (!selectedDish) {
            cout << "Invalid Dish ID. Try again.\n";
        }
        else {
            newOrder->addDish(selectedDish);
            newOrder->baseCost += selectedDish->cost;
            cout << selectedDish->name << " added to your order.\n";
        }

        cout << "Add another dish? (y/n): ";
        cin >> addMore;
    }

    if (!newOrder->dishHead) {
        cout << "No dishes were selected. Order cancelled.\n";
        delete newOrder;
        return;
    }

    applyPromotion(promoStack, newOrder);

    cout << "Select Priority (1 = Premium, 2 = Express, 3 = Normal): ";
    cin >> newOrder->priority;
    newOrder->applyDeliveryCharges();
    newOrder->applyPriorityCost();



    newOrder->displayOrder();
    queue->enqueue(newOrder);
    cout << "Order placed successfully! Order ID: " << newOrder->ID << "\n";
}
void viewOrderHistory(Customer* customer, ResNode* res) {
    cout << "\nOrder History for: " << customer->name << "\n";

    bool hasOrders = false;

    // Check current orders in the queue
    cout << "\nCurrent Orders:\n";
    for (OrderNode* node = res->orderQueue.getHead(); node != nullptr; node = node->next) {
        if (node->ord->customerName == customer->name) {
            node->ord->displayOrder();
            if (node->ord->isProcessed) {
                cout << "Status: Processed\n";
            }
            else {
                cout << "Status: Not Processed\n";
            }
            cout << "--------------------\n";
            hasOrders = true;
        }
    }

    // If no orders were found, inform the customer
    if (!hasOrders) {
        cout << "No orders found for this customer.\n";
    }
}
void viewCurrentOrder(Customer* customer, ResNode* res) {
    cout << "\nCurrent Order for: " << customer->name << "\n";

    // Check current orders in the queue
    for (OrderNode* node = res->orderQueue.getHead(); node != nullptr; node = node->next) {
        if (node->ord->customerName == customer->name && !node->ord->isProcessed) {
            node->ord->displayOrder();
            cout << "Status: Not Processed\n";
            return; // Only show the most recent unprocessed order
        }
    }

    cout << "No current unprocessed order found.\n";
}
void viewCurrentOrderForStaff(ResNode* res) {
    cout << "\nNext Order to Process in " << res->name << ":\n";

    if (res->orderQueue.isEmpty()) {
        cout << "No current orders to display.\n";
        return;
    }

    // Get the next order to process (head of the queue)
    Order* nextOrder = res->orderQueue.peek();
    if (nextOrder) {
        nextOrder->displayOrder();
        cout << "Status: Not Processed\n";
    }
    else {
        cout << "No current orders to display.\n";
    }
}
class reviews {
public:
    string ID;
    int rating; // 1-5 stars
    string description;
    ResNode* restaurant;
    Customer* owner; // Add owner to track the customer who created the review
    reviews* next;

    reviews(int r, string des, ResNode* rd, Customer* custOwner) {
        ID = randomIDgenerator();
        rating = r;
        description = des;
        restaurant = rd;
        owner = custOwner; // Set owner when the review is created
        next = nullptr;
    }

    string randomIDgenerator() {
        static int idCounter = 00000;
        string id = to_string(idCounter++);
        while (id.length() < 5) {
            id = "0" + id;
        }
        return id;
    }
};
class reviewHeap {
public:
    reviews* start;
    reviewHeap() {
        start = nullptr;
    }
    bool compare(reviews* a, reviews* b) {
        return a->rating > b->rating;
    }
    void addreview(reviews* newReview) {
        if (!start || (compare(newReview, start))) {
            newReview->next = start;
            start = newReview;
        }
        else {
            reviews* current = start;
            while (current->next != nullptr) {
                current = current->next;
            }
            current->next = newReview;
        }
        newReview->next = nullptr;
    }
    void deleteReview(string i) {
        if (!start) {
            return;
        }
        if (start->ID == i) {
            reviews* todelete = start;
            start = start->next;
            delete todelete;
            return;
        }

        reviews* last = start;
        while (last->next && last->next->ID != i) {
            last = last->next;
        }
        if (last->next) {
            reviews* todelete = last->next;
            last->next = last->next->next;
            delete todelete;
        }
    }
    void editReview(string id, int newRating, const string& newDescription) {
        reviews* current = start;

        while (current) {
            if (current->ID == id) {
                current->rating = newRating;
                current->description = newDescription;
                //return true;
            }
            current = current->next;
        }

        //return false; 
    }
    void displayTopReviews() const {
        reviews* current = start;
        while (current != nullptr) {
            cout << "ID: " << current->ID << ", Rating: ";
            for (int j = 0; j < current->rating; j++) {
                cout << "*";
            }
            cout << " Customer: " << current->owner->name << ", Restaurant: " << current->restaurant->name << ", Description : " << current->description << endl;
            current = current->next;
        }
        cout << endl;
    }

    bool searchReview(string id) {
        reviews* current = start;
        while (current) {
            if (current->ID == id) {
                return true;
            }
            current = current->next;
        }
        return false;
    }

    ~reviewHeap() {
        while (start) {
            reviews* todelete = start;
            start = start->next;
            delete todelete;
        }
    }
};
class reviewsManager {
public:
    reviewHeap goodheap;
    reviewHeap badheap;

    void addReview(int r, string des, ResNode* resNode, Customer* custOwner) {
        if (!resNode) {
            cout << "Error: Invalid restaurant provided." << endl;
            return;
        }

        reviews* newReview = new reviews(r, des, resNode, custOwner);
        if (r >= 3) {
            goodheap.addreview(newReview);
        }
        else {
            badheap.addreview(newReview);
        }
    }

    void displayGoodheap(const string& restaurantID) {
        reviews* current = goodheap.start;
        while (current) {
            if (current->restaurant && current->restaurant->ID == restaurantID) {
                cout << "Review ID: " << current->ID << ", Rating: " << current->rating << ", Description: " << current->description << endl;
            }
            current = current->next;
        }
    }

    void displayBadheap(const string& restaurantID) {
        reviews* current = badheap.start;
        while (current) {
            if (current->restaurant && current->restaurant->ID == restaurantID) {
                cout << "Review ID: " << current->ID << ", Rating: " << current->rating << ", Description: " << current->description << endl;
            }
            current = current->next;
        }
    }

    void displayGoodheap() {
        cout << "top good reviews" << endl;
        goodheap.displayTopReviews();

    }
    void displayBadheap() {
        cout << "top bad reviews" << endl;
        badheap.displayTopReviews();

    }

    void editReviews(string id, int r, string des, Customer* cust) {
        reviews* current = goodheap.start;
        while (current) {
            if (current->ID == id && current->owner == cust) {
                current->rating = r;
                current->description = des;
                cout << "Review updated successfully!" << endl;
                return;
            }
            current = current->next;
        }
        current = badheap.start;
        while (current) {
            if (current->ID == id && current->owner == cust) {
                current->rating = r;
                current->description = des;
                cout << "Review updated successfully!" << endl;
                return;
            }
            current = current->next;
        }
        cout << "Error: Review not found or you do not have permission to edit it." << endl;
    }

    void deleteReview(string id, Customer* cust) {
        if (goodheap.searchReview(id)) {
            reviews* current = goodheap.start;
            if (current->ID == id && current->owner == cust) {
                goodheap.deleteReview(id);
                cout << "Review deleted successfully!" << endl;
                return;
            }
        }
        if (badheap.searchReview(id)) {
            reviews* current = badheap.start;
            if (current->ID == id && current->owner == cust) {
                badheap.deleteReview(id);
                cout << "Review deleted successfully!" << endl;
                return;
            }
        }
        cout << "Error: Review not found or you do not have permission to delete it." << endl;
    }

};
class Admin {
    string name;
    string email;
    string password;
    Restaurant& restaurant;
public:
    Admin(Restaurant& res) : restaurant(res) {
        name = "Areej";
        email = "areej@gmail.com";
        password = "@1234Rew";
    }

    // Login function for the admin
    bool login() {
        string enteredEmail, enteredPassword;

        cout << "Enter your email: ";
        cin >> enteredEmail;

        // Get the password securely
        enteredPassword = getPassword();

        // Check if entered credentials match the admin's credentials
        if (enteredEmail == email && enteredPassword == password) {
            cout << "Login successful. Welcome, " << name << "!" << endl;
            return true;
        }
        else {
            cout << "Invalid email or password!" << endl;
            return false;
        }
    }

    void AdminMenu() {
        int choice;
        string ID;

        while (true) {
            cout << "\n----- Admin Menu -----\n";
            cout << "1. Add Restaurant\n";
            cout << "2. Edit Restaurant\n";
            cout << "3. Delete Restaurant\n";
            cout << "4. Display All Restaurants\n";
            cout << "5. Exit\n";
            cout << "Enter your choice: ";
            cin >> choice;

            switch (choice) {
            case 1:
                restaurant.addRestaurant();
                break;
            case 2:
                cout << "Enter restaurant ID to edit: ";
                cin >> ID;
                restaurant.editRestaurant(ID);
                break;
            case 3:
                cout << "Enter restaurant ID to delete: ";
                cin >> ID;
                restaurant.deleteRestaurant(ID);
                break;
            case 4:
                restaurant.displayRestaurants();
                break;
            case 5:
                cout << "Exiting Admin Menu. Goodbye!\n";
                return;
            default:
                cout << "Invalid choice. Please try again.\n";
                break;
            }
        }
        return;
    }

};
void deliveryMenu(Employee* emp, Restaurant* res, EmployeeHashTable* hash, reviewsManager* r, Graph* g) {
    ResNode* n = nullptr;
    int option;
    do {
        cout << "\nDelivery Driver Menu:\n";
        cout << "1. Edit Name\n2. Reset Password\n3. Deliver Order\n4. View Processed Orders\n5. Read Reviews\n6. View Current Orders\n7. Exit\n";
        cout << "Enter your choice: ";
        cin >> option;

        switch (option) {
        case 1: {
            string newName;
            cout << "Enter new name: ";
            cin.ignore();
            getline(cin, newName);

            if (res->isEmployeeUnique(newName, emp->password)) {
                cout << "Manager already exist. Please enter a different manager name.\n";
                break;
            }
            emp->name = newName;
            res->updateStaffName(emp->ID, newName);
            cout << "Name updated successfully to: " << emp->name << endl;
        }
              break;
        case 2: {
            string newPassword;
            do {
                cout << "New password: ";
                cin.ignore();
                getline(cin, newPassword);
            } while (!res->isValidPassword(newPassword));

            if (res->isEmployeeUnique(emp->name, newPassword)) {
                cout << "Manager already exists. Please enter a different manager password.\n";
                break;
            }

            emp->password = newPassword;
            res->updateStaffPassword(emp->ID, newPassword);
            cout << "Password updated successfully!\n";

            break;
        }
        case 3: {
            n = res->searchResturant(emp->ID);
            if (n == nullptr) {
                cout << "Restaurant doesn't exist" << endl;
                return;
            }

            // Count processed orders and collect their destinations
            int numProcessedOrders = 0;
            int* destinations = nullptr; // Pointer to dynamic array
            int destCount = 0;

            // Traverse through the order queue once
            for (OrderNode* node = n->orderQueue.getHead(); node != nullptr; node = node->next) {
                if (node->ord->isProcessed && !node->ord->isDelivered) {
                    numProcessedOrders++;
                }
            }

            // Only allocate and collect destinations if there are processed orders
            if (numProcessedOrders > 0) {
                destinations = new int[numProcessedOrders]; // Allocate dynamic array

                // Collect the destinations
                for (OrderNode* node = n->orderQueue.getHead(); node != nullptr; node = node->next) {
                    if (node->ord->isProcessed && !node->ord->isDelivered) {
                        destinations[destCount++] = node->ord->customerLocation;
                    }
                }

                // Calculate the shortest path
                g->shortestPath(n->location, destinations, destCount);

                // Mark orders as delivered
                for (OrderNode* node = n->orderQueue.getHead(); node != nullptr; node = node->next) {
                    if (node->ord->isProcessed && !node->ord->isDelivered) {
                        node->ord->markAsDelivered();
                        cout << "Order " << node->ord->ID << " marked as delivered.\n";
                    }
                }

                // Deallocate the dynamic array after use
                delete[] destinations;
            }
            else {
                cout << "Not enough processed orders for delivery.\n";
            }

            break;
        }
        case 4: { // View Processed Orders
            n = res->searchResturant(emp->ID);
            if (n == nullptr) { cout << "res doenst exist" << endl; }
            else {
                bool hasProcessedOrders = false;
                for (OrderNode* node = n->orderQueue.getHead(); node != nullptr; node = node->next) {
                    if (node->ord->isProcessed) {
                        node->ord->displayOrder();
                        cout << "Status: Processed\n";
                        cout << "--------------------\n";
                        hasProcessedOrders = true;
                    }
                }

                if (!hasProcessedOrders) {
                    cout << "No processed orders found.\n";
                }
            }

            break;
        }
        case 5: {
            n = res->searchResturant(emp->ID);
            if (n == nullptr) { cout << "employee doesnt exist" << endl; }
            else {
                cout << "Displaying reviews for restaurant: " << n->name << endl;
                r->displayGoodheap(n->ID);
                r->displayBadheap(n->ID);
            }
            break;
        }
        case 6: { // View Current Order
            n = res->searchResturant(emp->ID);
            if (n == nullptr) { cout << "res doenst exist" << endl; }
            else {
                Order* nextOrder = nullptr;
                for (OrderNode* node = n->orderQueue.getHead(); node != nullptr; node = node->next) {
                    if (!node->ord->isDelivered) {  // Check if the order is not processed yet
                        nextOrder = node->ord;
                        break;  // Stop after finding the first unprocessed order
                    }
                }

                if (nextOrder == nullptr) {
                    cout << "No current orders to deliver.\n";
                }
                else {
                    nextOrder->displayOrder();
                    cout << "Status: Not Delivered\n";
                    cout << "--------------------\n";
                }

            }

            break;
        }
        case 7:
            cout << "Exiting Manager Menu...\n";
            return;

        default:
            cout << "Invalid option. Please try again.\n";
        }
    } while (true);

}
void staffMenu(Employee* emp, Restaurant* res, EmployeeHashTable* hash, reviewsManager* r) {
    ResNode* n = nullptr;

    int option;
    do {
        cout << "\nStaff Menu:\n";
        cout << "1. Edit Name\n2. Reset Password\n3. Process Order\n4. View Processed Orders\n5. Read Reviews\n6. View Current Orders\n7. Exit\n";
        cout << "Enter your choice: ";
        cin >> option;

        switch (option) {
        case 1: {
            string newName;
            cout << "Enter new name: ";
            cin.ignore();
            getline(cin, newName);

            if (res->isEmployeeUnique(newName, emp->password)) {
                cout << "Manager already exist. Please enter a different manager name.\n";
                break;
            }
            emp->name = newName;
            res->updateStaffName(emp->ID, newName);
            cout << "Name updated successfully to: " << emp->name << endl;
        }
              break;
        case 2: {
            string newPassword;
            do {
                cout << "New password: ";
                cin.ignore();
                getline(cin, newPassword);
            } while (!res->isValidPassword(newPassword));

            if (res->isEmployeeUnique(emp->name, newPassword)) {
                cout << "Manager already exists. Please enter a different manager password.\n";
                break;
            }

            emp->password = newPassword;
            res->updateStaffPassword(emp->ID, newPassword);
            cout << "Password updated successfully!\n";

            break;
        }
        case 3: { // Process Next Order
            res->processNextOrder(emp);
            break;
        }
        case 4: { // View Processed Orders
            n = res->searchResturant(emp->ID);
            if (n == nullptr) { cout << "res doenst exist" << endl; }
            else {
                bool hasProcessedOrders = false;
                for (OrderNode* node = n->orderQueue.getHead(); node != nullptr; node = node->next) {
                    if (node->ord->isProcessed) {
                        node->ord->displayOrder();
                        cout << "Status: Processed\n";
                        cout << "--------------------\n";
                        hasProcessedOrders = true;
                    }
                }

                if (!hasProcessedOrders) {
                    cout << "No processed orders found.\n";
                }
            }

            break;
        }
        case 5: {
            n = res->searchResturant(emp->ID);
            if (n == nullptr) { cout << "employee doesnt exist" << endl; }
            else {
                cout << "Displaying reviews for restaurant: " << n->name << endl;
                r->displayGoodheap(n->ID);
                r->displayBadheap(n->ID);
            }
            break;
        }
        case 6: { // View Current Order
            n = res->searchResturant(emp->ID);
            if (n == nullptr) { cout << "res doenst exist" << endl; }
            else {
                Order* nextOrder = nullptr;
                for (OrderNode* node = n->orderQueue.getHead(); node != nullptr; node = node->next) {
                    if (!node->ord->isProcessed) {  // Check if the order is not processed yet
                        nextOrder = node->ord;
                        break;  // Stop after finding the first unprocessed order
                    }
                }

                if (nextOrder == nullptr) {
                    cout << "No current orders to process.\n";
                }
                else {
                    nextOrder->displayOrder();
                    cout << "Status: Not Processed\n";
                    cout << "--------------------\n";
                }

            }

            break;
        }
        case 7:
            cout << "Exiting Manager Menu...\n";
            return;

        default:
            cout << "Invalid option. Please try again.\n";
        }
    } while (true);
}
void managerMenu(Employee* emp, Restaurant* res, EmployeeHashTable* hash, reviewsManager* r) {
    int option;
    ResNode* n = nullptr;

    do {
        cout << "\nManager Menu:\n";
        cout << "1. Edit Name\n2. Reset Password\n3. Add staff\n4. Menu Management\n5. Read Reviews\n6. View Orders\n7. Exit\n";
        cout << "Enter your choice: ";
        cin >> option;

        switch (option) {
        case 1: {
            string newName;
            cout << "Enter new name: ";
            cin.ignore();
            getline(cin, newName);

            if (res->isEmployeeUnique(newName, emp->password)) {
                cout << "Manager already exist. Please enter a different manager name.\n";
                break;
            }
            emp->name = newName;
            res->updateManagerName(emp->ID, newName);
            cout << "Name updated successfully to: " << emp->name << endl;
        }
              break;
        case 2: {
            string newPassword;
            do {
                cout << "New password: ";
                cin.ignore();
                getline(cin, newPassword);
            } while (!res->isValidPassword(newPassword));

            if (res->isEmployeeUnique(emp->name, newPassword)) {
                cout << "Manager already exists. Please enter a different manager password.\n";
                break;
            }

            emp->password = newPassword;
            res->updateManagerPassword(emp->ID, newPassword);
            cout << "Password updated successfully!\n";

            break;
        }
        case 3: {
            int numStaff;
            string staffName, staffPassword;
            do {
                cout << "Enter the number of staff to add: ";
                cin >> numStaff;
            } while (numStaff < 2);

            cin.ignore();

            for (int i = 0; i < numStaff; i++) {
                cout << "Adding Staff Member " << i + 1 << ":\n";

                cout << "Enter staff name: ";
                getline(cin, staffName);

                do {
                    cout << "Enter staff password: ";
                    getline(cin, staffPassword);
                } while (!res->isValidPassword(staffPassword));

                if (res->isEmployeeUnique(staffName, staffPassword)) {
                    cout << "Staff already exists.\n";
                    continue; // Skip to the next staff member
                }

                // Find the restaurant where the manager works
                ResNode* current = res->gethead();
                while (current) {
                    if (current->manager && current->manager->ID == emp->ID) {
                        // Generate a unique staff ID using the restaurant's nextID
                        string staffID = current->ID + "_" + to_string(current->nextID++);

                        string staffRole = (current->headEmp == nullptr) ? "Delivery Driver" : "staff";
                        // Add to EmployeeHashTable
                        hash->addEmployee(staffID, staffName, staffRole, staffPassword);

                        // Add to the restaurant's staff list
                        if (!current->headEmp) {
                            current->headEmp = new Employee(staffID, staffName, staffRole, staffPassword);
                        }
                        else {
                            Employee* temp = current->headEmp;
                            while (temp->next) {
                                temp = temp->next;
                            }
                            temp->next = new Employee(staffID, staffName, staffRole, staffPassword);
                        }

                        current->staffNum++;
                        cout << "Staff added successfully to restaurant: " << current->name << "\n";
                        break;
                    }
                    current = current->next;
                }
            }
            break;
        }

        case 4: {
            res->menuManagement(emp);
            //menu management
            break;
        }
        case 5: {
            ResNode* current = res->gethead();
            while (current) {
                if (current->manager && current->manager->ID == emp->ID) {
                    cout << "Displaying reviews for restaurant: " << current->name << endl;
                    r->displayGoodheap(current->ID);
                    r->displayBadheap(current->ID);
                    break;
                }
                current = current->next;
            }
            break;
        }
        case 6: { // View Current Order
            //ResNode
            n = res->getRestaurantByManager(emp->ID);

            if (n == nullptr) { cout << "res doenst exist" << endl; }
            else {
                Order* nextOrder = nullptr;
                for (OrderNode* node = n->orderQueue.getHead(); node != nullptr; node = node->next) {
                    if (!node->ord->isProcessed) {  // Check if the order is not processed yet
                        nextOrder = node->ord;
                        break;  // Stop after finding the first unprocessed order
                    }
                }

                if (nextOrder == nullptr) {
                    cout << "No current orders to process.\n";
                }
                else {
                    nextOrder->displayOrder();
                    cout << "Status: Not Processed\n";
                    cout << "--------------------\n";
                }

            }

            break;
        }
        case 7:
            cout << "Exiting Manager Menu...\n";
            return;

        default:
            cout << "Invalid option. Please try again.\n";
        }
    } while (true);
}
void customerMenu(Customer* cus, reviewsManager* r, Restaurant rest, PromotionStack* promoStack) {
    cout << "Welcome Dear Customer" << endl;
    cout << "how are u doing this fine day(dont bother answering)" << endl;
    int choice, rating;
    string newName, oldPassword, newPassword, description, resID, orderID, restaurantName, reviewID;
    ResNode* res;
    Order* order;
    while (true) {
        cout << "What do you want to do:" << endl;
        cout << "1.edit your name\n2.reset password\n3.place an order\n4.leave a reviews\n5.view order history\n6.view current order status\n7.view review history\n8.Edit Reviews\n9.Delete reviews\n10.Exit\n";
        cin >> choice;
        switch (choice) {
        case 1:
            cout << "Enter your new name: ";
            cin.ignore();
            getline(cin, newName);
            cus->editName(newName);
            cout << "Name updated successfully to " << cus->name << "." << endl;
            break;
        case 2:
            cout << "Current password\n";
            oldPassword = getPassword();
            cout << "New password\n";
            newPassword = getPassword();
            cus->resetPassword(oldPassword, newPassword);
            break;
        case 3:
            rest.displayRestaurant();
            cout << "Which Resturant do you want to order from,enter resturatn ID:";
            cin.ignore();
            getline(cin, resID);
            res = rest.searchRestaurantByID(resID);
            if (res == nullptr) { cout << "restaurant doesnt exist" << endl; }
            else {
                placeOrder(cus, res, &res->orderQueue, promoStack);
            }
            break;
        case 4:
        {
            char ans;
            cin.ignore();
            rest.displayRestaurant();
            cout << "Enter the name of the restaurant: ";
            getline(cin, restaurantName);
            ResNode* selectedRes = rest.findRestaurant(restaurantName);

            if (!selectedRes) {
                cout << "Restaurant not found. Review cannot be added." << endl;
            }
            else {
                cout << "Leave a review:" << endl;
                cout << "Enter a rating (1-5 stars): ";
                cin >> rating;
                while (rating < 1 || rating > 5) {
                    cout << "Invalid rating. Please enter a value between 1 and 5: ";
                    cin >> rating;
                }

                cout << "Do u want to enter review on a specific dish? (Y/N)\n";
                cin >> ans;

                if (ans == 'Y' || ans == 'y') {
                    cout << "Enter your review on a dish: ";
                    cin.ignore();
                    getline(cin, description);
                    r->addReview(rating, description, selectedRes, cus);
                }
                else {
                    cout << "Enter your review description: ";
                    cin.ignore();
                    getline(cin, description);
                    r->addReview(rating, description, selectedRes, cus);
                }
                cout << "Thank you for your review for " << selectedRes->name << "!" << endl;
            }
            break;

        }
        case 5:
            cout << "Which Resturant do you want to order from,enter resturatn ID:";
            cin.ignore();
            getline(cin, resID);
            res = rest.searchRestaurantByID(resID);
            if (res == nullptr) { cout << "restaurant doesnt exist" << endl; }
            else {
                viewOrderHistory(cus, res);
            }

            break;
        case 6:
            cout << "Enter Order ID to check status:";
            cin.ignore();
            getline(cin, orderID);
            order = rest.searchOrderByID(orderID);
            if (order == nullptr) { cout << "order doesnt exist" << endl; }
            else {
                bool status = order->isProcessed;
                if (status == true) {
                    cout << "Order has been processed" << endl;
                    order->displayOrder();
                }
                else {
                    cout << "order has to be processed" << endl;
                    order->displayOrder();
                }
            }

            break;
        case 7:
            cout << "Your reviews:" << endl;
            r->displayGoodheap();
            r->displayBadheap();
            break;
        case 8:
        { // Edit Review
            cout << "Enter the ID of the review you want to edit: ";
            cin.ignore();
            getline(cin, reviewID);

            cout << "Enter the new rating (1-5 stars): ";
            cin >> rating;
            while (rating < 1 || rating > 5) {
                cout << "Invalid rating. Please enter a value between 1 and 5: ";
                cin >> rating;
            }
            cin.ignore();
            cout << "Enter the new description: ";
            getline(cin, description);

            r->editReviews(reviewID, rating, description, cus);
            break;
        }
        case 9: { // Delete Review
            cout << "Enter the ID of the review you want to delete: ";
            cin.ignore();
            getline(cin, reviewID);

            r->deleteReview(reviewID, cus);
            break;
        }
        case 10:
            return;
        default:
            break;
        }
    }
};
struct Promotion {
    int id;
    string name;
    double discount;
    int limit;
    Promotion* next;

    Promotion(int id, const string& name, double discount, int limit)
        : id(id), name(name), discount(discount), limit(limit), next(nullptr) {}
};
class PromotionStack {
private:
    Promotion* top;
    int idCounter;

    int generateId() {
        return ++idCounter;
    }

public:
    PromotionStack() : top(nullptr), idCounter(10000) {}

    void push(const string& name, double discount, int limit) {
        Promotion* newPromo = new Promotion(generateId(), name, discount, limit);
        newPromo->next = top;
        top = newPromo;
    }

    void pop() {
        if (top) {
            Promotion* temp = top;
            top = top->next;
            delete temp;
        }
    }

    Promotion* peek() const {
        return top;
    }

    bool isEmpty() const {
        return top == nullptr;
    }
};
void applyPromotion(PromotionStack* promoStack, Order* order) {
    if (promoStack->isEmpty()) {
        cout << "empty\n"; return;
    }
    Promotion* promo = promoStack->peek();
    order->baseCost -= order->baseCost * (promo->discount / 100);

    promo->limit--;
    if (promo->limit == 0) {
        promoStack->pop();
    }
}

int main() {
    int V = 30; // Number of vertices
    Graph g(V);
    initializeGraph(g);


    Restaurant res;
    Admin admin(res);
    Employee* emp = nullptr;
    EmployeeHashTable employeeHashTable;
    Customer* cus = nullptr;
    CustomerHashTable customerHashTable;
    string cid, customerpass;
    reviewsManager r;
    PromotionStack promoStack;

    promoStack.push("Black Friday", 50, 2);
    promoStack.push("New Year", 30, 3);

    cout << " ______    _______  _______  _______  _______  __   __  ______    _______  __    _  _______    __   __  __   __  _______    __  " << endl;
    cout << "|    _ |  |       ||       ||       ||   _   ||  | |  ||    _ |  |   _   ||  |  | ||       |  |  | |  ||  | |  ||  _    |  |  | " << endl;
    cout << "|   | ||  |    ___||  _____||_     _||  |_|  ||  | |  ||   | ||  |  |_|  ||   |_| ||_     _|  |  |_|  ||  | |  || |_|   |  |  | " << endl;
    cout << "|   |_||_ |   |___ | |_____   |   |  |       ||  |_|  ||   |_||_ |       ||       |  |   |    |       ||  |_|  ||       |  |  | " << endl;
    cout << "|    __  ||    ___||_____  |  |   |  |       ||       ||    __  ||       ||  _    |  |   |    |       ||       ||  _   |   |__| " << endl;
    cout << "|   |  | ||   |___  _____| |  |   |  |   _   ||       ||   |  | ||   _   || | |   |  |   |    |   _   ||       || |_|   |   __  " << endl;
    cout << "|___|  |_||_______||_______|  |___|  |__| |__||_______||___|  |_||__| |__||_|  |__|  |___|    |__| |__||_______||_______|  |__| " << endl;
    cout << endl;

    while (true) {
        int userType;
        cout << "\nSelect User Type\n1. Admin\n2. Employee\n3. Customer\n4. Exit ";
        cin >> userType;

        switch (userType) { //admin login
        case 1: {
            if (admin.login()) {
                admin.AdminMenu();
                employeeHashTable = res.getemployeeTable();
            }
        }
              break;
        case 2: { // Employee Login
            string id, enteredPassword;
            cout << "Enter Employee ID: ";
            cin >> id;
            enteredPassword = getPassword();
            emp = employeeHashTable.searchEmployee(id);

            if (emp != nullptr && emp->password == enteredPassword) {
                cout << "Login successful! Welcome " << emp->name << " (" << emp->role << ")." << endl;

                if (emp->role == "manager") {
                    cout << "Redirecting to Manager Menu..." << endl;
                    managerMenu(emp, &res, &employeeHashTable, &r);
                }
                else if (emp->role == "Delivery Driver") {
                    cout << "Redirecting to Delivery Driver Menu..." << endl;
                    deliveryMenu(emp, &res, &employeeHashTable, &r, &g);
                }
                else if (emp->role == "staff") {
                    cout << "Redirecting to Staff Menu..." << endl;
                    staffMenu(emp, &res, &employeeHashTable, &r);
                }
                else {
                    cout << "Invalid role assigned. Please contact the admin." << endl;
                }
            }
            else {
                cout << "Invalid ID or password. Please try again." << endl;
            }
        }
              break;
        case 3: {
            int choice;

            // customer sigin
            cout << "Enter 1 to Signup\nEnter 2 to login" << endl;
            cin >> choice;
            if (choice == 1) {
                customerHashTable.signup();
            }
            // customer login
            else if (choice == 2) {
                string id, enteredPassword;
                cout << "Enter Customer ID: ";
                cin >> id;
                enteredPassword = getPassword();
                cus = customerHashTable.searchCustomer(id);

                if (cus != nullptr && cus->password == enteredPassword) {
                    cout << "Login successful! Welcome " << cus->name << " (" << cus->ID << ")." << endl;
                    customerMenu(cus, &r, res, &promoStack);
                }
                else {
                    cout << "Invalid ID or password. Please try again." << endl;
                }
            }
            else {
                cout << "invalid choice" << endl;
            }
            break;
        }

        case 4:
            cout << "Exiting program..." << endl;
            return 0;
        default:
            cout << "Invalid selection!" << endl;
        }
    }

}