hw

//HW3
//Due: 11:59PM, February 21 (Friday)

#include <iostream>
#include <list>
#include <map>
#include <string>
#include <tuple>

using namespace std;

class course {
public:
    string name;
    int section;
    int credits;
    string grade;
    course() {}
    course(string n, int s, int c, string g) { name = n; section = s; credits = c; grade = g; }
    bool operator==(const course& cx) {
        return cx.name == name;
    }
    bool operator<(const course& cx) {
        return cx.grade < grade;
    }

    int operator+(int x) {
        return credits + x;
    }

    //You might need to implement some overloaded operators here.

};
ostream& operator<< (ostream& str, const course c) { //each ostream (output stream) is a device you can send data to, reference->so not making copy, gets the buffer and prints it
    str << c.name << " " << c.section << " " << c.credits << " " << c.grade;
    return str;
}
//Implement the following functions.
//When adding a student, if the student is already in DB, then ignore the operation.
//When adding a course, if the course is already in DB, then ignore the operation.
//When dropping a course, if the course does not exist, then ignore the operation.
//When removing a student, if the student does not exist, then ignore the operation.
//All courses in a semester need to be sorted.
//When dropping or adding a course, overall GPA, semester GPA, overall credits and semester credits all need to be updated.

//Semeser numbers:  Spring 2019: 20191; Fall 2019: 20192, etc.
ostream& operator<<(ostream& str, const map<int, tuple<int, float, list<course*>*> >& semester) {
    for (auto i : semester) {

    }
}

ostream& operator<<(ostream& str, const list<course*>* classes) {

    /*for (auto i : classes) {
        str << i
    }*/
}

void add_student(map<int, tuple<int, float, map<int, tuple<int, float, list<course*>*> >*>*>& DB, int id);
void remove_student(map<int, tuple<int, float, map<int, tuple<int, float, list<course*>*> >*>*>& DB, int id);
void add_course(map<int, tuple<int, float, map<int, tuple<int, float, list<course*>*> >*>*>& DB, int semester, int id, course c); //20171 Spring semester of 2017; 20172: Fall semester of 2017
                                                                //All courses in the list should be sorted according to name (increasing order)
void drop_course(map<int, tuple<int, float, map<int, tuple<int, float, list<course*>*> >*>*>& DB, int semester, int id, course c);
void print_student_semester_courses(map<int, tuple<int, float, map<int, tuple<int, float, list<course*>*> >*>*>& DB, int semester, int id);
void print_student_all_courses(map<int, tuple<int, float, map<int, tuple<int, float, list<course*>*> >*>*>& DB, int id);

//Implement additional functions such that you can do
//cout << DB << endl;

//You might need to implement some overloaded operators in the course class.



int main() {
    map<int, tuple<int, float, map<int, tuple<int, float, list<course*>*> >*>*>  DB;

    add_student(DB, 11111);
    course C1("CIS554", 1, 3, "A-"), C2("CSE674", 1, 3, "B+"), C3("MAT296", 8, 4, "A"), C4("WRT205", 5, 3, "A");

    add_course(DB, 20171, 11111, C1);
    add_course(DB, 20171, 11111, C4);
    add_course(DB, 20171, 11111, C3);
    add_course(DB, 20171, 11111, C2);
    print_student_semester_courses(DB, 20171, 11111);

    drop_course(DB, 20171, 11111, C1);
    print_student_semester_courses(DB, 20171, 11111); //sorted according to course name

    course C5("CIS351", 2, 3, "A-"), C6("PSY205", 5, 3, "B+"), C7("MAT331", 2, 3, "A"), C8("ECN203", 4, 3, "A");
    add_course(DB, 20172, 11111, C5);
    add_course(DB, 20172, 11111, C6);
    add_course(DB, 20172, 11111, C7);
    add_course(DB, 20172, 11111, C8);
    add_course(DB, 20172, 11111, C3);
    print_student_all_courses(DB, 11111);//ID GPA

    add_student(DB, 11112);
    add_course(DB, 20171, 11112, C2);
    add_course(DB, 20171, 11112, C5);
    add_course(DB, 20171, 11112, C7);
    add_course(DB, 20171, 11112, C4);
    print_student_semester_courses(DB, 20171, 11112);

    add_course(DB, 20172, 11112, C8);
    add_course(DB, 20172, 11112, C3);
    add_course(DB, 20172, 11112, C5);
    add_course(DB, 20172, 11112, C1);
    print_student_semester_courses(DB, 20172, 11112);

    print_student_all_courses(DB, 11112);

    //cout << DB << endl;
    remove_student(DB, 11111);
    //cout << DB << endl;
    getchar();
    getchar();
    return 0;
}
//map<int, tuple<int, float, map<int, tuple<int, float, list<course*>*> >*>*>
//
void add_student(map<int, tuple<int, float, map<int, tuple<int, float, list<course*>*> >*>*>& DB, int id) {
    if (DB.find(id) != DB.end())return;
    tuple<int, float, map<int, tuple<int, float, list<course*>*> >*>* overall = new tuple<int, float, map<int, tuple<int, float, list<course*>*> >*>;
    map<int, tuple<int, float, list<course*>*>>* semesterCollection = new map<int, tuple<int, float, list<course*>*>>;
    get<2>(*overall) = semesterCollection;
    DB[id] = overall;
}
void remove_student(map<int, tuple<int, float, map<int, tuple<int, float, list<course*>*> >*>*>& DB, int id) {
    if (DB.find(id) != DB.end()) {
        auto overall_Tuple = DB[id]; //first tuple
        auto mapSemester_Map = *get<2>(*overall_Tuple); //second map

        if (mapSemester_Map.size() != 0) { //checks if semester isnt empty
            for (auto i = mapSemester_Map.begin(); i != mapSemester_Map.end(); ++i) {
                auto mapSemester_Tuple = i->second;//inner mapsemester_tuple
                auto courseList = *get<2>(mapSemester_Tuple);

                if (courseList.size() != 0) {//searching the courselist, if found
                    for (auto i : courseList)delete i;
                }
                delete& courseList;
            }
            for (auto i = mapSemester_Map.begin(); i != mapSemester_Map.end(); ++i)delete& i;
        }
        delete& mapSemester_Map;
        delete overall_Tuple;
        DB.erase(id);

    }return;
}

void add_course(map<int, tuple<int, float, map<int, tuple<int, float, list<course*>*> >*>*>& DB, int semester, int id, course c) {
    if (DB.find(id) != DB.end()) {
        auto overall_Tuple = DB[id]; //first tuple
        auto mapSemester_Map = *get<2>(*overall_Tuple); //pointer to second map

        if (mapSemester_Map.find(semester) == mapSemester_Map.end()) { //checks if the semester is already there in the tuple

            tuple<int, float, list<course*>*> semesterTuple; //semestertuple of 2nd map
            mapSemester_Map[semester] = semesterTuple;//setting 20191 value to semestertuple
            auto classes = get<2>(semesterTuple); //list of classes of the semester tuple
            list<course*>* courseList = new list<course*>;
            courseList->push_back(new course(c));
            auto credits = 0;
            auto grade = 0.00;
            map<string, float> gradingScale{ {"A", 4.00}, {"A-", 3.75}, {"B+", 3.33}, {"B", 3.00}, {"B-", 2.67}, {"C+", 2.33},
            {"C", 2.00}, {"C-", 1.67}, {"D+", 1.33}, {"D", 1.00} };
            for (auto i = courseList->begin(); i != courseList->end(); ++i) {
                credits = **i + credits;
                grade += ((gradingScale[(*i)->grade]) * (*i)->credits);
            }
            //can only assign address to pointers
            //auto &p1 = get<2>((*get<2>(*DB[id]))[semester]);
            get<0>(semesterTuple) = credits;
            get<1>(semesterTuple) = grade / credits;
        }
        else {

            auto innerTuple = mapSemester_Map[semester]; //returns a tuple
            auto& courseList = *get<2>(innerTuple);//returns a tuple of sem creds and gpa
            for (auto i = courseList.begin(); i != courseList.end(); ++i) {
                if (**i == c)return;
            }
            courseList.push_back(new course(c));
            auto credits = 0;
            auto grade =  0.00;
            map<string, float> gradingScale{ {"A", 4.00}, {"A-", 3.75}, {"B+", 3.33}, {"B", 3.00}, {"B-", 2.67}, {"C+", 2.33},
            {"C", 2.00}, {"C-", 1.67}, {"D+", 1.33}, {"D", 1.00} };
            for (auto i = courseList.begin(); i != courseList.end(); ++i) {
                credits = **i + credits;
                grade += ((gradingScale[(**i).grade]) * (**i).credits);
            }
            //can only assign address to pointers
            //auto &p1 = get<2>((*get<2>(*DB[id]))[semester]);
            get<0>(innerTuple) = credits;
            get<1>(innerTuple) = grade / credits;
        }
        //FOR GPA and Creds get<0>(*DB[id]) = 0; get<1>(*DB[id]) = 0.0; creds, gpa respectively
    }return;
    //comparator sort overload the course
}

void drop_course(map<int, tuple<int, float, map<int, tuple<int, float, list<course*>*> >*>*>& DB, int semester, int id, course c) {
    if (DB.find(id) != DB.end()) {
        auto overall_Tuple = DB[id]; //first tuple
        auto mapSemester_Map = *get<2>(*overall_Tuple); //second map

        if (mapSemester_Map.find(semester) != mapSemester_Map.end()) { //checks if the semester is found

            auto mapSemester_Tuple = mapSemester_Map[semester];
            auto courseList = *get<2>(mapSemester_Tuple);
            auto credits = 0;
            auto grade = 0.00;
            for (auto i = courseList.begin(); i != courseList.end(); ++i) {
                if (**i == c)courseList.remove(*i);
                credits = **i + credits;
            }
            auto tupleCreds = mapSemester_Map[semester];
            get<0>(tupleCreds) = credits;
            get<1>(tupleCreds) = grade / credits;
        }
    }return;
}

void print_student_semester_courses(map<int, tuple<int, float, map<int, tuple<int, float, list<course*>*> >*>*>& DB, int semester, int id) {
    if (DB.find(id) != DB.end()) {
        auto overall_Tuple = DB[id];
        auto mapSemester_Map = *get<2>(*overall_Tuple);

        if (mapSemester_Map.find(semester) != mapSemester_Map.end()) {
            auto currentSemester = mapSemester_Map[semester];
            auto courseList = get<2>(currentSemester);
            auto gpa = get<0>(currentSemester);
            auto credits = get<1>(currentSemester);
            cout << "ID: " << id << endl;
            cout << "Semester: " << semester << endl;
            cout << "GPA: " << gpa << endl;
            //cout << "Credits: " << credits << endl;
            auto i = 0;
            for (auto i = courseList.begin(); i != courseList.end(); ++i)cout << courseList[i] << endl;
        }

    }
}
void print_student_all_courses(map<int, tuple<int, float, map<int, tuple<int, float, list<course*>*> >*>*>& DB, int id) {
    if (DB.find(id) != DB.end()) {
        auto overall_Tuple = DB[id];
        auto mapSemester_Map = *get<2>(*overall_Tuple);
        //print overall gpa
        //print overall credits
        cout << "DB: " << endl;
        cout << "Overall Credits: " << endl;
        int credits = 0;
        auto i = 0;
        while (i != mapSemester_Map.size()) {
            auto eachCredits = get<0>(mapSemester_Map[i]);
            credits = credits + eachCredits;
            ++i;
        }
        cout << "Overall GPA: " << endl;


        for (auto i : mapSemester_Map) {
            print_student_semester_courses(DB, i.first, id);
        }
        //print each semester
        //for (auto i = mapSemester_Map.begin(); i != mapSemester_Map->end(); ++i) {
            //mapSemester_Map.

        //}
    }
}