StudentManager.cpp

#include "StudentManager.h"
#include <fstream>
#include <iostream>
#include <algorithm>
#include <sstream>

#include "json.hpp"
using json = nlohmann::json;

// ================== UTILS ==================

std::string toLower(std::string data) {
    std::transform(data.begin(), data.end(), data.begin(),
                   [](unsigned char c) { return std::tolower(c); });
    return data;
}

const std::string WHITESPACE = " \n\r\t\f\v";

std::string ltrim(const std::string& s) {
    size_t start = s.find_first_not_of(WHITESPACE);
    return (start == std::string::npos) ? "" : s.substr(start);
}

std::string rtrim(const std::string& s) {
    size_t end = s.find_last_not_of(WHITESPACE);
    return (end == std::string::npos) ? "" : s.substr(0, end + 1);
}

std::string trim(const std::string& s) {
    return rtrim(ltrim(s));
}

// ================== HISTORY ==================

void StudentManager::saveAction() {
    history.push_back(students);
    redoStack.clear();
}

void StudentManager::undo() {
    if (history.empty()) {
        std::cout << "Nothing to undo\n";
        return;
    }

    redoStack.push_back(students);
    students = history.back();
    history.pop_back();

    rebuildIndex();
    std::cout << "Undo successful\n";
}

void StudentManager::redo() {
    if (redoStack.empty()) {
        std::cout << "Nothing to redo\n";
        return;
    }

    history.push_back(students);
    students = redoStack.back();
    redoStack.pop_back();

    rebuildIndex();
    std::cout << "Redo successful\n";
}

// ================== CORE ==================

void StudentManager::addStudent(const Student& s) {
    if (index.count(s.getId())) {
        std::cout << "ID already exists\n";
        return;
    }

    saveAction();

    students.push_back(s);
    index[s.getId()] = students.size() - 1;
}

void StudentManager::showAll() const {
    for (const auto& s : students) {
        s.display();
    }
}

Student* StudentManager::getStudentById(int id) {
    auto it = index.find(id);
    if (it == index.end()) return nullptr;
    return &students[it->second];
}

// ================== DELETE ==================

void StudentManager::deleteStudentById(int id) {
    if (!index.count(id)) {
        std::cout << "Student not found\n";
        return;
    }

    saveAction();

    int idx = index[id];
    int lastIdx = students.size() - 1;

    if (idx != lastIdx) {
        students[idx] = students[lastIdx];
        index[students[idx].getId()] = idx;
    }

    students.pop_back();
    index.erase(id);

    std::cout << "Student deleted\n";
}

// ================== SEARCH ==================

void StudentManager::findStudentsByField(Field field, const std::string& value) {
    std::string searchVal = toLower(value);
    bool found = false;

    for (auto& s : students) {
        std::string fieldVal =
            (field == NAME) ? s.getName() : s.getSurname();

        if (toLower(fieldVal).find(trim(searchVal)) != std::string::npos) {
            s.display();
            found = true;
        }
    }

    if (!found) std::cout << "No students found\n";
}

// ================== FILE ==================

void StudentManager::saveToFile(const std::string& filename) {
    std::ofstream file(filename);
    if (!file) {
        std::cout << "File error\n";
        return;
    }

    json j = json::array();

    for (const auto& s : students) {
        j.push_back({
            {"id", s.getId()},
            {"name", s.getName()},
            {"surname", s.getSurname()},
            {"age", s.getAge()},
            {"gpa", s.getGpa()}
        });
    }

    file << j.dump(4);
}
void StudentManager::loadFromFile(const std::string& filename) {
    std::ifstream file(filename);

    if (!file) {
        std::cout << "File error\n";
        return;
    }

    if (!students.empty()) saveAction();

    json j;

    if (file.peek() == std::ifstream::traits_type::eof()) {
        return;
    }

    try {
        file >> j;
    } catch (...) {
        std::cout << "Invalid JSON format\n";
        return;
    }

    students.clear();
    index.clear();

    for (const auto& item : j) {
        Student s;
        s.setData(
            item.value("id", 0),
            item.value("name", ""),
            item.value("surname", ""),
            item.value("age", 0),
            item.value("gpa", 0.0f)
        );

        students.push_back(s);
    }

    rebuildIndex();
}

// ================== SORT ==================

void StudentManager::sortStudentsByField(Field field) {
    saveAction();

    std::sort(students.begin(), students.end(),
        [field](const Student& a, const Student& b) {
            switch (field) {
                case ID: return a.getId() < b.getId();
                case GPA: return a.getGpa() > b.getGpa();
                case AGE: return a.getAge() > b.getAge();
                case NAME: return a.getName() < b.getName();
                case SURNAME: return a.getSurname() < b.getSurname();
            }
            return false;
        });

    rebuildIndex();
}

// ================== UPDATE ==================

void StudentManager::updateStudent(Student* student) {
    std::string input;
    int currentIndex = index[student->getId()];

    bool changed = false;
    bool saved = false;

    auto saveOnce = [&]() {
        if (!saved) {
            saveAction();
            saved = true;
        }
    };

    // ID
    std::cout << "Enter new id (>0, or skip): ";
    std::getline(std::cin, input);

    if (!input.empty()) {
        try {
            int id = std::stoi(input);

            if (id <= 0 || (index.count(id) && id != student->getId())) {
                std::cout << "Invalid ID\n";
                return;
            }

            if (id != student->getId()) {
                saveOnce();

                index.erase(student->getId());
                student->setId(id);
                index[id] = currentIndex;

                changed = true;
            }

        } catch (...) {
            std::cout << "Invalid ID\n";
            return;
        }
    }

    // NAME
    std::cout << "Enter new name: ";
    std::getline(std::cin, input);
    if (!input.empty()) {
        saveOnce();
        student->setName(input);
        changed = true;
    }

    // SURNAME
    std::cout << "Enter new surname: ";
    std::getline(std::cin, input);
    if (!input.empty()) {
        saveOnce();
        student->setSurname(input);
        changed = true;
    }

    // AGE
    std::cout << "Enter new age: ";
    std::getline(std::cin, input);
    if (!input.empty()) {
        try {
            int age = std::stoi(input);
            if (age <= 0) throw;

            saveOnce();
            student->setAge(age);
            changed = true;

        } catch (...) {
            std::cout << "Invalid age\n";
            return;
        }
    }

    // GPA
    std::cout << "Enter new gpa: ";
    std::getline(std::cin, input);
    if (!input.empty()) {
        try {
            float gpa = std::stof(input);
            if (gpa < 0 || gpa > 5) throw;

            saveOnce();
            student->setGpa(gpa);
            changed = true;

        } catch (...) {
            std::cout << "Invalid GPA\n";
            return;
        }
    }

    if (changed)
        std::cout << "Updated\n";
    else
        std::cout << "No changes made\n";
}

// ================== FILTER ==================

void StudentManager::filterByGPA(float min) {
    bool found = false;

    for (auto& s : students) {
        if (s.getGpa() >= min) {
            s.display();
            found = true;
        }
    }

    if (!found) std::cout << "No students found\n";
}

void StudentManager::filterByAge(int min, int max) {
    bool found = false;

    for (auto& s : students) {
        if (s.getAge() >= min && s.getAge() <= max) {
            s.display();
            found = true;
        }
    }

    if (!found) std::cout << "No students found\n";
}

// ================== FULL SEARCH ==================

void StudentManager::searchStudent(const std::string& query) {
    std::stringstream ss(query);
    std::string word;

    std::vector<std::string> words;
    while (ss >> word) {
        words.push_back(toLower(word));
    }

    if (words.empty()) {
        std::cout << "Empty query\n";
        return;
    }

    for (auto& s : students) {
        std::string full = toLower(s.getName() + " " + s.getSurname());

        bool match = true;
        for (auto& w : words) {
            if (full.find(w) == std::string::npos) {
                match = false;
                break;
            }
        }

        if (match) s.display();
    }
}