#include "Record.hpp"
#include "Tools.hpp"
#include <iomanip>
#include <iostream>

int BaseRecord::nextRecordID = 1;

BaseRecord::BaseRecord(const time_t _date, const std::string _courseName,
                       const int _studentNumber, const std::string _studentName)
    : recordID(nextRecordID++), date(_date), courseName(_courseName),
      student(_studentNumber, _studentName){};

BaseRecord::BaseRecord(const int _recordID, const time_t _date,
                       const std::string _courseName, const int _studentNumber,
                       const std::string _studentName)
    : recordID(_recordID), date(_date), courseName(_courseName),
      student(_studentNumber, _studentName){};

BaseRecord::~BaseRecord() {
}

const int BaseRecord::getRecordID() const {
    return this->recordID;
}

const Date &BaseRecord::getDate() const {
    return this->date;
}

const std::string BaseRecord::getCourseName() const {
    return this->courseName;
}

const int BaseRecord::getStudentNumber() const {
    return this->student.getNumber();
}

const std::string BaseRecord::getStudentName() const {
    return this->student.getName();
}

const Student &BaseRecord::getStudent() const {
    return this->student;
}

void BaseRecord::promptForNewDate(bool showOriginal) {
    time_t originTime = this->date.getTime();
    // tm *curDate = localtime(&originTime);

    tm curDate;

#if defined __APPLE__ || defined __linux__
    curDate = *(localtime(&originTime));
#endif

#if defined _WIN64 || defined _WIN32
    localtime_s(&curDate, &originTime);
#endif

    tm newDate;
    int tempInput;
    if (showOriginal) {
        char buffer[20];
        strftime(buffer, 20, "%F", &curDate);
        std::cout << setoutputcolor(ConsoleColorTool::green)
                  << "Current date: " << buffer
                  << ". Enter 0 to retain original value." << resetOutputColor
                  << std::endl;
        std::cout << setoutputcolor(ConsoleColorTool::blue)
                  << "Year: " << resetOutputColor << std::flush;
        // std::cin >> tempInput;
        // std::cin.ignore();
        tempInput = safeInputNum<int>("Please input a positive integer.\n",
                                      [](const int &num) { return num >= 0; });
        newDate.tm_year = (tempInput == 0 ? curDate.tm_year : tempInput - 1900);
        std::cout << setoutputcolor(ConsoleColorTool::blue)
                  << "Month: " << resetOutputColor << std::flush;
        // std::cin >> tempInput;
        // std::cin.ignore();
        tempInput = safeInputNum<int>("Please input a positive integer.\n",
                                      [](const int &num) { return num >= 0; });
        newDate.tm_mon = (tempInput == 0 ? curDate.tm_mon : tempInput - 1);
        std::cout << setoutputcolor(ConsoleColorTool::blue)
                  << "Day: " << resetOutputColor << std::flush;
        // std::cin >> tempInput;
        // std::cin.ignore();
        tempInput = safeInputNum<int>("Please input a positive integer.\n",
                                      [](const int &num) { return num >= 0; });
        newDate.tm_mday = (tempInput == 0 ? curDate.tm_mday : tempInput);
    }
    else {
        std::cout << setoutputcolor(ConsoleColorTool::blue)
                  << "Year: " << resetOutputColor << std::flush;
        // std::cin >> tempInput;
        // std::cin.ignore();
        tempInput = safeInputNum<int>("Please input a positive integer.\n",
                                      [](const int &num) { return num > 0; });
        newDate.tm_year = tempInput - 1900;
        std::cout << setoutputcolor(ConsoleColorTool::blue)
                  << "Month: " << resetOutputColor << std::flush;
        // std::cin >> tempInput;
        // std::cin.ignore();
        tempInput = safeInputNum<int>("Please input a positive integer.\n",
                                      [](const int &num) { return num > 0; });
        newDate.tm_mon = tempInput - 1;
        std::cout << setoutputcolor(ConsoleColorTool::blue)
                  << "Day: " << resetOutputColor << std::flush;
        // std::cin >> tempInput;
        // std::cin.ignore();
        tempInput = safeInputNum<int>("Please input a positive integer.\n",
                                      [](const int &num) { return num > 0; });
        newDate.tm_mday = tempInput;
    }
    this->date = mktime(&newDate);
}

void BaseRecord::promptForNewCourseName(bool showOriginal) {
    std::string tempCourseName;
    if (showOriginal) {
        std::cout << setoutputcolor(ConsoleColorTool::green)
                  << "Original course name: " << resetOutputColor
                  << this->courseName << "\n"
                  << setoutputcolor(ConsoleColorTool::green)
                  << "Enter 0 to retain original value." << resetOutputColor
                  << std::endl;
        std::cout << setoutputcolor(ConsoleColorTool::blue)
                  << "Course name: " << resetOutputColor << std::flush;

        std::getline(std::cin, tempCourseName);
        this->courseName =
            (tempCourseName == "0" ? this->courseName : tempCourseName);
    }
    else {
        std::cout << "Course name: " << std::flush;
        // std::cin >> this->courseName;
        // std::cin.ignore();
        std::getline(std::cin, courseName);
    }
}

void BaseRecord::promptForNewStudentInfo(bool showOriginal) {
    int tempStuID;
    std::string tempStuName;
    if (showOriginal) {
        std::cout << setoutputcolor(ConsoleColorTool::green)
                  << "Current student info: \n"
                  << setoutputcolor(ConsoleColorTool::blue)
                  << "Student ID: " << resetOutputColor
                  << this->student.getNumber() << "\n"
                  << setoutputcolor(ConsoleColorTool::blue)
                  << "Student Name: " << resetOutputColor
                  << this->student.getName() << "\n"
                  << setoutputcolor(ConsoleColorTool::green)
                  << "Enter 0 to retain original value." << std::endl;
        std::cout << setoutputcolor(ConsoleColorTool::blue)
                  << "Student ID: " << resetOutputColor << std::flush;
        // std::cin >> tempStuID;
        // std::cin.ignore();
        tempStuID = safeInputNum<int>("Please input a positive integer.\n",
                                      [](const int &num) { return num >= 0; });
        this->student.setNumber(tempStuID == 0 ? this->student.getNumber()
                                               : tempStuID);
        std::cout << setoutputcolor(ConsoleColorTool::blue)
                  << "Student Name: " << resetOutputColor << std::flush;
        std::getline(std::cin, tempStuName);
        this->student.setName(tempStuName == "0" ? this->student.getName()
                                                 : tempStuName);
    }
    else {
        std::cout << setoutputcolor(ConsoleColorTool::blue)
                  << "Student ID: " << resetOutputColor << std::flush;
        // std::cin >> tempStuID;
        // std::cin.ignore();
        tempStuID = safeInputNum<int>("Please input a positive integer.\n",
                                      [](const int &num) { return num > 0; });
        this->student.setNumber(tempStuID);
        std::cout << setoutputcolor(ConsoleColorTool::blue)
                  << "Student Name: " << resetOutputColor << std::flush;
        // std::cin >> tempStuName;
        // std::cin.ignore();
        std::getline(std::cin, tempStuName);
        this->student.setName(tempStuName);
    }
}

void BaseRecord::display() const {
    std::cout << "│   " << std::setfill('0')
              << std::setw(recordDisplayRowSize.recordID - 2) << this->recordID;
    std::cout << " │ ";
    std::cout << std::setfill(' ') << std::setw(recordDisplayRowSize.date)
              << cutToLength(this->date.toString(), recordDisplayRowSize.date);
    std::cout << " │ ";
    std::cout << std::setfill(' ') << std::setw(recordDisplayRowSize.courseName)
              << cutToLength(this->courseName, recordDisplayRowSize.courseName);
    std::cout << " │ ";
    std::cout << std::setfill(' ') << std::setw(recordDisplayRowSize.studentID)
              << this->student.getNumber();
    std::cout << " │ ";
    std::cout << std::setfill(' ')
              << std::setw(recordDisplayRowSize.studentName)
              << cutToLength(this->student.getName(),
                             recordDisplayRowSize.studentName);
    std::cout << " │ ";
    std::cout << std::setfill(' ') << std::setw(recordDisplayRowSize.type)
              << this->getRecordTypeString() << " │";
    std::cout << std::endl;
}

void BaseRecord::displayComplete() const {
    std::cout << setoutputcolor(true) << setbgcolor(ConsoleColorTool::magenta)
              << "Record ID " << this->recordID << resetOutputColor << "\n";
    std::cout << setoutputcolor(ConsoleColorTool::green)
              << "Date: " << resetOutputColor << this->date.toString() << "\n";
    std::cout << setoutputcolor(ConsoleColorTool::green)
              << "Course name: " << resetOutputColor << this->courseName
              << "\n";
    std::cout << setoutputcolor(ConsoleColorTool::green)
              << "Student: " << resetOutputColor << "\n";
    std::cout << "├─" << setoutputcolor(ConsoleColorTool::blue)
              << "ID: " << resetOutputColor << this->student.getNumber()
              << "\n";
    std::cout << "└─" << setoutputcolor(ConsoleColorTool::blue)
              << "Name: " << resetOutputColor << this->student.getName()
              << "\n";
    std::cout << setoutputcolor(ConsoleColorTool::green)
              << "Type: " << resetOutputColor << this->getRecordTypeString()
              << std::endl;
}

LateRecord::LateRecord(const time_t _date, const std::string _courseName,
                       const int _studentNumber, const std::string _studentName)
    : BaseRecord(_date, _courseName, _studentNumber, _studentName){};

LateRecord::LateRecord(const int _recordID, const time_t _date,
                       const std::string _courseName, const int _studentNumber,
                       const std::string _studentName)
    : BaseRecord(_recordID, _date, _courseName, _studentNumber, _studentName){};

std::string LateRecord::getRecordTypeString() const {
    return "Late";
}

StuRecord::RecordType LateRecord::getRecordType() const {
    return StuRecord::Late;
}

LateRecord::operator SaveRecord() const {
    return SaveRecord{.recordID = this->recordID,
                      .date = this->date.getTime(),
                      .courseNameLength = this->courseName.length(),
                      .studentNumber = this->student.getNumber(),
                      .studentNameLength = this->student.getName().length(),
                      .recordType = StuRecord::Late};
}

LateRecord::~LateRecord(){};

AbsentRecord::AbsentRecord(const time_t _date, const std::string _courseName,
                           const int _studentNumber,
                           const std::string _studentName)
    : BaseRecord(_date, _courseName, _studentNumber, _studentName){};

AbsentRecord::AbsentRecord(const int _recordID, const time_t _date,
                           const std::string _courseName,
                           const int _studentNumber,
                           const std::string _studentName)
    : BaseRecord(_recordID, _date, _courseName, _studentNumber, _studentName){};

std::string AbsentRecord::getRecordTypeString() const {
    return "Absent";
}

StuRecord::RecordType AbsentRecord::getRecordType() const {
    return StuRecord::Absent;
}

AbsentRecord::operator SaveRecord() const {
    return SaveRecord{.recordID = this->recordID,
                      .date = this->date.getTime(),
                      .courseNameLength = this->courseName.length(),
                      .studentNumber = this->student.getNumber(),
                      .studentNameLength = this->student.getName().length(),
                      .recordType = StuRecord::Absent};
}

AbsentRecord::~AbsentRecord(){};

PersonalLeaveRecord::PersonalLeaveRecord(const time_t _date,
                                         const std::string _courseName,
                                         const int _studentNumber,
                                         const std::string _studentName)
    : BaseRecord(_date, _courseName, _studentNumber, _studentName){};

PersonalLeaveRecord::PersonalLeaveRecord(const int _recordID,
                                         const time_t _date,
                                         const std::string _courseName,
                                         const int _studentNumber,
                                         const std::string _studentName)
    : BaseRecord(_recordID, _date, _courseName, _studentNumber, _studentName){};

std::string PersonalLeaveRecord::getRecordTypeString() const {
    return "Personal";
}

StuRecord::RecordType PersonalLeaveRecord::getRecordType() const {
    return StuRecord::PersonalLeave;
}

PersonalLeaveRecord::operator SaveRecord() const {
    return SaveRecord{.recordID = this->recordID,
                      .date = this->date.getTime(),
                      .courseNameLength = this->courseName.length(),
                      .studentNumber = this->student.getNumber(),
                      .studentNameLength = this->student.getName().length(),
                      .recordType = StuRecord::PersonalLeave};
}

PersonalLeaveRecord::~PersonalLeaveRecord(){};