ProjectTwo.cpp

// ProjectTwo.cpp
// Advising Assistance Program for ABCU Computer Science Department
// Author: Joshua Torres
// Date: June 2025

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <queue>
#include <limits>

using namespace std;

// Represents a single course with its number, title, and prerequisites
struct Course {
    string number;
    string title;
    vector<string> prerequisites;
};

// Alias for catalog data structure (balanced BST)
typedef map<string, Course> CourseCatalog;

// Displays the main menu options to the user
void displayMenu() {
    cout << "\nWelcome to the course planner.\n"
         << "1. Load Data Structure.\n"
         << "2. Print Course List (Alphanumeric).\n"
         << "3. Print Course.\n"
         << "4. Print Course List (Topological Order).\n"
         << "9. Exit\n"
         << "What would you like to do? ";
}

// Loads course data from a CSV file into a map keyed by course number
CourseCatalog loadData(const string& inputName) {
    CourseCatalog catalog;
    string filename = inputName;

    // Attempt to open the file as given
    ifstream fin(filename);
    if (!fin && filename.find('.') == string::npos) {
        // If no extension is present, try adding ".csv"
        fin.clear();
        filename += ".csv";
        fin.open(filename);
        if (fin) {
            cout << "Note: opened '" << filename << "' instead." << endl;
        }
    }
    if (!fin) {
        cerr << "Error: cannot open file '" << inputName << "'." << endl;
        return catalog;
    }

    string line;
    while (getline(fin, line)) {
        if (line.empty()) continue; // Skip blank lines
        stringstream ss(line);
        Course c;
        getline(ss, c.number, ',');
        getline(ss, c.title, ',');

        if (c.number.empty() || c.title.empty()) continue; // Skip invalid lines

        string pre;
        while (getline(ss, pre, ',')) {
            if (!pre.empty()) { // Skip empty prerequisites
                c.prerequisites.push_back(pre);
            }
        }
        catalog[c.number] = c;
    }
    return catalog;
}

// Prints all courses in alphanumeric order
void printCourseList(const CourseCatalog& catalog) {
    if (catalog.empty()) {
        cout << "No data loaded. Use option 1 first." << endl;
        return;
    }
    cout << "\nCourse List (Alphanumeric):" << endl;
    for (const auto& [num, course] : catalog) {
        cout << num << ", " << course.title << endl;
    }
}

// Prints details for a specific course, including its prerequisites
void printCourseDetails(const CourseCatalog& catalog, const string& key) {
    auto it = catalog.find(key);
    if (it == catalog.end()) {
        cout << "Course '" << key << "' not found." << endl;
        return;
    }
    const Course& c = it->second;
    cout << c.number << ", " << c.title << "\nPrerequisites: ";
    if (c.prerequisites.empty()) {
        cout << "None" << endl;
        return;
    }
    for (size_t i = 0; i < c.prerequisites.size(); ++i) {
        const string& pnum = c.prerequisites[i];
        auto pit = catalog.find(pnum);
        if (pit != catalog.end())
            cout << pit->second.number << " (" << pit->second.title << ")";
        else
            cout << pnum << " (not found)";
        if (i + 1 < c.prerequisites.size())
            cout << ", ";
    }
    cout << endl;
}

// Prints all courses in a valid topological order using Kahn's algorithm
void printTopoOrder(const CourseCatalog& catalog) {
    if (catalog.empty()) {
        cout << "No data loaded. Use option 1 first." << endl;
        return;
    }

    map<string, int> indegree; // Tracks in-degrees of courses
    map<string, vector<string>> adj; // Adjacency list for prerequisites

    // Initialize in-degree map and adjacency list
    for (const auto& [num, course] : catalog) {
        indegree[num] = 0;
    }
    for (const auto& [num, course] : catalog) {
        for (const auto& pre : course.prerequisites) {
            if (!catalog.count(pre)) { // Ensure prerequisite exists in the catalog
                cerr << "Error: Prerequisite '" << pre << "' not found in catalog." << endl;
                continue;
            }
            adj[pre].push_back(num);
            indegree[num]++;
        }
    }

    // Debugging: Print adjacency list and in-degrees
    cout << "Adjacency List:\n";
    for (const auto& [key, val] : adj) {
        cout << key << ": ";
        for (const auto& v : val) {
            cout << v << " ";
        }
        cout << endl;
    }
    cout << "In-Degrees:\n";
    for (const auto& [key, val] : indegree) {
        cout << key << ": " << val << endl;
    }

    queue<string> q; // Queue for courses with zero in-degree
    for (const auto& [num, deg] : indegree) {
        if (deg == 0) {
            q.push(num);
        }
    }

    vector<string> topo; // Stores topological order
    while (!q.empty()) {
        string curr = q.front();
        q.pop();
        topo.push_back(curr);

        for (const auto& nb : adj[curr]) {
            if (--indegree[nb] == 0) {
                q.push(nb);
            }
        }
    }

    // Check for cycles
    if (topo.size() != catalog.size()) {
        cout << "Cannot generate schedule: prerequisite cycle detected." << endl;
        return;
    }

    // Print topological order
    cout << "\nCourse List (Topological Order):" << endl;
    for (const auto& num : topo) {
        cout << num << ", " << catalog.at(num).title << endl;
    }
}

int main() {
    CourseCatalog catalog; // Stores course data
    while (true) {
        displayMenu(); // Show menu options
        int choice;
        if (!(cin >> choice)) {
            cin.clear();
            cin.ignore(numeric_limits<streamsize>::max(), '\n');
            cout << "Invalid input. Please enter a number." << endl;
            continue;
        }
        if (choice == 9) {
            cout << "Thank you for using the course planner!" << endl;
            break;
        }
        switch (choice) {
            case 1: {
                cout << "Enter the data filename (e.g., ABCU Advising Program Input.csv): ";
                cin.ignore(numeric_limits<streamsize>::max(), '\n');
                string fname;
                getline(cin, fname);
                catalog = loadData(fname);
                if (!catalog.empty())
                    cout << "Data loaded successfully." << endl;
                break;
            }
            case 2:
                printCourseList(catalog);
                break;
            case 3: {
                cout << "What course do you want to know about? ";
                string key;
                cin >> key;
                for (auto& ch : key)
                    ch = toupper(ch); // Convert to uppercase for uniformity
                printCourseDetails(catalog, key);
                break;
            }
            case 4:
                printTopoOrder(catalog);
                break;
            default:
                cout << choice << " is not a valid option." << endl;
        }
    }
    return 0;
}