main.cpp

#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <string>
#include <mutex>
#include <mysql/mysql.h>
#include <json/json.h>
#include <cpprest/http_listener.h>
#include <cpprest/json.h>
#include <iomanip>
#include <ctime>
#include <chrono>
#include <sstream>

using namespace std;
using namespace web;
using namespace web::http;
using namespace web::http::experimental::listener;

// Interval Tree Node for scheduling
struct Interval {
    int start, end;
    int id;
    string data;
    
    Interval(int s, int e, int i, string d) : start(s), end(e), id(i), data(d) {}
};

class IntervalTreeNode {
public:
    Interval interval;
    int max_end;
    IntervalTreeNode* left;
    IntervalTreeNode* right;
    
    IntervalTreeNode(Interval i) : interval(i), max_end(i.end), left(nullptr), right(nullptr) {}
};

class IntervalTree {
private:
    IntervalTreeNode* root;
    
    IntervalTreeNode* insert(IntervalTreeNode* root, Interval interval) {
        if (!root) return new IntervalTreeNode(interval);
        
        int low = interval.start;
        if (low < root->interval.start) {
            root->left = insert(root->left, interval);
        } else {
            root->right = insert(root->right, interval);
        }
        
        if (root->max_end < interval.end) {
            root->max_end = interval.end;
        }
        
        return root;
    }
    
    bool doOverlap(Interval i1, Interval i2) {
        return (i1.start < i2.end && i2.start < i1.end);
    }
    
    Interval* overlapSearch(IntervalTreeNode* root, Interval i) {
        if (!root) return nullptr;
        
        if (doOverlap(root->interval, i)) {
            return &(root->interval);
        }
        
        if (root->left && root->left->max_end >= i.start) {
            return overlapSearch(root->left, i);
        }
        
        return overlapSearch(root->right, i);
    }
    
public:
    IntervalTree() : root(nullptr) {}
    
    void insert(Interval interval) {
        root = insert(root, interval);
    }
    
    bool hasConflict(Interval interval) {
        return overlapSearch(root, interval) != nullptr;
    }
};

// Graph for student-course relationships
class Graph {
private:
    map<int, vector<int>> adj_list;
    
public:
    void addEdge(int student_id, int course_id) {
        adj_list[student_id].push_back(course_id);
    }
    
    vector<int> getStudentCourses(int student_id) {
        if (adj_list.find(student_id) != adj_list.end()) {
            return adj_list[student_id];
        }
        return {};
    }
    
    vector<int> getCourseStudents(int course_id) {
        vector<int> students;
        for (const auto& pair : adj_list) {
            for (int course : pair.second) {
                if (course == course_id) {
                    students.push_back(pair.first);
                    break;
                }
            }
        }
        return students;
    }
    
    // Find shortest path between students (through common courses)
    vector<int> findPath(int start_student, int end_student) {
        if (start_student == end_student) return {start_student};
        
        queue<int> q;
        map<int, int> parent;
        set<int> visited;
        
        q.push(start_student);
        visited.insert(start_student);
        parent[start_student] = -1;
        
        while (!q.empty()) {
            int current = q.front();
            q.pop();
            
            vector<int> courses = getStudentCourses(current);
            
            for (int course : courses) {
                vector<int> course_students = getCourseStudents(course);
                
                for (int student : course_students) {
                    if (visited.find(student) == visited.end()) {
                        visited.insert(student);
                        parent[student] = current;
                        q.push(student);
                        
                        if (student == end_student) {
                            vector<int> path;
                            int curr = end_student;
                            while (curr != -1) {
                                path.push_back(curr);
                                curr = parent[curr];
                            }
                            reverse(path.begin(), path.end());
                            return path;
                        }
                    }
                }
            }
        }
        
        return {};
    }
    
    const map<int, vector<int>>& getAdjList() const { return adj_list; }
};

// Database Manager
class DatabaseManager {
private:
    mutex db_mutex;
    MYSQL* connection;
    
    void ensureConnection() {
        if (!connection || mysql_ping(connection)) {
            cerr << "🔁 Reconnecting to MySQL...\n";
            if (connection) mysql_close(connection);
            
            connection = mysql_init(nullptr);
            if (!connection) {
                throw runtime_error("MySQL initialization failed");
            }
            
            if (!mysql_real_connect(connection, "localhost", "root", "password", 
                                   "school_management2", 0, NULL, 0)) {
                string error_msg = mysql_error(connection);
                mysql_close(connection);
                connection = nullptr;
                throw runtime_error("Database connection failed: " + error_msg);
            }
            cout << "✅ Connected to MySQL database\n";
        }
    }
    
public:
    DatabaseManager() : connection(nullptr) {
        ensureConnection();
    }
    
    ~DatabaseManager() {
        if (connection) {
            mysql_close(connection);
            connection = nullptr;
        }
    }
    
    
    Json::Value executeQuery(const string& query) {
        lock_guard<mutex> lock(db_mutex); 
        ensureConnection();
        Json::Value result(Json::arrayValue);
        
        if (mysql_query(connection, query.c_str())) {
            throw runtime_error("Query failed: " + string(mysql_error(connection)));
        }
        
        MYSQL_RES* mysql_result = mysql_store_result(connection);
        if (!mysql_result) return result;
        
        MYSQL_ROW row;
        MYSQL_FIELD* fields = mysql_fetch_fields(mysql_result);
        int num_fields = mysql_num_fields(mysql_result);
        
        while ((row = mysql_fetch_row(mysql_result))) {
            Json::Value json_row;
            for (int i = 0; i < num_fields; i++) {
                const char* field_name = fields[i].name;
                const char* value = row[i] ? row[i] : "";
                json_row[field_name] = value;
            }
            result.append(json_row);
        }
        
        mysql_free_result(mysql_result);
        return result;
    }
    
    bool executeUpdate(const string& query) {
        lock_guard<mutex> lock(db_mutex);
        ensureConnection();
        return mysql_query(connection, query.c_str()) == 0;
    }
    
    int getLastInsertId() {
        lock_guard<mutex> lock(db_mutex);
        return mysql_insert_id(connection);
    }
};

web::json::value jsonToWebJson(const Json::Value& jsoncpp_value) {
    if (jsoncpp_value.isNull()) {
        return web::json::value::null();
    } else if (jsoncpp_value.isBool()) {
        return web::json::value::boolean(jsoncpp_value.asBool());
    } else if (jsoncpp_value.isInt()) {
        return web::json::value::number(jsoncpp_value.asInt());
    } else if (jsoncpp_value.isUInt()) {
        return web::json::value::number(jsoncpp_value.asUInt());
    } else if (jsoncpp_value.isDouble()) {
        return web::json::value::number(jsoncpp_value.asDouble());
    } else if (jsoncpp_value.isString()) {
        return web::json::value::string(utility::conversions::to_string_t(jsoncpp_value.asString()));
    } else if (jsoncpp_value.isArray()) {
        web::json::value arr = web::json::value::array();
        for (int i = 0; i < jsoncpp_value.size(); i++) {
            arr[i] = jsonToWebJson(jsoncpp_value[i]);
        }
        return arr;
    } else if (jsoncpp_value.isObject()) {
        web::json::value obj = web::json::value::object();
        for (const auto& key : jsoncpp_value.getMemberNames()) {
            obj[utility::conversions::to_string_t(key)] = jsonToWebJson(jsoncpp_value[key]);
        }
        return obj;
    } else {
        return web::json::value::null();
    }
}

string formatTime(const string& time) {
    if (time.empty()) return "";
    
    try {
        int hours = stoi(time.substr(0, 2));
        int minutes = stoi(time.substr(3, 2));
        string period = (hours >= 12) ? "PM" : "AM";
        
        if (hours > 12) hours -= 12;
        if (hours == 0) hours = 12;
        
        return to_string(hours) + ":" + 
               (minutes < 10 ? "0" : "") + to_string(minutes) + " " + period;
    } catch (...) {
        return time;
    }
}
// School Management System
class SchoolManagementSystem {
private:
    DatabaseManager db;
    Graph student_course_graph;
    IntervalTree schedule_tree;
    
    void loadStudentCourseGraph() {
        student_course_graph = Graph();
        Json::Value enrollments = db.executeQuery(
            "SELECT student_id, course_id FROM enrollments"
        );
        
        for (const auto& enrollment : enrollments) {
            int student_id = stoi(enrollment["student_id"].asString());
            int course_id = stoi(enrollment["course_id"].asString());
            student_course_graph.addEdge(student_id, course_id);
        }
    }
    
    void loadScheduleTree() {
        Json::Value schedules = db.executeQuery(
            "SELECT s.schedule_id, t.start_time, t.end_time, t.day_of_week, "
            "c.course_name FROM schedules s "
            "JOIN time_slots t ON s.slot_id = t.slot_id "
            "JOIN courses c ON s.course_id = c.course_id"
        );
        
        for (const auto& schedule : schedules) {
            int start = timeToMinutes(schedule["start_time"].asString());
            int end = timeToMinutes(schedule["end_time"].asString());
            int id = stoi(schedule["schedule_id"].asString());
            string data = schedule["course_name"].asString();
            
            schedule_tree.insert(Interval(start, end, id, data));
        }
    }
    
    int timeToMinutes(const string& time) {
        int hours, minutes;
        char colon;
        stringstream ss(time);
        ss >> hours >> colon >> minutes;
        return hours * 60 + minutes;
    }
    
    string getCurrentSemester() {
    time_t now = time(0);
    tm* ltm = localtime(&now);
    int month = 1 + ltm->tm_mon;
    int year = 1900 + ltm->tm_year;

    // Debug output
    cerr << "Current month: " << month << ", year: " << year << endl;
    
    if (month >= 1 && month <= 4) return "Spring " + to_string(year);
    if (month >= 5 && month <= 7) return "Summer " + to_string(year);
    return "Fall " + to_string(year);
}
    
public:
    SchoolManagementSystem() {
        try {
            loadStudentCourseGraph();
            loadScheduleTree();
        } catch (const exception& e) {
            cerr << "Error loading graph/schedule: " << e.what() << endl;
        }
    }
    
    void reloadData() {
        try {
            loadStudentCourseGraph();
            loadScheduleTree();
        } catch (const exception& e) {
            cerr << "Error reloading data: " << e.what() << endl;
        }
    }

    Json::Value getEnrollmentDetails(int enrollment_id) {
    return db.executeQuery(
        "SELECT e.enrollment_id, s.name AS student_name, c.course_name, "
        "e.enrollment_date, e.status, e.grade "
        "FROM enrollments e "
        "JOIN students s ON e.student_id = s.student_id "
        "JOIN courses c ON e.course_id = c.course_id "
        "WHERE e.enrollment_id = " + to_string(enrollment_id)
    );
}
// Fixed getTeacherAnalytics function
Json::Value SchoolManagementSystem::getTeacherAnalytics() {
    Json::Value analytics(Json::objectValue);
    string current_semester = getCurrentSemester();
    
    size_t space_pos = current_semester.find(' ');
    if (space_pos == string::npos) {
        analytics["error"] = "Invalid semester format";
        return analytics;
    }
    
    string semester_name = current_semester.substr(0, space_pos);
    string semester_year = current_semester.substr(space_pos + 1);
    
    try {
        // Teacher workload query
        string workload_query = 
            "SELECT t.teacher_id, t.name AS teacher_name, "
            "COUNT(DISTINCT s.course_id) AS course_count "
            "FROM teachers t "
            "LEFT JOIN schedules s ON t.teacher_id = s.teacher_id "
            "WHERE s.semester = '" + semester_name + "' AND s.year = '" + semester_year + "' "
            "GROUP BY t.teacher_id, t.name";
        
        Json::Value workload = db.executeQuery(workload_query);
        analytics["workload"] = workload;
        
        // Teacher effectiveness query
        string effectiveness_query = 
            "SELECT t.name AS teacher_name, c.course_name, "
            "ROUND(AVG(e.grade), 1) AS avg_grade, "
            "COUNT(e.enrollment_id) AS enrollment_count, "
            "ROUND(SUM(CASE WHEN e.grade >= 60 THEN 1 ELSE 0 END) / COUNT(e.enrollment_id) * 100, 1) AS pass_rate "
            "FROM teachers t "
            "JOIN schedules s ON t.teacher_id = s.teacher_id "
            "JOIN enrollments e ON s.course_id = e.course_id "
            "JOIN courses c ON s.course_id = c.course_id "
            "WHERE s.semester = '" + semester_name + "' AND s.year = '" + semester_year + "' "
            "AND e.grade IS NOT NULL "
            "GROUP BY t.teacher_id, c.course_id";
        
        Json::Value effectiveness = db.executeQuery(effectiveness_query);
        analytics["effectiveness"] = effectiveness;
        
        if (workload.empty() && effectiveness.empty()) {
            analytics["message"] = "No teaching activity found for " + current_semester;
        }
        
    } catch (const exception& e) {
        analytics["error"] = e.what();
    }
    
    return analytics;
}
// Fixed getCourseAnalytics function
Json::Value SchoolManagementSystem::getCourseAnalytics() {
    Json::Value analytics(Json::objectValue);
    
    try {
        // Enrollment counts with course names
        string enrollment_query = 
            "SELECT c.course_id, c.course_name, "
            "COUNT(e.enrollment_id) AS student_count "
            "FROM courses c "
            "LEFT JOIN enrollments e ON c.course_id = e.course_id AND e.status = 'enrolled' "
            "GROUP BY c.course_id, c.course_name";
        
        Json::Value enrollmentCounts = db.executeQuery(enrollment_query);
        analytics["students_per_course"] = enrollmentCounts;
        
        // Find most popular course
        int max_count = 0;
        string popular_course_name = "No Data";
        if (!enrollmentCounts.empty()) {
            for (const auto& course : enrollmentCounts) {
                int count = 0;
                if (!course["student_count"].isNull()) {
                    try {
                        count = stoi(course["student_count"].asString());
                    } catch (...) {
                        count = 0;
                    }
                }
                if (count > max_count) {
                    max_count = count;
                    popular_course_name = course["course_name"].asString();
                }
            }
        }
        
        analytics["most_popular_course_name"] = popular_course_name;
        analytics["most_popular_count"] = max_count;
        
        // Fixed grade analytics with proper handling
        string grade_query = 
            "SELECT c.course_name, "
            "ROUND(AVG(e.grade), 1) as avg_grade "
            "FROM enrollments e "
            "JOIN courses c ON e.course_id = c.course_id "
            "WHERE e.grade IS NOT NULL AND e.grade > 0 "
            "GROUP BY c.course_name";
        
        Json::Value grade_analytics = db.executeQuery(grade_query);
        analytics["average_grades"] = grade_analytics;
        
    } catch (const exception& e) {
        analytics["error"] = e.what();
    }
    
    return analytics;
}

// Fix getCourseAnalytics function

// Add new endpoints to backend
Json::Value getEnrollmentCount() {
    Json::Value result = db.executeQuery(
        "SELECT COUNT(*) as count FROM enrollments"
    );
    return result[0]; // Return first row with count
}

Json::Value getRecentEnrollments() {
    return db.executeQuery(
        "SELECT s.name AS student_name, c.course_name, e.enrollment_date, e.status "
        "FROM enrollments e "
        "JOIN students s ON e.student_id = s.student_id "
        "JOIN courses c ON e.course_id = c.course_id "
        "ORDER BY e.enrollment_date DESC LIMIT 5"
    );
}
    // API Endpoints
    Json::Value getStudents() {
        return db.executeQuery("SELECT * FROM students");
    }
    
    Json::Value getCourses() {
        return db.executeQuery(
            "SELECT c.*, d.name AS department_name "
            "FROM courses c "
            "JOIN departments d ON c.department_id = d.department_id"
        );
    }
    
    Json::Value getSchedule() {
    string current_semester = getCurrentSemester();
    
    size_t space_pos = current_semester.find(' ');
    if (space_pos == string::npos) {
        cerr << "Invalid semester format: " << current_semester << endl;
        return Json::Value(Json::arrayValue);
    }
    
    string semester_name = current_semester.substr(0, space_pos);
    string semester_year = current_semester.substr(space_pos + 1);
    
    try {
        string query = 
            "SELECT s.schedule_id, c.course_name, t.name as teacher_name, "
            "r.room_number, "
            "LOWER(SUBSTRING(ts.day_of_week, 1, 3)) as day_of_week_short, "
            "ts.day_of_week, "  // Add full day name
            "ts.start_time, ts.end_time "
            "FROM schedules s "
            "JOIN courses c ON s.course_id = c.course_id "
            "JOIN teachers t ON s.teacher_id = t.teacher_id "
            "JOIN classrooms r ON s.room_id = r.room_id "
            "JOIN time_slots ts ON s.slot_id = ts.slot_id "
            "WHERE s.semester = '" + semester_name + "' AND s.year = '" + semester_year + "' "
            "ORDER BY ts.day_of_week, ts.start_time";
        
        cerr << "Executing schedule query: " << query << endl;
        
        return db.executeQuery(query);
    } catch (const exception& e) {
        cerr << "Error in getSchedule: " << e.what() << endl;
        return Json::Value(Json::arrayValue);
    }
}

    Json::Value getTeachers() {
        return db.executeQuery("SELECT * FROM teachers");
    }

    Json::Value getEnrollments() {
        return db.executeQuery(
            "SELECT e.enrollment_id, e.student_id, s.name as student_name, "
            "e.course_id, c.course_name, e.enrollment_date, e.status, e.grade "
            "FROM enrollments e "
            "JOIN students s ON e.student_id = s.student_id "
            "JOIN courses c ON e.course_id = c.course_id"
        );
    }
    
    Json::Value getStudentCourses(int student_id) {
        string query = 
            "SELECT c.*, d.name AS department_name "
            "FROM courses c "
            "JOIN departments d ON c.department_id = d.department_id "
            "JOIN enrollments e ON c.course_id = e.course_id "
            "WHERE e.student_id = " + to_string(student_id) + 
            " AND e.status = 'enrolled'";
        return db.executeQuery(query);
    }
    
    Json::Value getStudentCourseEdges() {
        Json::Value edges(Json::arrayValue);
        for (const auto& pair : student_course_graph.getAdjList()) {
            int student_id = pair.first;
            for (int course_id : pair.second) {
                Json::Value edge;
                edge["student_id"] = student_id;
                edge["course_id"] = course_id;
                edges.append(edge);
            }
        }
        return edges;
    }

    Json::Value findStudentPath(int start_student, int end_student) {
        Json::Value result(Json::arrayValue);
        vector<int> path = student_course_graph.findPath(start_student, end_student);
        for (int sid : path) result.append(sid);
        return result;
    }

    Json::Value getCurrentEnrollments() {
    return db.executeQuery(
        "SELECT e.enrollment_id, s.name AS student_name, c.course_name, "
        "e.enrollment_date, e.status, e.grade "
        "FROM enrollments e "
        "JOIN students s ON e.student_id = s.student_id "
        "JOIN courses c ON e.course_id = c.course_id "
        "WHERE e.status = 'enrolled'"  // Only show active enrollments
    );
}
    
    bool enrollStudent(int student_id, int course_id) {
        string prereq_query = "SELECT COUNT(*) as missing FROM prerequisites p "
                             "WHERE p.course_id = " + to_string(course_id) + 
                             " AND p.prerequisite_course_id NOT IN ("
                             "SELECT e.course_id FROM enrollments e "
                             "WHERE e.student_id = " + to_string(student_id) + 
                             " AND e.status = 'completed')";
        
        Json::Value prereq_result = db.executeQuery(prereq_query);
        if (!prereq_result.empty() && stoi(prereq_result[0]["missing"].asString()) > 0) {
            return false;
        }
        
        string capacity_query = 
            "SELECT c.max_capacity, COUNT(e.enrollment_id) as enrolled "
            "FROM courses c LEFT JOIN enrollments e ON c.course_id = e.course_id "
            "AND e.status = 'enrolled' "
            "WHERE c.course_id = " + to_string(course_id) + " "
            "GROUP BY c.course_id";
        
        Json::Value capacity_result = db.executeQuery(capacity_query);
        if (!capacity_result.empty()) {
            int max_cap = stoi(capacity_result[0]["max_capacity"].asString());
            int enrolled = stoi(capacity_result[0]["enrolled"].asString());
            if (enrolled >= max_cap) {
                return false;
            }
        }
        
        string enroll_query = "INSERT INTO enrollments (student_id, course_id, status) VALUES (" + 
                             to_string(student_id) + ", " + to_string(course_id) + ", 'enrolled')";
        
        bool success = db.executeUpdate(enroll_query);
        if (success) {
            student_course_graph.addEdge(student_id, course_id);
        }
        return success;
    }
    bool checkScheduleConflict(int start_time, int end_time) {
        Interval new_interval(start_time, end_time, -1, "");
        return schedule_tree.hasConflict(new_interval);
    }
    
    DatabaseManager& getDb() { return db; }
};

// HTTP Server
class HTTPServer {
private:
    mutex sms_mutex;
    SchoolManagementSystem sms;
    http_listener listener;
    
    void handleGet(http_request request) {
        lock_guard<mutex> lock(sms_mutex);
        auto path = request.relative_uri().path();
        string path_str = utility::conversions::to_utf8string(path);
        cout << "📝 Incoming GET: " << path_str << endl;
        
        http_response response(status_codes::OK);
        response.headers().add(U("Access-Control-Allow-Origin"), U("*"));
        response.headers().add(U("Content-Type"), U("application/json"));
        response.headers().add(U("Access-Control-Allow-Methods"), U("GET, POST, OPTIONS"));
        response.headers().add(U("Access-Control-Allow-Headers"), U("Content-Type"));
        
        try {
            Json::Value result;
            
            if (path_str == "/students") {
                result = sms.getStudents();
            }else if (path_str == "/current-enrollments") {
                result = sms.getCurrentEnrollments();
            }else if (path_str.find("/enrollment-details/") == 0){
    size_t pos = path_str.find_last_of('/');
    if (pos != string::npos) {
        string id_str = path_str.substr(pos + 1);
        try {
            int enrollment_id = stoi(id_str);
            result = sms.getEnrollmentDetails(enrollment_id);
        } catch (...) {
            result["error"] = "Invalid enrollment ID";
        }
    }
}
            else if (path_str == "/enrollment-count") {
                result = sms.getEnrollmentCount();
            } else if (path_str == "/recent-enrollments") {
                result = sms.getRecentEnrollments();
            }else if (path_str == "/courses") {
                result = sms.getCourses();
            } else if (path_str == "/schedule") {
                result = sms.getSchedule();
            } else if (path_str == "/student-course-edges") {
                result = sms.getStudentCourseEdges();
            } else if (path_str == "/course-analytics") {
                result = sms.getCourseAnalytics();
            } else if (path_str == "/teacher-analytics") {
                result = sms.getTeacherAnalytics();
            }
            else if (path_str == "/teachers") {
                result = sms.getTeachers();
            } 
            else if (path_str == "/enrollments") {
                result = sms.getEnrollments();
            }
            else if (path_str == "/find-student-path") {
                auto query = uri::split_query(request.relative_uri().query());
                int start_student = 0, end_student = 0;
                
                if (query.find(U("start_student")) != query.end()) {
                    start_student = stoi(utility::conversions::to_utf8string(query[U("start_student")]));
                }
                if (query.find(U("end_student")) != query.end()) {
                    end_student = stoi(utility::conversions::to_utf8string(query[U("end_student")]));
                }
                
                Json::Value path = sms.findStudentPath(start_student, end_student);
                Json::Value jsonResult;
                for (auto sid : path) {
                    jsonResult.append(sid);
                }
                result = jsonResult;
            } else {
                response.set_status_code(status_codes::NotFound);
                result["error"] = "Endpoint not found";
            }
            
            response.set_body(jsonToWebJson(result));
            
        } catch (const exception& e) {
            response.set_status_code(status_codes::InternalError);
            web::json::value error = web::json::value::object();
            error[U("error")] = web::json::value::string(
                utility::conversions::to_string_t(e.what()));
            response.set_body(error);
        }
        
        request.reply(response);
    }
    
    void handlePost(http_request request) {
        lock_guard<mutex> lock(sms_mutex);
        request.extract_json().then([=](pplx::task<web::json::value> task) {
            try {
                auto json_data = task.get();
                auto path = request.relative_uri().path();
                string path_str = utility::conversions::to_utf8string(path);
                
                http_response response(status_codes::OK);
                response.headers().add(U("Access-Control-Allow-Origin"), U("*"));
                response.headers().add(U("Content-Type"), U("application/json"));
                response.headers().add(U("Access-Control-Allow-Methods"), U("GET, POST, OPTIONS"));
                response.headers().add(U("Access-Control-Allow-Headers"), U("Content-Type"));
                web::json::value result = web::json::value::object();
                
                if (path_str == "/add-student") {
                    string name = utility::conversions::to_utf8string(
                        json_data[U("name")].as_string());
                    string email = utility::conversions::to_utf8string(
                        json_data[U("email")].as_string());
                    string phone = json_data.has_field(U("phone")) ? 
                        utility::conversions::to_utf8string(
                            json_data[U("phone")].as_string()) : "";
                    string address = json_data.has_field(U("address")) ? 
                        utility::conversions::to_utf8string(
                            json_data[U("address")].as_string()) : "";
                    
                    string insert_query = 
                        "INSERT INTO students (name, email, phone, address, status, enrollment_date) "
                        "VALUES ('" + name + "', '" + email + "', '" + 
                        phone + "', '" + address + "', 'active', CURDATE())";
                    
                    bool success = sms.getDb().executeUpdate(insert_query);
                    
                    result[U("success")] = web::json::value::boolean(success);
                    result[U("message")] = web::json::value::string(
                        utility::conversions::to_string_t(
                            success ? "Student added successfully" : "Failed to add student"
                        )
                    );
                    
                } else if (path_str.find("/enrollment-details/") == 0) {
                size_t pos = path_str.find_last_of('/');
                if (pos != string::npos) {
                    string id_str = path_str.substr(pos + 1);
                    try {
                        int enrollment_id = stoi(id_str);
                        result = jsonToWebJson(sms.getEnrollmentDetails(enrollment_id));
                    } catch (...) {
                        result[U("error")] = web::json::value::string(U("Invalid enrollment ID"));
                    }
                }
            }
                else if (path_str == "/add-course") {
                    string course_code = utility::conversions::to_utf8string(
                        json_data[U("course_code")].as_string());
                    string course_name = utility::conversions::to_utf8string(
                        json_data[U("course_name")].as_string());
                    string department_name = utility::conversions::to_utf8string(
                        json_data[U("department")].as_string());
                    int credits = json_data[U("credits")].as_integer();
                    int max_capacity = json_data[U("max_capacity")].as_integer();
                    string description = json_data.has_field(U("description")) ? 
                        utility::conversions::to_utf8string(
                            json_data[U("description")].as_string()) : "";
                    
                    string dept_query = "SELECT department_id FROM departments WHERE name = '" + 
                                    department_name + "'";
                    Json::Value dept_result = sms.getDb().executeQuery(dept_query);
                    int department_id = -1;
                    
                    if (dept_result.empty()) {
                        string insert_dept = "INSERT INTO departments (name) VALUES ('" + 
                                        department_name + "')";
                        if (!sms.getDb().executeUpdate(insert_dept)) {
                            throw runtime_error("Failed to create department");
                        }
                        department_id = sms.getDb().getLastInsertId();
                    } else {
                        department_id = stoi(dept_result[0]["department_id"].asString());
                    }
                    
                    string insert_query = 
                        "INSERT INTO courses (course_code, course_name, credits, department_id, max_capacity, description) "
                        "VALUES ('" + course_code + "', '" + course_name + "', " + 
                        to_string(credits) + ", " + to_string(department_id) + ", " + 
                        to_string(max_capacity) + ", '" + description + "')";
                    
                    bool success = sms.getDb().executeUpdate(insert_query);
                    int course_id = sms.getDb().getLastInsertId();
                    
                    if (json_data.has_field(U("prerequisites"))) {
                        auto prerequisites = json_data[U("prerequisites")].as_array();
                        for (const auto& prereq : prerequisites) {
                            int prereq_id = prereq.as_integer();
                            string prereq_query = 
                                "INSERT INTO prerequisites (course_id, prerequisite_course_id) "
                                "VALUES (" + to_string(course_id) + ", " + to_string(prereq_id) + ")";
                            sms.getDb().executeUpdate(prereq_query);
                        }
                    }
                    
                    result[U("success")] = web::json::value::boolean(success);
                    result[U("message")] = web::json::value::string(
                        utility::conversions::to_string_t(
                            success ? "Course added successfully" : "Failed to add course"
                        )
                    );
                } else if (path_str == "/enroll") {
                    int student_id = json_data[U("student_id")].as_integer();
                    int course_id = json_data[U("course_id")].as_integer();

                    string prereq_query = 
                        "SELECT COUNT(*) as missing FROM prerequisites p "
                        "WHERE p.course_id = " + to_string(course_id) +
                        " AND p.prerequisite_course_id NOT IN ("
                            "SELECT e.course_id FROM enrollments e "
                            "WHERE e.student_id = " + to_string(student_id) +
                            " AND e.status = 'completed'"
                        ")";
                    Json::Value prereq_result = sms.getDb().executeQuery(prereq_query);
                    if (!prereq_result.empty() && stoi(prereq_result[0]["missing"].asString()) > 0) {
                        result[U("success")] = web::json::value::boolean(false);
                        result[U("message")] = web::json::value::string(
                            utility::conversions::to_string_t(
                                "Student is missing prerequisites for this course."
                            )
                        );
                        response.set_body(result);
                        request.reply(response);
                        return;
                    }

                    string capacity_query = 
                        "SELECT c.max_capacity, COUNT(e.enrollment_id) as enrolled "
                        "FROM courses c LEFT JOIN enrollments e ON c.course_id = e.course_id "
                        "AND e.status = 'enrolled' "
                        "WHERE c.course_id = " + to_string(course_id) + " "
                        "GROUP BY c.course_id";
                    Json::Value capacity_result = sms.getDb().executeQuery(capacity_query);
                    if (!capacity_result.empty()) {
                        int max_cap = stoi(capacity_result[0]["max_capacity"].asString());
                        int enrolled = stoi(capacity_result[0]["enrolled"].asString());
                        if (enrolled >= max_cap) {
                            result[U("success")] = web::json::value::boolean(false);
                            result[U("message")] = web::json::value::string(
                                utility::conversions::to_string_t("Course is already full.")
                            );
                            response.set_body(result);
                            request.reply(response);
                            return;
                        }
                    }

                    string already_query = 
                        "SELECT COUNT(*) as cnt FROM enrollments WHERE student_id = " + 
                        to_string(student_id) +
                        " AND course_id = " + to_string(course_id) + " AND status = 'enrolled'";
                    Json::Value already_result = sms.getDb().executeQuery(already_query);
                    if (!already_result.empty() && stoi(already_result[0]["cnt"].asString()) > 0) {
                        result[U("success")] = web::json::value::boolean(false);
                        result[U("message")] = web::json::value::string(
                            utility::conversions::to_string_t("Student is already enrolled in this course.")
                        );
                        response.set_body(result);
                        request.reply(response);
                        return;
                    }

                    bool enroll_success = sms.enrollStudent(student_id, course_id);
                    result[U("success")] = web::json::value::boolean(enroll_success);
                    result[U("message")] = web::json::value::string(
                        utility::conversions::to_string_t(
                            enroll_success ? "Enrollment successful" : 
                            "Enrollment failed due to a database error."
                        )
                    );
                    
                } else if (path_str == "/find-student-path") {
                    int start_id = json_data[U("start_student")].as_integer();
                    int end_id = json_data[U("end_student")].as_integer();
                    Json::Value path = sms.findStudentPath(start_id, end_id);
                    result = jsonToWebJson(path);
                    response.set_body(result);
                    request.reply(response);
                    return;
                    
                } else if (path_str == "/check-schedule-conflict") {
                    string start_time = utility::conversions::to_utf8string(
                        json_data[U("start_time")].as_string());
                    string end_time = utility::conversions::to_utf8string(
                        json_data[U("end_time")].as_string());
                    
                    int start_minutes = timeToMinutes(start_time);
                    int end_minutes = timeToMinutes(end_time);
                    
                    bool has_conflict = sms.checkScheduleConflict(start_minutes, end_minutes);
                    result[U("has_conflict")] = web::json::value::boolean(has_conflict);
                    result[U("message")] = web::json::value::string(
                        utility::conversions::to_string_t(
                            has_conflict ? "Schedule conflict detected" : "No schedule conflict"
                        )
                    );
                    
                } else if (path_str == "/student-courses") {
                    int student_id = json_data[U("student_id")].as_integer();
                    Json::Value courses = sms.getStudentCourses(student_id);
                    result = jsonToWebJson(courses);
                    response.set_body(result);
                    request.reply(response);
                    return;
                    
                } else if (path_str == "/reload-data") {
                    sms.reloadData();
                    result[U("success")] = web::json::value::boolean(true);
                    result[U("message")] = web::json::value::string(
                        utility::conversions::to_string_t("Data reloaded successfully")
                    );
                    
                } else if (path_str == "/update-grade") {
                    int student_id = json_data[U("student_id")].as_integer();
                    int course_id = json_data[U("course_id")].as_integer();
                    double grade = json_data[U("grade")].as_double();
                    
                    string update_query = 
                        "UPDATE enrollments SET grade = " + to_string(grade) +
                        " WHERE student_id = " + to_string(student_id) +
                        " AND course_id = " + to_string(course_id);
                    
                    bool success = sms.getDb().executeUpdate(update_query);
                    result[U("success")] = web::json::value::boolean(success);
                    result[U("message")] = web::json::value::string(
                        utility::conversions::to_string_t(
                            success ? "Grade updated successfully" : "Failed to update grade"
                        )
                    );
                    
                } else if (path_str == "/add-teacher") {
                    string name = utility::conversions::to_utf8string(
                        json_data[U("name")].as_string());
                    string email = utility::conversions::to_utf8string(
                        json_data[U("email")].as_string());
                    string phone = json_data.has_field(U("phone")) ? 
                        utility::conversions::to_utf8string(
                            json_data[U("phone")].as_string()) : "";
                    string department = utility::conversions::to_utf8string(
                        json_data[U("department")].as_string());
                    
                    string insert_query = 
                        "INSERT INTO teachers (name, email, phone, department, hire_date) "
                        "VALUES ('" + name + "', '" + email + "', '" + 
                        phone + "', '" + department + "', CURDATE())";
                    
                    bool success = sms.getDb().executeUpdate(insert_query);
                    result[U("success")] = web::json::value::boolean(success);
                    result[U("message")] = web::json::value::string(
                        utility::conversions::to_string_t(
                            success ? "Teacher added successfully" : "Failed to add teacher"
                        )
                    );
                    
                } else if (path_str == "/create-schedule") {
    int course_id = json_data[U("course_id")].as_integer();
    int teacher_id = json_data[U("teacher_id")].as_integer();
    string room_number = utility::conversions::to_utf8string(json_data[U("room")].as_string());
    string day_of_week = utility::conversions::to_utf8string(json_data[U("day_of_week")].as_string());
    string start_time = utility::conversions::to_utf8string(json_data[U("start_time")].as_string());
    string end_time = utility::conversions::to_utf8string(json_data[U("end_time")].as_string());
    string semester = "Fall";  // Default semester
    int year = 2025;           // Default year

    // 1. Find or create room
    string room_query = "SELECT room_id FROM classrooms WHERE room_number = '" + room_number + "'";
    Json::Value room_result = sms.getDb().executeQuery(room_query);
    int room_id = -1;
    
    if (room_result.empty()) {
        // Create new room if doesn't exist
        string insert_room = "INSERT INTO classrooms (room_number, capacity) VALUES ('" + 
                            room_number + "', 30)"; // Default capacity
        if (!sms.getDb().executeUpdate(insert_room)) {
            throw runtime_error("Failed to create classroom");
        }
        room_id = sms.getDb().getLastInsertId();
    } else {
        room_id = stoi(room_result[0]["room_id"].asString());
    }

    // 2. Find or create time slot
    string slot_query = "SELECT slot_id FROM time_slots WHERE day_of_week = '" + day_of_week +
                       "' AND start_time = '" + start_time + "' AND end_time = '" + end_time + "'";
    Json::Value slot_result = sms.getDb().executeQuery(slot_query);
    int slot_id = -1;
    
    if (slot_result.empty()) {
        string insert_slot = "INSERT INTO time_slots (day_of_week, start_time, end_time) "
                            "VALUES ('" + day_of_week + "', '" + start_time + "', '" + end_time + "')";
        if (!sms.getDb().executeUpdate(insert_slot)) {
            throw runtime_error("Failed to create time slot");
        }
        slot_id = sms.getDb().getLastInsertId();
    } else {
        slot_id = stoi(slot_result[0]["slot_id"].asString());
    }

    // 3. Create schedule entry
    string schedule_query = 
        "INSERT INTO schedules (course_id, teacher_id, room_id, slot_id, semester, year) "
        "VALUES (" + to_string(course_id) + ", " + to_string(teacher_id) + ", " +
        to_string(room_id) + ", " + to_string(slot_id) + ", '" +
        semester + "', " + to_string(year) + ")";
    
    bool success = sms.getDb().executeUpdate(schedule_query);
    
                    if (success) {
                        result[U("success")] = web::json::value::boolean(true);
                        result[U("message")] = web::json::value::string(U("Schedule created successfully"));
                        sms.reloadData();
                    } else {
                        result[U("success")] = web::json::value::boolean(false);
                        result[U("message")] = web::json::value::string(U("Failed to create schedule"));
                    }
                    
                } else {
                    response.set_status_code(status_codes::NotFound);
                    result[U("error")] = web::json::value::string(U("Endpoint not found"));
                }
                
                response.set_body(result);
                request.reply(response);
                
            } catch (const exception& e) {
                http_response response(status_codes::InternalError);
                response.headers().add(U("Access-Control-Allow-Origin"), U("*"));
                response.headers().add(U("Content-Type"), U("application/json"));
                response.headers().add(U("Access-Control-Allow-Methods"), U("GET, POST, OPTIONS"));
                response.headers().add(U("Access-Control-Allow-Headers"), U("Content-Type"));
                web::json::value error = web::json::value::object();
                error[U("error")] = web::json::value::string(
                    utility::conversions::to_string_t(e.what()));
                response.set_body(error);
                request.reply(response);
            }
        });
    }
    
    int timeToMinutes(const string& time) {
        size_t colon_pos = time.find(':');
        if (colon_pos == string::npos || colon_pos == 0 || colon_pos >= time.length() - 1) {
            return 0;
        }
        
        try {
            int hours = stoi(time.substr(0, colon_pos));
            int minutes = stoi(time.substr(colon_pos + 1, 2));
            return hours * 60 + minutes;
        } catch (const exception&) {
            return 0;
        }
    }
    
public:
    HTTPServer(const string& address) : listener(http::uri(utility::conversions::to_string_t(address))) {
        listener.support(methods::GET, [this](http_request request) {
            handleGet(request);
        });
        
        listener.support(methods::POST, [this](http_request request) {
            handlePost(request);
        });
        
        listener.support(methods::OPTIONS, [this](http_request request) {
            http_response response(status_codes::OK);
            response.headers().add(U("Access-Control-Allow-Origin"), U("*"));
            response.headers().add(U("Access-Control-Allow-Methods"), U("GET, POST, OPTIONS"));
            response.headers().add(U("Access-Control-Allow-Headers"), U("Content-Type"));
            request.reply(response);
        });
    }
    
    pplx::task<void> start() {
        return listener.open();
    }
    
    pplx::task<void> stop() {
        return listener.close();
    }
};

int main() {
    try {
        HTTPServer server("http://localhost:8080");
        
        cout << "🚀 Starting School Management System server on http://localhost:8080" << endl;
        server.start().wait();
        
        cout << "⏳ Press Enter to exit..." << endl;
        string line;
        getline(cin, line);
        
        server.stop().wait();
        cout << "🛑 Server stopped" << endl;
        
    } catch (const exception& e) {
        cerr << "❌ Error: " << e.what() << endl;
        return 1;
    }
    
    return 0;
}