server.cpp

#include "restaurant.hpp"

Restaurant::Restaurant(string nameR , string districtR , string foodsDetail , int openingTimeR , int closingTimeR , int numberOfTablesR){
    name = nameR;
    district = districtR;
    AddToFoodMenu(foodsDetail);
    openingTime = openingTimeR;
    closingTime = closingTimeR;
    numberOfTables = numberOfTablesR;
    MakeTableDetail();
}

void Restaurant::MakeTableDetail(){
    for(int i = 1 ; i <= numberOfTables ; i++)
    {
        RestaurantTable* newTable = new RestaurantTable;
        newTable->numberOfTable = i;
        tables.push_back(newTable);
    }
}

string Restaurant::DistrictGeter(){
    return district;
}

bool Restaurant::FoodCheker(string foodN){
    for(auto food : foodsMenu){
        if(food->name == foodN){
            return true;
        }
    }
    return false;
}

void Restaurant::PrintBaseDetail(){
    cout << name << SPACE << PARENTHESE_1 << district << PARENTHESE_2 << endl;
}

int Restaurant::reserveIDGeter(){
    return reserveIdNumber;
}

void Restaurant::AddReserve(ReserveMethod* newReserve){
    tables[(newReserve->table) - 1]->reserves.push_back(newReserve);
    reserveIdNumber++;
}

bool Restaurant::ReserveIdCheker(int reserveID){
    for(auto table : tables)
    {
        for(auto reserve : table->reserves)
        {
            if(reserve->reserveID == reserveID){
                return true;
            }
        }
    }
    return false;
}

void Restaurant::DeleteReserve(ReserveMethod* deleteReserve){
    int i = 0;
    for(auto reserve : tables[deleteReserve->table - 1]->reserves)
    {
        if(reserve->reserveID == deleteReserve->reserveID && reserve->resturantName == deleteReserve->resturantName){
            tables[deleteReserve->table - 1]->reserves.erase(tables[deleteReserve->table - 1]->reserves.begin() + i);
            throw (OK_MESSAGE);
        }
        i++;
    }
}

vector<int> Restaurant::FoodCalculator(vector<string> foods){
    vector<int> price(2);
    for(auto food : foods)
    {
        for(auto foodMenu : foodsMenu)
        {
            if(food == foodMenu->name)
            {
                if(foodMenu->foodDiscount != NULL){
                    cout << foodMenu->foodDiscount->DiscountValueGeter() << endl;
                    price[1] += foodMenu->foodDiscount->DiscountValueGeter();
                    
                }
                price[0] += stoi(foodMenu->price);
            }
        }
    }
    return price;
}

int Restaurant::TotalPriceDiscountCalculator(int price){
    int discount = 0;
    if(totalPriceDiscount == NULL){
        return discount;
    }
    if(price >= minimumPriceForDiscount){
        discount = totalPriceDiscount->discountCalculator(price);
    }
    return discount;
}

int Restaurant::FirstOrderDiscountCalculator(int price , string userName){
    int discount = 0;
    if(firstOrderDiscount == NULL){
        return discount;
    }
    for(auto user : userUserFirstOrderDiscount){
        if(user == userName){
            return discount;
        }
    }
    discount = firstOrderDiscount->discountCalculator(price);
    return discount;
}

void Restaurant::ReserveCheker(string userName , string &tableID , string &startTime , string &endTime , vector<string> &foods){
    int startT = stoi(startTime) , endT = stoi(endTime);
    if(tables.size() < stoi(tableID)){
        throw (NOT_FOUND_MESSAGE);}
    for(auto reserve : tables[stoi(tableID) - 1]->reserves)
    {
        if((startT > reserve->startingTime && startT < reserve->endingTime) || (endT > reserve->startingTime && endT < reserve->endingTime)){
            throw (PERMISSION_DENIED_MESSAGE);}
    }
    if(startT < openingTime || endT > closingTime){
    throw (PERMISSION_DENIED_MESSAGE);}
    bool foodSituation = false;
    for(auto foodReserve : foods)
    {
        for(auto food : foodsMenu)
        {
            if(foodReserve == food->name)
            {
                foodSituation = true;
            }
        }
        if(foodSituation == false){
            throw (NOT_FOUND_MESSAGE);}
        foodSituation = false;
    }
}

void Restaurant::AddToFoodMenu(string foodsDetail){
    stringstream foodsDetailNote(foodsDetail);
    string foodDetail;
    while(getline(foodsDetailNote , foodDetail , ';'))
    {
        Food* newFood = new Food;
        stringstream foodDetailNote(foodDetail);
        getline(foodDetailNote , newFood->name , ':');
        getline(foodDetailNote , newFood->price);
        foodsMenu.push_back(newFood);
    }
}

string Restaurant::NameGeter(){
    return name;
}

void Restaurant::RestaurantDetail(){
    int number = 1;
    cout << NAME << name << endl;
    cout << DISTRICT << district << endl;
    cout << TIME << openingTime << MINUS << closingTime << endl;
    cout << MENU ;
    PrintFoodMenu();
    for(auto table : tables)
    {
        cout << number << COLON;
        PrintTableDetail(number);
        number++;
    }
    PrintDiscountDetail();
}

void Restaurant::PrintDiscountDetail(){
    if(totalPriceDiscount != NULL){
        cout << ORDER_AMOUNT_NOTE << totalPriceDiscount->TypeGeter() << COMMA << SPACE << minimumPriceForDiscount << COMMA << SPACE << totalPriceDiscount->DiscountValueGeter() << endl;
    }
    if(FoodDiscountCheker()){
        cout << ITEM_SPECIFIC_NOTE ;
        int i = 0;
        for(auto food : foodsMenu){
            if((food->foodDiscount != NULL) && (i == 0)){
                cout << SPACE << food->name << PARENTHESE_1 << food->foodDiscount->TypeGeter() << COLON << SPACE << food->foodDiscount->DiscountValueGeter() << PARENTHESE_2;
                i++;
            }           
            else if(food->foodDiscount != NULL){
                cout << COMMA << SPACE << food->name << PARENTHESE_1 << food->foodDiscount->TypeGeter() << COLON << SPACE << food->foodDiscount->DiscountValueGeter() << PARENTHESE_2;
            }
        }
        cout << endl;
    }
    if(firstOrderDiscount != NULL){
        cout << FIRST_ORDER_NOTE << firstOrderDiscount->TypeGeter() << COMMA << SPACE << firstOrderDiscount->DiscountValueGeter() << endl;
    }
}

bool Restaurant::FoodDiscountCheker(){
    for(auto food : foodsMenu){
        if(food->foodDiscount != NULL){
            return true;
        }
    }
    return false;
}

void Restaurant::PrintFoodMenu(){
    int number = 0;
    vector<Food*> foodsMenuSort = foodsMenu;
    sort(foodsMenuSort.begin(), foodsMenuSort.end(), [](const Food* d1, const Food* d2) { return d1->name < d2->name; });
    for(auto foodMenuSort : foodsMenuSort)
    {
        if(number == (foodsMenu.size() - 1)){
            cout << SPACE <<  foodMenuSort->name << PARENTHESE_1 << foodMenuSort->price << PARENTHESE_2 << endl ;
        }
        else{
        cout << SPACE <<  foodMenuSort->name << PARENTHESE_1 << foodMenuSort->price << PARENTHESE_2 << COMMA ;
        }
        number++;
    }
}

void Restaurant::PrintTableDetail(int numberTable){
    int number = 0;
    numberOfTables--;
    if(tables[numberOfTables]->reserves.size() == 0){
        cout << endl;
    }
    else{
        sort(tables[numberOfTables]->reserves.begin(), tables[numberOfTables]->reserves.end(), [](const ReserveMethod* r1, const ReserveMethod* r2) { return r1->startingTime < r2->startingTime; });
        for(auto reserve : tables[numberOfTables]->reserves)
        {
            if(number ==  tables[numberOfTables]->reserves.size() - 1){
                cout << SPACE << PARENTHESE_1 << reserve->startingTime << MINUS << reserve->endingTime << PARENTHESE_2 << endl;
            }
            else{
            cout << SPACE << PARENTHESE_1 << reserve->startingTime << MINUS << reserve->endingTime << PARENTHESE_2 << COMMA;
            }
            number++;
        }
    }
}

void Restaurant::DiscountLineReader(string discountLine){
    stringstream discountLineNote(discountLine);
    string totalPriceDiscountLine , firstOrderDiscountLine , foodDiscountLine;
    getline(discountLineNote , totalPriceDiscountLine , COMMA);
    getline(discountLineNote , firstOrderDiscountLine , COMMA);
    getline(discountLineNote , foodDiscountLine , COMMA);
    if(totalPriceDiscountLine != NONE){
        TotalPriceDiscountLineReader(totalPriceDiscountLine);}
    if(firstOrderDiscountLine != NONE){
        FirstOrderDiscountLineReader(firstOrderDiscountLine);}
    if(foodDiscountLine != NONE){
        FoodDiscountLineReader(foodDiscountLine);}
}

void Restaurant::TotalPriceDiscountLineReader(string totalPriceDiscountLine){
    string type , minimume , value;
    stringstream totalPriceDiscountLineNote(totalPriceDiscountLine);
    getline(totalPriceDiscountLineNote , type , SEMICOLON);
    getline(totalPriceDiscountLineNote , minimume , SEMICOLON);
    getline(totalPriceDiscountLineNote , value , SEMICOLON);
    minimumPriceForDiscount = stoi(minimume);
    if(type == PERCENT){
        Percent* totalDiscountType = new Percent(stoi(value));
        totalPriceDiscount = totalDiscountType;
    }
    else if(type == AMOUNT){
        Amount* totalDiscountType = new Amount(stoi(value));
        totalPriceDiscount = totalDiscountType;
    }
}

void Restaurant::FirstOrderDiscountLineReader(string firstOrederDiscountLine){
    string type , value;
    stringstream firstOrederDiscountLineNote(firstOrederDiscountLine);
    getline(firstOrederDiscountLineNote , type , SEMICOLON);
    getline(firstOrederDiscountLineNote , value , SEMICOLON);
    if(type == PERCENT){
        Percent* firstOrderDiscountType = new Percent(stoi(value));
        firstOrderDiscount = firstOrderDiscountType;
    }
    else if(type == AMOUNT){
        Amount* firstOrderDiscountType = new Amount(stoi(value));
        firstOrderDiscount = firstOrderDiscountType;
    }    
}

void Restaurant::FoodDiscountLineReader(string foodDiscountLine){
    string foodLine;
    stringstream foodDiscountLineNote(foodDiscountLine);
    while(getline(foodDiscountLineNote , foodLine , VERTICAL_BAR)){
        EachFoodLineDiscountReader(foodLine);
    }
}

void Restaurant::EachFoodLineDiscountReader(string foodLine){
    string type , foodName , value;
    stringstream foodLineNote(foodLine);
    getline(foodLineNote , type , SEMICOLON);
    getline(foodLineNote , foodName , COLON);
    getline(foodLineNote , value);
    for(auto food : foodsMenu){
        if(food->name == foodName){
            if(type == PERCENT){
                Percent* foodDiscountType = new Percent(stoi(value));
                food->foodDiscount = foodDiscountType;
            }
            else if(type == AMOUNT){
                Amount* foodDiscountType = new Amount(stoi(value));
                food->foodDiscount = foodDiscountType;
            }       
        }
    }
}