StudentRepository.cpp

// Project files
#include "StudentRepository.h"
#include "InputUtils.h"

// Defauld models
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <algorithm>
#include <limits>


// utitlities
static void ignoreLine() {
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
}

Node* findNodeById(Node* head, int id) {
    Node* cur = head;
    while (cur) {
        if (cur->student && cur->student->getID() == id) {
            return cur;
        }
        cur = cur->next;
    }
    return nullptr;
}


Node* findNodePrevByID(Node* head, int id) {
    Node* prev = nullptr;
    Node* cur = head;
    while (cur)
    {
        if (cur->student && cur->student->getID() == id) { return prev; }
        prev = cur;
        cur = cur->next;
    }
    return nullptr;
}


Student* findStudentByID(Node* head, int id) {
    Node* n = findNodeById(head, id);
    if (!n) { return nullptr;}
    return n->student;
}

// CRUD (Create, Read, Update, Delete)
void addStudent(Node*& head) {
    std::string name = getStringInput("Enter name: ");
    int id = getIntInput("Enter ID (Integer): ");

    if (findStudentByID(head, id)) {
        std::cout << "A student with this ID already exists.\n";
        return;
    }
    int age = getIntInput("Enter age: ");
    int gradesCount = getIntInput("Number of grades: ");
    if (gradesCount < 0) gradesCount = 0;
    Student* s = new Student(name, id, age, gradesCount);
    for (int i = 0; i < gradesCount; ++i) {
        float g = getFloatInput(("Grade #" + std::to_string(i+1) + ":").c_str());
        s->setGrade(i, g);
    }

    Node* node = new Node(s);
    if (!head) {
        head = node;
    } else {
        Node* cur = head;
        while (cur->next) 
        {
            cur = cur->next;
        }
        cur->next = node;
    }
    std::cout << "Student added.\n";
}

// Information students
void displayStudents(Node* head) {
    if (!head) {
        std::cout << "List is empty\n";
        return;
    }
    std::cout << "Students:\n";
    Node* cur = head;
    while (cur) {
        if (cur->student) cur->student->displayInfo();
        cur = cur->next;
    }
}

// Get student by id and update fields 
void updateStudent(Node* head, int id) {
    Student* s = findStudentByID(head, id);
    if (!s) {
        std::cout << "Student not found.\n";
        return;
    }

    std::cout << "Updating student (current values):\n";
    s->displayInfo();

    // цикл выбора поля для обновления (без раннего return)
    while (true) {
        std::cout << "\nChoose field to update:\n";
        std::cout << "1. Name\n2. Age\n3. Grades\n0. Finish\nChoice: ";
        int ch;
        if (!(std::cin >> ch)) {
            std::cin.clear();
            ignoreLine();
            ch = -1;
        } else ignoreLine();

        if (ch == 0) break;

        // получаем указатель на узел, чтобы заменить student* при необходимости
        Node* n = findNodeById(head, id);
        if (!n) {
            std::cout << "Unexpected: node not found.\n";
            return;
        }

        switch (ch) 
        {
            case 1: {
                std::string newName = getStringInput("New name: ");
                if (newName.empty()) { std::cout << "Name unchanged.\n"; continue; }

                int age = s->getAge();
                int gcount = s->getGradesCount();
                Student* newS = new Student(newName, s->getID(), age, gcount);
                for (int i = 0; i < gcount; ++i) newS->setGrade(i, s->getGrade(i));

                delete n->student;        // удаляем старый объект
                n->student = newS;        // ставим новый
                s = newS;                 // продолжаем работать с новым объектом
                std::cout << "Name updated.\n";
            }

            case 2: {
                int newAge = getIntInput("New age: ");
                std::string name = s->getName();
                int gcount = s->getGradesCount();
                Student* newS = new Student(name, s->getID(), newAge, gcount);
                for (int i = 0; i < gcount; ++i) newS->setGrade(i, s->getGrade(i));

                delete n->student;
                n->student = newS;
                s = newS;
                std::cout << "Age updated.\n";
            }

            case 3: {
                // Baholar qoshiladi lekin ozgartirilmaydi 
                int newCount = getIntInput("New grades count: ");
                if (newCount < 0) newCount = 0;
                std::string name = s->getName();
                int age = s->getAge();
                Student* newS = new Student(name, s->getID(), age, newCount);
                int copyCount = std::min(s->getGradesCount(), newCount);
                for (int i = 0; i < copyCount; ++i) newS->setGrade(i, s->getGrade(i));
                for (int i = copyCount; i < newCount; ++i) {
                    float g = getFloatInput(("Grade #" + std::to_string(i+1) + ": ").c_str());
                    newS->setGrade(i, g);
                }

                delete n->student;
                n->student = newS;
                s = newS;
                std::cout << "Grades updated.\n";
            }
            
            default: {
                std::cout << "Unknown choice\n";
            }
        }
    }

    std::cout << "Update finished.\n";
}

// Delete student by id
void deleteStudent(Node*& head, int id) {
    if (!head) {std::cout << "List empty.\n"; return; }

    Node* prev = nullptr;
    Node* cur = head;
    while (cur)
    {
        if (cur->student && cur->student->getID() == id) break;
        prev = cur; 
        cur = cur->next;
    }
    if (!cur) { std:: cout << "Student not found.\n"; return; }

    if (prev == nullptr) {
        head = cur->next;
    } else {
        prev->next = cur->next;
    }
    
    delete cur->student;
    delete cur;
    std::cout << "Student deleted.\n";
}

// Clear list of students
void clearList(Node*& head) {
    Node* cur = head;
    while (cur) {
        Node* tmp = cur;
        cur = cur->next;
        delete tmp->student;
        delete tmp;
    }
    head = nullptr;
}

// convrt list -> vector, sort, rebuild
static std::vector<Student*> listToVector(Node* head) {
    std::vector<Student*> v;
    Node* cur = head;
    while (cur) {
        if (cur->student) v.push_back(cur->student);
        cur = cur->next;
    }
    return v;
}


static Node* vectorToList(const std::vector<Student*>& v) {
    Node* newHead = nullptr;
    Node* tail = nullptr;
    for (Student* s : v) {
        Node* node = new Node(s);
        if (!newHead) newHead = node;
        else tail->next = node;
        tail = node;
    }
    return newHead;
}


void sortByID(Node*& head) {
    auto v = listToVector(head);
    std::sort(v.begin(), v.end(), [](Student* a, Student* b){ return a->getID() < b->getID(); });
    // free old node wrappers but keep Student* pointers
    Node* cur = head;
    while (cur) { Node* tmp = cur; cur = cur->next; delete tmp; }
    head = vectorToList(v);
    std::cout << "Sorted by ID ascending.\n";
}


void sortByName(Node*& head) {
    auto v = listToVector(head);
    std::sort(v.begin(), v.end(), [](Student* a, Student* b){ return a->getName() < b->getName(); });
    Node* cur = head;
    while (cur) { Node* tmp = cur; cur = cur->next; delete tmp; }
    head = vectorToList(v);
    std::cout << "Sorted by name (A-Z).\n";
}


void sortByAverage(Node*& head) {
    auto v = listToVector(head);
    std::sort(v.begin(), v.end(), [](Student* a, Student* b){ return a->calculateAverage() > b->calculateAverage(); });
    Node* cur = head;
    while (cur) { Node* tmp = cur; cur = cur->next; delete tmp; }
    head = vectorToList(v);
    std::cout << "Sorted by average (descending).\n";
}