implement.cpp

#include "header.h"
#include "avl.h"
#include<fstream>

PizzaShop* myPizzaShop=NULL;
double total, takeAway, dineIn, homeDelivery;
int orderIDCounter = 1;


//For home delivery
HomeDeliveryNode* home = NULL;

//For dine in orders
Node* dineInQueue=NULL;  //front in our queue
Node* currentOrder=NULL; //rear in our queue

//For take away orders
Node* head = NULL;
int size = 0;





customer insertData(PizzaShop* myPizzaShop){
	customer c;

	cin.ignore(); 
	cout << "Enter the name of the customer: ";
	getline(cin, c.name);
	cout << endl;

	cout << "Enter age of the customer: ";
	cin >> c.age;
	cout << endl;

	cout << "Enter option for Pizza: ";
	cin >> c.pizzaIndex;

    // assign pizza name based on index
    if (c.pizzaIndex >= 1 && c.pizzaIndex <= 10) {
        c.pizzaName = myPizzaShop->menu[c.pizzaIndex];
    } else {
        cout << "Invalid index. Setting pizza name to 'unknown'.\n";
        c.pizzaName = "unknown";
    }

	cout << "Enter quantity: ";
	cin >> c.quantity;

	c.bill = c.quantity * myPizzaShop->price[c.pizzaIndex];

	return c;
}






//-----------------------------------------------------------Place Orders------------------------------------------------------------------

void placeTakeAwayOrder(customer c) {
	c.orderID = orderIDCounter++;
    Node* newNode = new Node;
    newNode->c = c;
    newNode->next = NULL;

    if (head == NULL) {
        head = newNode;
        size++;
		cout << "Your Order has been Placed MR/MRS " << c.name
		     << " | Order ID: " << c.orderID
		     << " | Pizza: " << c.pizzaName
		     << " | Quantity: " << c.quantity
		     << " | Total Bill: " << c.bill << " RS/_"
		     << endl;
		string customerType="Take-Away ";
		writeOrderToFile(c, "order.txt",customerType );
        return;
    }

    // Append at end
    Node* temp = head;
    while (temp->next != NULL)
        temp = temp->next;
    temp->next = newNode;

    // Heapify up (swap by customer if age condition not met)
    int childIndex = size;
    int parentIndex = (childIndex - 1) / 2;

    while (childIndex > 0) {
        Node* child = head;
        for (int i = 0; i < childIndex; ++i)
            child = child->next;

        Node* parent = head;
        for (int i = 0; i < parentIndex; ++i)
            parent = parent->next;

        if (child->c.age <= parent->c.age)
            break;

        // Swap customer objects (not nodes)
        customer tempC = parent->c;
        parent->c = child->c;
        child->c = tempC;

        childIndex = parentIndex;
        parentIndex = (childIndex - 1) / 2;
    }

    size++;

    // Final print after insertion
	cout << "Your Order has been Placed MR/MRS " << c.name
	     << " | Order ID: " << c.orderID
	     << " | Pizza: " << c.pizzaName
	     << " | Quantity: " << c.quantity
	     << " | Total Bill: " << c.bill << " RS/_"
	     << endl;
	     
	string customerType = "Take-Away ";
    writeOrderToFile(c, "order.txt", customerType);
}




void placeDineInOrder(customer c) {
	c.orderID = orderIDCounter++;
    Node* newOrder = new Node;
    newOrder->c = c;
    newOrder->next = NULL;

    if (dineInQueue == NULL) {
        dineInQueue = newOrder;
    } 
	else {
        Node* currentOrder = dineInQueue;
        while (currentOrder->next != NULL) {
            currentOrder = currentOrder->next;
        }
        currentOrder->next = newOrder;
    }

	cout << "Your Order has been Placed MR/MRS " << c.name
	     << " | Order ID: " << c.orderID
	     << " | Pizza: " << c.pizzaName
	     << " | Quantity: " << c.quantity
	     << " | Total Bill: " << c.bill << " RS/_"
	     << endl;

	string customerType = "Dine-In ";
    writeOrderToFile(c, "order.txt", customerType);
}



void placeHomeOrders(customer c, string address, int deliveryCharges, int distanceDelivery) {
	c.orderID = orderIDCounter++;
    HomeDeliveryNode* tmp = new HomeDeliveryNode();

    tmp->c = c;
    tmp->address = address;
    tmp->deliveryCharges = deliveryCharges;
    tmp->distanceFromShop = distanceDelivery;
    tmp->next = home;
    home = tmp;
	
	cout << "Your Order has been Placed MR/MRS " << c.name
	     << " | Order ID: " << c.orderID
	     << " | Pizza: " << c.pizzaName
	     << " | Quantity: " << c.quantity
	     << " | Total Bill: " << c.bill << " RS/_"
	     << endl;


    cout << "Delivery Charges: " << deliveryCharges << " RS/_"
         << " | Distance: " << distanceDelivery << " KM"
         << " | Address: " << address << endl;
    
	string customerType = "Home-Delivery Customer";
    writeOrderToFile(c, "order.txt", customerType);
}





//---------------------------------------------------------Serve Orders--------------------------------------------------------------------

void serveTakeAway() {
    if (head == NULL) {
        cout << "No customer to serve.\n";
        return;
    }

    // If only one element
    if (size == 1) {
        cout << "Take away customer served: " << head->c.name
             << " | Age: " << head->c.age
             << " | Pizza: " << head->c.pizzaName
             << " | Quantity: " << head->c.quantity
             << " | Bill: " << head->c.bill << endl;

        // storing in avl
        string customerType = "Take-Away";
        bool ht_inc = false;
        root=insertAVL(head->c,customerType,root,&ht_inc);
        writeOrderToFile(head->c, "served.txt", customerType);
        
        delete head;
        head = NULL;
        size--;
        return;
    }

    // Find last node and its previous node
    Node* last = head;
    Node* beforeLast = NULL;
    for (int i = 0; i < size - 1; i++) {
        beforeLast = last;
        last = last->next;
    }

    // Store root (highest priority) for output
    customer served = head->c;

    // Replace root with last node's customer
    head->c = last->c;

    // Delete last node
    if (beforeLast != NULL)
        beforeLast->next = NULL;
    else
        head = NULL;

    delete last;
    size--;

    // Bubble down to maintain heap
    int parentIndex = 0;
    int left = 2 * parentIndex + 1;
    int right = 2 * parentIndex + 2;

    while (right < size) {
        Node* parent = head;
        for (int i = 0; i < parentIndex; i++) parent = parent->next;

        Node* leftNode = head;
        for (int i = 0; i < left; i++) leftNode = leftNode->next;

        Node* rightNode = head;
        for (int i = 0; i < right; i++) rightNode = rightNode->next;

        if (parent->c.age >= leftNode->c.age && parent->c.age >= rightNode->c.age)
            break;

        if (leftNode->c.age >= rightNode->c.age) {
            customer temp = parent->c;
            parent->c = leftNode->c;
            leftNode->c = temp;
            parentIndex = left;
        } else {
            customer temp = parent->c;
            parent->c = rightNode->c;
            rightNode->c = temp;
            parentIndex = right;
        }

        left = 2 * parentIndex + 1;
        right = 2 * parentIndex + 2;
    }

    if (left == size - 1) {
        Node* parent = head;
        for (int i = 0; i < parentIndex; i++) parent = parent->next;

        Node* leftNode = head;
        for (int i = 0; i < left; i++) leftNode = leftNode->next;

        if (parent->c.age < leftNode->c.age) {
            customer temp = parent->c;
            parent->c = leftNode->c;
            leftNode->c = temp;
        }
    }


    cout << "Take away customer served: " << served.name
         << " | Age: " << served.age
         << " | Order ID : " << served.orderID 
         << " | Pizza: " << served.pizzaName
         << " | Quantity: " << served.quantity
         << " | Bill: " << served.bill << endl;

    // storing to AVL and file
    string customerType = "Take-Away";
    bool ht_inc = false;
    root=insertAVL(served,customerType,root,&ht_inc);
    writeOrderToFile(served, "served.txt", customerType);
}




void serveDineInOrder() {
    if (dineInQueue == NULL) {
        cout << "No dine-in customers to serve!" << endl;
        return;
    }

    Node* servedNode = dineInQueue;
    customer served = servedNode->c;

    dineInQueue = dineInQueue->next;

    if (dineInQueue == NULL) {
        currentOrder = NULL;
    }

    cout << "Dine-in customer served: " << served.name
         << " | Age: " << served.age
         << " | Order ID : " << served.orderID 
         << " | Pizza: " << served.pizzaName
         << " | Quantity: " << served.quantity
         << " | Bill: " << served.bill << endl;


// storing in AVL and file
    string customerType = "Dine-In";
    bool ht_inc = false;
    root=insertAVL(served,customerType,root,&ht_inc); 
    writeOrderToFile(served, "served.txt", customerType);

    delete servedNode;
}




void serveHomeOrder() {
    if (home == NULL) {
        cout << "No Home Delivery Customer to Serve!" << endl;
        return;
    }

    HomeDeliveryNode* tmp = home;
    customer served = tmp->c;

    home = home->next;

    cout << "Home Delivery Customer served: " << served.name
         << " | Age: " << served.age
         << " | Order ID : " << served.orderID
         << " | Pizza: " << served.pizzaName
         << " | Quantity: " << served.quantity
         << " | Bill: " << served.bill << endl;


// storing in AVL and file
    string customerType = "Home-Delivery Customer";
    bool ht_inc = false;
    root=insertAVL(served,customerType,root,&ht_inc);
    writeOrderToFile(served, "served.txt", customerType);

    delete tmp;
}


void serveAllOrders() {
    //Takeaway
    while (size > 0) {
        serveTakeAway();
    }

    //Dine-In
    while (dineInQueue != NULL) {
        serveDineInOrder();
    }

    //Home Delivery
    while (home != NULL) {
        serveHomeOrder();
    }
}







//-----------------------------------------------------------Display Orders----------------------------------------------------------------

void displayTakeAwayOrders() {
    if (head == NULL) {
        cout << "There is no Order for Walking Customer till yet" << endl;
        return;
    }

    Node* temp = head;
    int count = 1;

    while (temp != NULL) {
        cout << "-----------------------------------------------------" << endl;
        cout << "Take-Away Customer " << count++ << " : " << temp->c.name << endl;
        cout << "Age : " << temp->c.age << endl;
        cout << "Order ID : " << temp->c.orderID << endl;
        cout << "Pizza Name : " << temp->c.pizzaName << endl;
        cout << "Quantity : " << temp->c.quantity << endl;
        cout << "Bill : " << temp->c.bill << " RS/_" << endl;
        cout << "-----------------------------------------------------" << endl;

        temp = temp->next;
    }
}



void displayDineInOrders() {
	int count = 1;
	
    if (dineInQueue == NULL) {
        cout << "There is no Order for Dine-In Customer till yet" << endl;
    } 
	else {
        Node* traversal = dineInQueue;
        while (traversal != NULL) {
            cout << "-----------------------------------------------------" << endl;
            cout << "Dine-In Customer " << count++ << " : " << traversal->c.name << endl;
            cout << "Age : " << traversal->c.age << endl;
            cout << "Order ID : " << traversal->c.orderID << endl;
            cout << "Pizza Name : " << traversal->c.pizzaName << endl;
            cout << "Quantity : " << traversal->c.quantity << endl;
            cout << "Bill : " << traversal->c.bill << " RS/_" << endl;
            cout << "-----------------------------------------------------" << endl;
            traversal = traversal->next;
        }
    }
}



void displayHomeOrders() {
    if (home == NULL) {
        cout << "There is no Order for Home Delivery Customer till yet" << endl;
        return;
    }

    HomeDeliveryNode* traversal = home;
    int count=1;
    while (traversal != NULL) {
        cout << "-----------------------------------------------------" << endl;
        cout << "Home Delivery Customer "<< count++ << " : " << traversal->c.name << endl;
        cout << "Age : " << traversal->c.age << endl;
        cout << "Order ID : " << traversal->c.orderID << endl;
        cout << "Pizza Name : " << traversal->c.pizzaName << endl;
        cout << "Quantity : " << traversal->c.quantity << endl;
        cout << "Delivery Distance : " << traversal->distanceFromShop << "KM" << endl;
        cout << "Delivery Charges : " << traversal->deliveryCharges << endl;
        cout << "Bill : " << traversal->c.bill << " RS/_" << endl;
        cout << "Delivery Address : " << traversal->address << endl;
        cout << "-----------------------------------------------------" << endl;
        traversal = traversal->next;
    }
}



void displayAllOrders() {
    cout << "The Take-Away Customers Are :" << endl;
    displayTakeAwayOrders();
    cout << "The Dine-IN Customers Are :" << endl;
    displayDineInOrders();
    cout << "The Home Delivery Customers Are :" << endl;
    displayHomeOrders();
}





//----------------------------------------------------Pending Orders Bill-------------------------------------------------------------------

void totalbillofPendingOrders() {
    takeAway = 0;
    dineIn = 0;
    homeDelivery = 0;
    total=0;

    // Take-Away (Linked List Max Heap)
    Node* p = head;
    while (p != NULL) {
        takeAway += p->c.bill;
        p = p->next;
    }

    // Dine-In (Queue)
    Node* q = dineInQueue;
    while (q != NULL) {
        dineIn += q->c.bill;
        q = q->next;
    }

    // Home Delivery (Stack)
    HomeDeliveryNode* r = home;
    while (r != NULL) {
        homeDelivery += r->c.bill;
        r = r->next;
    }

    // Total
    total = takeAway + dineIn + homeDelivery;

    cout << "The total bill of pending orders for Take-Away customers are : " << takeAway << " RS/_" << endl;
    cout << "The total bill of pending orders for Dine-In customers are : " << dineIn << " RS/_" << endl;
    cout << "The total bill of pending orders for Delivery customers are : " << homeDelivery << " RS/_" << endl;
    cout << "The Total orders pending are : " << total << " RS/_" << endl;
}















//-------------------------------------------------File Handling-----------------------------------------------------------------------

void writeOrderToFile(const customer& c, const string& fileName, const string& customerType) {
    ofstream file(fileName.c_str(), ios::app); // append mode - using .c_str() for older compilers

    if (file.is_open()) {
        file << "Order ID: " << c.orderID << "\n";
        file << "Name: " << c.name << "\n";
        file << "Age: " << c.age << "\n";
        file << "Pizza: " << c.pizzaName << "\n";
        file << "Quantity: " << c.quantity << "\n";
        file << "Bill: " << c.bill << "\n";
        file << "Customer Type: " << customerType << "\n";
        file << "------------------------\n";
        file.close();
    } else {
        cout << "Unable to open file: " << fileName << endl;
    }
}

void readFromFile(const string& fileName) {
    ifstream file(fileName.c_str());  // using .c_str() for older compilers

    if (file.is_open()) {
        string line;
        bool empty = true;
        while (getline(file, line)) {
            cout << line << endl;
            empty = false;
        }
        if (empty)
            cout << "No data found in " << fileName << endl;
        file.close();
    } else {
        cout << "Unable to open file: " << fileName << endl;
    }
}

void clearFile(const string& fileName) {
    ofstream file(fileName.c_str(), ios::trunc);  // using .c_str() for older compilers
    if (file.is_open()) {
        file.close();
        cout << fileName << " has been cleared successfully.\n";
    } else {
        cout << "Unable to open file: " << fileName << endl;
    }
}