midterm.cpp

// File: midterm.cpp
// Console Gradebook with View, Add, Remove, Edit, and Student Averages

#include <bits/stdc++.h> //
using namespace std; // Standard library

// ------------------- DATA STRUCTURES -------------------
struct Record {             // Student Record Structure
    string firstName;       // Desclares first name string
    string lastName;        // Desclares last name string
    string assignment;      // Desclares assignment string
    int grade;              // Desclares grade integer
};

string to_lower_str(const string &s) {  // Convert string to lowercase
    string out = s;
    transform(out.begin(), out.end(), out.begin(),
              [](unsigned char c){ return std::tolower(c); });
    return out;                         // Return lowercase string
}

void pause_enter() {                    // Waits for user to interact
    cout << "\nPress Enter to continue...";
    string tmp;
    getline(cin, tmp);
}
// -------------------------------------------------


// ------------------- MAIN MENU -------------------
void show_main_menu() {                 // Simple welcome menu
    cout << "────── ⋆⋅☆⋅⋆ ──────\n";
    cout << "     Welcome!\n";
    cout << "a. View Gradebook\n";
    cout << "b. Edit Gradebook\n";
    cout << "c. Save Data and Close\n";
    cout << "Choose an option: ";
}
// -------------------------------------------------

// ----------------- VIEW FUNCTIONS -----------------

void show_full_gradebook(const vector<Record>& book) {
    cout << "\n # |     Name     | Assignment     | Grade\n";
    cout << "-------------------------------------------\n";

    if (book.empty()) {                             // If there's no Gradebook file
        cout << "There are no records yet!\n\n";
        while (true) {
            cout << "a. Go Back\n";
            cout << "Choose an option: ";
            string choice;
            if (!getline(cin, choice)) return;
            choice = to_lower_str(choice);
            if (!choice.empty() && choice[0] == 'a')// Checks for 'a' input
                return;                             // Goes back to menu
            cout << "Invalid choice. Please enter 'a' to go back.\n";
        }
    } else {
        int i = 1;
        for (const auto& r : book) {
            string fullName = r.firstName + " " + r.lastName;
            cout << setw(2) << i << " | "
                 << left << setw(13) << fullName << " | "
                 << left << setw(14) << r.assignment << " | "
                 << right << setw(5) << r.grade << "\n";
            ++i;
        }
        cout << "\n";
        pause_enter(); // Waits for user to interact
    }
}
// -------------------------------------------------

// ------------------- STUDENT AVERAGES -------------------
void show_student_averages(const vector<Record>& book) { // Displays the average grade for each student in the gradebook
    if (book.empty()) {
        cout << "\nThere are no records yet!\n\n";
        pause_enter();  // Waits for user to interact
        return;         // Goes back to menu
    }

    // Map each student to their list of grades
    map<string, vector<int>> studentGrades;
    for (const auto& r : book) {
        string fullName = r.lastName + ", " + r.firstName; // What the fuck am I doing
        studentGrades[fullName].push_back(r.grade);
    }

    // Calculate average of each student
    vector<pair<string, double>> averages;
    for (const auto& [name, grades] : studentGrades) {
        double sum = accumulate(grades.begin(), grades.end(), 0.0);
        double avg = sum / grades.size();
        averages.push_back({name, avg});
    }

    sort(averages.begin(), averages.end(),
         [](auto &a, auto &b){ return a.first < b.first; });

    // Header
    cout << "\n # | Name                | Grade Average\n";
    cout << "-------------------------------------------\n";

    // Print each student average
    int i = 1;
    for (const auto& [name, avg] : averages) {
        cout << setw(2) << i << " | "
             << left << setw(22) << name << " | "
             << right << fixed << setprecision(2) << avg << "\n";
        ++i;
    }

    cout << "\n";
    pause_enter(); // Wait for user to interact
}

// ------------------- VIEW MENU -------------------
void view_gradebook(const vector<Record>& book) {
    while (true) {
        cout << "\nView Menu:\n";
        cout << "a. View Gradebook\n";
        cout << "b. View Student Averages\n";
        cout << "c. Search Student\n";
        cout << "d. Go Back\n";
        cout << "Choose an option: ";

        string choice;
        if (!getline(cin, choice)) return;
        choice = to_lower_str(choice);
        if (choice.empty()) continue;

        if (choice[0] == 'a') {
            // --- Regular Gradebook View ---
            cout << "\n # |     Name     | Assignment     | Grade\n";
            cout << "-------------------------------------------\n";

            if (book.empty()) {
                cout << "There are no records yet!\n\n";
                while (true) {
                    cout << "a. Go Back\n";
                    cout << "Choose an option: ";
                    string ch;
                    if (!getline(cin, ch)) return;
                    ch = to_lower_str(ch);
                    if (!ch.empty() && ch[0] == 'a')
                        break;
                    cout << "Invalid choice. Please enter 'a' to go back.\n";
                }
            } else {
                int i = 1;
                for (const auto& r : book) {
                    string fullName = r.firstName + " " + r.lastName;
                    cout << setw(2) << i << " | "
                         << left << setw(13) << fullName << " | "
                         << left << setw(14) << r.assignment << " | "
                         << right << setw(5) << r.grade << "\n";
                    ++i;
                }
                cout << "\n";
                pause_enter();
            } // ----------------------
        }

        else if (choice[0] == 'b') {
            // --- Student Averages ---
            if (book.empty()) {
                cout << "\nThere are no records yet!\n";
                pause_enter();
                continue;
            }

            map<string, pair<int, int>> avgMap; // key=name, val={sum, count}
            for (const auto& r : book) {
                string full = r.lastName + ", " + r.firstName;
                avgMap[full].first += r.grade;
                avgMap[full].second += 1;
            }

            // Header
            cout << "\n # |         Name         |  Grade Average\n";
            cout << "-----------------------------------------\n";
            int i = 1;
            for (auto& [name, data] : avgMap) {
                double avg = static_cast<double>(data.first) / data.second;
                cout << setw(2) << i << " | "
                     << left << setw(20) << name << " | "
                     << fixed << setprecision(2) << avg << "\n";
                i++;
            }
            pause_enter(); // Wait for user to interact
        }
        else if (choice[0] == 'c') {

            // --- Search Student ---
            if (book.empty()) {
            cout << "\nThere are no records yet!\n";
            pause_enter();
            continue;
            }

            // Collect unique names (case-insensitive)
            map<string, string> nameMap; // lower->display
            for (const auto& r : book) {
                string key = to_lower_str(r.lastName + ", " + r.firstName);
                string display = r.lastName + ", " + r.firstName;
                nameMap[key] = display;
            }

            vector<string> sortedNames;
            for (auto& [k, v] : nameMap)
                sortedNames.push_back(v);

            cout << "\n # | Name\n";
            cout << "----------------\n";
            for (int i = 0; i < (int)sortedNames.size(); ++i) {
                cout << setw(2) << i + 1 << " | " << sortedNames[i] << "\n";
            }

            cout << "\nSearch for a student (type part of the name, or #): ";
            string query;
            getline(cin, query);
            query = to_lower_str(query);

            vector<string> matches;

            // If user entered a number, use that directly
            if (!query.empty() && isdigit(query[0])) {
                int num = stoi(query);
                if (num >= 1 && num <= (int)sortedNames.size())
                    matches.push_back(sortedNames[num - 1]);
            } else {
                // Otherwise, find partial matches
                for (const auto& name : sortedNames) {
                    if (to_lower_str(name).find(query) != string::npos)
                        matches.push_back(name);
                }
            }

            if (matches.empty()) {
                cout << "\nNo matching students found.\n";
                pause_enter();
                continue;
            }

            // If more than one match, list them
            if (matches.size() > 1) {
                cout << "\nMatching Students:\n";
                for (int i = 0; i < (int)matches.size(); ++i) {
                    cout << setw(2) << i + 1 << " | " << matches[i] << "\n";
                }
                cout << "\nType full name or # to view details: ";
                string sel;
                getline(cin, sel);
                sel = to_lower_str(sel);

                string chosen;
                if (!sel.empty() && isdigit(sel[0])) {
                    int num = stoi(sel);
                    if (num >= 1 && num <= (int)matches.size())
                        chosen = matches[num - 1];
                } else {
                    for (const auto& n : matches)
                        if (to_lower_str(n) == sel) chosen = n;
                }

                if (chosen.empty()) {
                    cout << "\nInvalid selection.\n";
                    pause_enter();
                    continue;
                }

                query = to_lower_str(chosen);
            } else {
                query = to_lower_str(matches[0]);
            }

            // Show details for the chosen student
            vector<Record> studentRecords;
            int total = 0;
            for (const auto& r : book) {
                string full = to_lower_str(r.lastName + ", " + r.firstName);
                if (full == query) {
                    studentRecords.push_back(r);
                    total += r.grade;
                }
            }

            cout << "\nStudent Name: " << nameMap[query] << "\n";
            if (!studentRecords.empty()) {
                double avg = (double)total / studentRecords.size();
                cout << "Average Grade: " << fixed << setprecision(2) << avg << "\n";
                cout << "\n # | Assignment | Grade\n";
                cout << "------------------------\n";
                for (int i = 0; i < (int)studentRecords.size(); ++i) {
                    cout << setw(2) << i + 1 << " | "
                        << left << setw(14) << studentRecords[i].assignment << " | "
                        << right << setw(3) << studentRecords[i].grade << "\n";
                }
            } else {
                cout << "No records found for this student.\n";
            }

            cout << "\na. Go Back\n";
            string back;
            while (true) {
                cout << "Choose an option: ";
                getline(cin, back);
                back = to_lower_str(back);
                if (!back.empty() && back[0] == 'a') break;
                cout << "Invalid input. Type 'a' to go back.\n";
            }
        }
        else if (choice[0] == 'd') {
            return;  // Go back to main menu
        }
        else {
            cout << "Invalid option. Please choose a, b, c, or d.\n";
        }

    }
}
// -------------------------------------------------

// ------------------- EDIT FUNCTIONS -------------------

void add_student(vector<Record>& book) {
    Record r;
    string gradeInput;

    cout << "\nStudent Name: ";
    getline(cin, r.firstName);

    cout << "Student Lastname: ";
    getline(cin, r.lastName);

    cout << "Assignment Name: ";
    getline(cin, r.assignment);

    while (true) {
        cout << "Student Grade: ";
        getline(cin, gradeInput);
        try {
            r.grade = stoi(gradeInput);
            if (r.grade < 0 || r.grade > 100)
                throw out_of_range("Grade out of range");
            break;
        } catch (...) {
            cout << "Invalid grade. Please enter a number between 0 and 100.\n";
        }
    }

    book.push_back(r);
    cout << "\nStudent added successfully!\n";
    pause_enter();
}

bool matches_query(const Record& r, const string& query) {
    string first = to_lower_str(r.firstName);
    string last = to_lower_str(r.lastName);
    string full = to_lower_str(r.firstName + " " + r.lastName);
    return first.find(query) != string::npos ||
           last.find(query) != string::npos ||
           full.find(query) != string::npos;
}

void remove_student(vector<Record>& book) {
    if (book.empty()) {
        cout << "\nThere are no students to remove.\n";
        pause_enter();
        return; // Go back
    }

    cout << "\nSearch a Student to Remove: ";
    string query;
    getline(cin, query);
    query = to_lower_str(query);

    vector<int> matches;
    for (int i = 0; i < (int)book.size(); ++i) {
        if (matches_query(book[i], query))
            matches.push_back(i);
    }

    if (matches.empty()) {
        cout << "\nNo matching students found.\n";
        pause_enter();
        return; // Go back
    }

    cout << "\n────── ⋆⋅☆⋅⋆ ──────\n";
    cout << "  Matching Students:\n";
    for (int i = 0; i < (int)matches.size(); ++i) {
        const auto& r = book[matches[i]];
        cout << " - " << r.firstName << " " << r.lastName << "\n";
    }

    while (true) {
        cout << "\nWhich student do you wish to remove? (Type their full name)\n";
        cout << "Type 'Menu' to cancel\n";
        cout << "Input: ";
        string input;
        getline(cin, input);

        if (input.empty()) continue;
        string lowerInput = to_lower_str(input);

        if (lowerInput == "menu") {
            cout << "\nReturning to main menu...\n";
            pause_enter();
            return; // Go back
        }

        bool found = false;
        for (auto it = book.begin(); it != book.end(); ++it) {
            string full = to_lower_str(it->firstName + " " + it->lastName);
            if (full == lowerInput) {
                book.erase(it);
                cout << "\nStudent Removed Successfully!\n";
                pause_enter();
                found = true;
                break;
            }
        }

        if (found)
            return;
        else
            cout << "No exact match found for that name. Try again.\n";
    }
}

// ------------------- NEW: EDIT STUDENT -------------------

void edit_student(vector<Record>& book) {
    if (book.empty()) {
        cout << "\nThere are no students to edit.\n";
        pause_enter();
        return; // Go back
    }

    // Build sorted list of unique names
    map<string, vector<int>> studentMap;
    for (int i = 0; i < (int)book.size(); ++i) {
        string full = book[i].lastName + ", " + book[i].firstName;
        studentMap[full].push_back(i);
    }

    vector<string> sortedNames;
    for (auto &p : studentMap)
        sortedNames.push_back(p.first);
    
    cout << "\n────── ⋆⋅☆⋅⋆ ──────\n";
    cout << "Students:\n";
    int idx = 1;
    for (auto &n : sortedNames)
        cout << setw(2) << idx++ << ". " << n << "\n";
    
    cout << "\n────── ⋆⋅☆⋅⋆ ──────\n";
    cout << "What student do you wish to edit? (Type full name or #): ";
    string input;
    getline(cin, input);
    input = to_lower_str(input);

    int chosenIndex = -1;

    // Check if numeric
    if (!input.empty() && isdigit(input[0])) {
        try {
            int num = stoi(input);
            if (num >= 1 && num <= (int)sortedNames.size()) {
                string chosenName = sortedNames[num - 1];
                chosenIndex = studentMap[chosenName][0]; // edit first record
            }
        } catch (...) {}
    } else {
        // Match by full name
        for (auto &p : studentMap) {
            if (to_lower_str(p.first) == input) {
                chosenIndex = p.second[0];
                break;
            }
        }
    }

    if (chosenIndex == -1) {
        cout << "\nNo matching student found.\n";
        pause_enter();
        return; // Go back
    }

    // Show student's record
    Record &r = book[chosenIndex];
    cout << "\nStudent Record:\n";
    cout << " # |     Name     | Assignment     | Grade\n";
    cout << "-------------------------------------------\n";
    cout << " 1 | " << left << setw(13) << (r.firstName + " " + r.lastName)
         << " | " << left << setw(14) << r.assignment
         << " | " << right << setw(5) << r.grade << "\n";

    cout << "\nEnter the line number you want to edit (1): ";
    string lineInput;
    getline(cin, lineInput); // (for future multi-line support)
    cout << "\n";

    while (true) {
        cout << "────── ⋆⋅☆⋅⋆ ──────\n";
        cout << "a. Change Name\n";
        cout << "b. Change Assignment\n";
        cout << "c. Change Grade\n";
        cout << "d. Done\n";
        cout << "Choose an option: ";

        string choice;
        getline(cin, choice);
        choice = to_lower_str(choice);

        if (choice.empty()) continue;

        if (choice[0] == 'a') {
            cout << "Student Name: ";
            getline(cin, r.firstName);
            cout << "Student Lastname: ";
            getline(cin, r.lastName);
            cout << "\nName updated!\n\n";
        } else if (choice[0] == 'b') {
            cout << "Assignment: ";
            getline(cin, r.assignment);
            cout << "\nAssignment updated!\n\n";
        } else if (choice[0] == 'c') {
            while (true) {
                cout << "Grade: ";
                string gradeInput;
                getline(cin, gradeInput);
                try {
                    int g = stoi(gradeInput);
                    if (g < 0 || g > 100)
                        throw out_of_range("Grade out of range");
                    r.grade = g;
                    cout << "\nGrade updated!\n\n";
                    break;
                } catch (...) {
                    cout << "Invalid grade. Please enter 0–100.\n";
                }
            }
        } else if (choice[0] == 'd') {
            cout << "\nUpdated Record:\n";
            cout << " # |     Name     | Assignment     | Grade\n";
            cout << "-------------------------------------------\n";
            cout << " 1 | " << left << setw(13) << (r.firstName + " " + r.lastName)
                 << " | " << left << setw(14) << r.assignment
                 << " | " << right << setw(5) << r.grade << "\n";
            pause_enter();
            return; // Done editing
        } else {
            cout << "Invalid choice. Please enter a, b, c, or d.\n";
        }
    }
}

// ------------------- EDIT MENU -------------------

void edit_gradebook(vector<Record>& book) {
    while (true) {
        cout << "\n────── ⋆⋅☆⋅⋆ ──────\n";
        cout << "Edit Gradebook Menu:\n";
        cout << "a. Add Student\n";
        cout << "b. Remove Student\n";
        cout << "c. Edit Student\n";
        cout << "d. Go Back\n";
        cout << "Choose an option: ";

        string choice;
        if (!getline(cin, choice)) return;
        choice = to_lower_str(choice);

        if (choice.empty()) continue;

        switch (choice[0]) {
            case 'a':
                add_student(book);
                break;
            case 'b':
                remove_student(book);
                break;
            case 'c':
                edit_student(book);
                break;
            case 'd':
                return; // Go back to main menu
            default:
                cout << "Invalid option. Please choose a, b, c, or d.\n";
        }
    }
}
// ------------------- FILE SAVE/LOAD -------------------

void save_gradebook(const vector<Record>& book) {
    ofstream out("gradebook.txt");
    if (!out) {
        cerr << "Error: Could not open gradebook.txt for writing.\n";
        return; 
    }

    for (const auto& r : book) {
        out << r.firstName << ","
            << r.lastName << ","
            << r.assignment << ","
            << r.grade << "\n";
    }

    out.close();
}

void load_gradebook(vector<Record>& book) {
    ifstream in("gradebook.txt");
    if (!in) {
        // No file yet, start fresh
        return;
    }

    book.clear();
    string line;
    while (getline(in, line)) {
        if (line.empty()) continue;

        stringstream ss(line);
        Record r;
        string gradeStr;

        getline(ss, r.firstName, ',');
        getline(ss, r.lastName, ',');
        getline(ss, r.assignment, ',');
        getline(ss, gradeStr, ',');

        try {
            r.grade = stoi(gradeStr);
        } catch (...) {
            continue; // skip malformed lines
        }

        book.push_back(r);
    }

    in.close();
}
// -------------------------------------------------

// ------------------- MAIN -------------------
int main() {
    vector<Record> gradebook;
    // Container to store all student records
    // Load data at startup
    load_gradebook(gradebook);
    cout << "Gradebook loaded successfully. (" << gradebook.size() << " records)\n\n";

    while (true) {          // Main program loop
        show_main_menu();   // Display main menu

        string input;
        if (!getline(cin, input)) break;    //Exit on EOF
        input = to_lower_str(input);        //Convert input to lowercase

        if (input.empty()) { // Handle empty input
            cout << "No input received. Please choose a, b, or c.\n\n";
            continue;        // Prompt again
        }

        char choice = input[0];         // Get first character of input
        if (choice == 'a') {
            view_gradebook(gradebook);  // View gradebook option
            cout << "\n";
        } else if (choice == 'b') {
            edit_gradebook(gradebook);  // Edit gradebook option
            cout << "\n";
        } else if (choice == 'c') {     // Save and close option
            cout << "Saving gradebook and closing program...\n";
            save_gradebook(gradebook);
            cout << "Data saved to gradebook.txt\n";
            break;
        } else {                        // Invalid input message
            cout << "Invalid option. Please choose a, b, or c.\n\n";
        }
    }

    return 0; // End of program FINALLY
} // What if I just jump brah