BGTU_QUIZ

#include <iostream>
#include <fstream>
#include <string>
#include <set>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <unordered_map>

#define QUESTION_LENGTH 1024
#define RADNOM_UNIQUE_QUESTIONS_COUNT 7
#define MAX_QUESTIONS_COUNT_PER_TOPIC 10
#define QUESTION_ANSWERS_DIVIDER 'd'

#define TOPICS_COUNT 3
#define MAX_FINAL_TEST_QUESTIONS_COUNT 20

#define EXCELLENT_MARK_IN_PERCENTAGE 90
#define GOOD_MARK_IN_PERCENTAGE 80
#define SATISFIED_MARK_IN_PERCENTAGE 60
#define BAD_MARK_IN_PERCENTAGE 50

using namespace std;

unordered_map<string, int> topic_title_to_index_map;
unordered_map<int, string> topic_index_to_title_map;
unordered_map<int, string> topic_index_to_questions_file_map;
unordered_map<int, string> topic_index_to_answers_file_map;

struct QuestionAndAnswers {
    int number;
    int topic_index;
    string question;
    string answers;
};

struct FuckedUpQuestion {
    int number;
    string question;
};

void train_by_selected_topic() { // todo
    cout << "train_by_selected_topic";
}

int generate_random_qunique_questions(
    const QuestionAndAnswers all_questions[MAX_QUESTIONS_COUNT_PER_TOPIC],
    QuestionAndAnswers random_questions[RADNOM_UNIQUE_QUESTIONS_COUNT]
) {
    srand(time(0));
    set<int> seen_question;

    int curr = 0;

    while(curr < RADNOM_UNIQUE_QUESTIONS_COUNT) {
        int random_question_index = 0 + (rand() % MAX_QUESTIONS_COUNT_PER_TOPIC);
        if(seen_question.count(random_question_index) <= 0) {
            seen_question.insert(random_question_index);
            random_questions[curr++] = all_questions[random_question_index];
        }
    }
}

vector<string> split_string(const string& s, char delimiter) {
    vector<string> tokens;
    size_t start = 0, end = 0;
    while ((end = s.find(delimiter, start)) != string::npos) {
        tokens.push_back(s.substr(start, end - start));
        start = end + 1;
    }
    tokens.push_back(s.substr(start));
    return tokens;
}

string generate_formatted_answer(string answer) {
    vector<string> answers = split_string(answer, QUESTION_ANSWERS_DIVIDER);
        string formatted_answer = "";
        if(answers.size() > 0) {
            for (const string& answer : answers) {
                formatted_answer = formatted_answer + "\n" + answer;
            }
        } else {
            formatted_answer = answer;
        }

    return formatted_answer;
}

void generate_quesitons_and_answers_by_topic(string file_name, string topic, QuestionAndAnswers all_questions[MAX_QUESTIONS_COUNT_PER_TOPIC]) {
    ifstream file(file_name);
    string q_number, q, a, divider;

    int question_index = 0;
    while(getline(file, q_number) && getline(file, q) && getline(file, a) && getline(file, divider)) {
        QuestionAndAnswers question;
        question.number = stoi(q_number);
        question.question = q;
        question.topic_index = topic_title_to_index_map[topic];
        question.answers = generate_formatted_answer(a);

        all_questions[question_index++] = question;
    }
}

void generate_correct_answers_by_topic(string file_name, int correct_answers[MAX_QUESTIONS_COUNT_PER_TOPIC]) {
    ifstream file(file_name);
    string answer;
    int ans_index = 0;
    while(getline(file, answer)) {
        correct_answers[ans_index++] = stoi(answer, nullptr, 10);
    }
}

void print_errors_after_quiz_if_needed(int size, FuckedUpQuestion *fucked_up_questions) {
    if(size > 0) {

        cout << "Count of fucked up questions - " << size << endl;
        for(int i = 0; i < size; i++) {
            FuckedUpQuestion question = fucked_up_questions[i];
            cout << "Q" << question.number << ": " << question.question << endl;
        }
    } else {
        cout << "You have answered all the questions correctly! Congrats!!!";
    }
}

int calculate_mark(int fucked_questions_size, int all_questions_size) {
    int mark = -1;

    double in_percentage = (double(all_questions_size - fucked_questions_size) / double(all_questions_size)) * 100;
    if(in_percentage >= EXCELLENT_MARK_IN_PERCENTAGE) {
        mark = 5;
    } else {
        if(in_percentage >= GOOD_MARK_IN_PERCENTAGE) {
            mark = 4;
        } else {
            if(in_percentage >= SATISFIED_MARK_IN_PERCENTAGE) {
                mark = 3;
            } else {
                mark = 2;
            }
        }
    }

    return mark;
}

void test_by_selected_topic() {
    cout << endl << "------Choose the topic------" << endl;
    int chosen_topic = -1;

    while(true) {
        for(int index = 0; index < TOPICS_COUNT; index++) {
            cout << endl << (index + 1) << " - " << topic_index_to_title_map[index];
        }
        cout << endl << "0 - Exit: ";

        cin >> chosen_topic;

        if(chosen_topic == 0) break;
        if(chosen_topic >= 1 && chosen_topic <= TOPICS_COUNT) break;
    }

    if (chosen_topic == 0) return;

    int chosen_topic_index = chosen_topic - 1;

    int correct_answers[MAX_QUESTIONS_COUNT_PER_TOPIC];
    generate_correct_answers_by_topic(topic_index_to_answers_file_map[chosen_topic_index], correct_answers);

    QuestionAndAnswers all_questions[MAX_QUESTIONS_COUNT_PER_TOPIC];

    generate_quesitons_and_answers_by_topic(
        topic_index_to_questions_file_map[chosen_topic_index],
        topic_index_to_title_map[chosen_topic_index], all_questions
    );

    QuestionAndAnswers random_questions[RADNOM_UNIQUE_QUESTIONS_COUNT];
    generate_random_qunique_questions(all_questions, random_questions);


    FuckedUpQuestion *fucked_up_questions = NULL;
    int fuckued_up_question_index = 0;

    for(int i = 0; i < RADNOM_UNIQUE_QUESTIONS_COUNT; i++) {
        QuestionAndAnswers question = random_questions[i];
        int correct_anwer_to_the_question = correct_answers[question.number - 1];

        int answer = -1;
        while(true) {
            cout << endl << endl << "Q" << question.number << ": " << question.question << "\n " << question.answers << ": ";
            cin >> answer;
            if(answer > 0 && answer < 5) break;
        }

        if(correct_anwer_to_the_question != answer) {
            fucked_up_questions = (FuckedUpQuestion*)realloc(fucked_up_questions, sizeof(FuckedUpQuestion) * (fuckued_up_question_index + 1));

            FuckedUpQuestion fucked_up_question;
            fucked_up_question.number = question.number;
            fucked_up_question.question = question.question;

            fucked_up_questions[fuckued_up_question_index++] = fucked_up_question;
        }
    }

    cout << endl << "Your mark is " << calculate_mark(fuckued_up_question_index, RADNOM_UNIQUE_QUESTIONS_COUNT) << endl;
    print_errors_after_quiz_if_needed(fuckued_up_question_index, fucked_up_questions);

}

void pass_final_test() {
    srand(time(0));

    QuestionAndAnswers topic_to_question_and_answers[TOPICS_COUNT][MAX_QUESTIONS_COUNT_PER_TOPIC];
    int topic_to_question_answer[TOPICS_COUNT][MAX_QUESTIONS_COUNT_PER_TOPIC];

    for(int i = 0; i < TOPICS_COUNT; i++) {
        string questions_file_name = topic_index_to_questions_file_map[i];
        string answers_file_name = topic_index_to_answers_file_map[i];
        generate_quesitons_and_answers_by_topic(questions_file_name, topic_index_to_title_map[i], topic_to_question_and_answers[i]);
        generate_correct_answers_by_topic(answers_file_name, topic_to_question_answer[i]);
    }

    int curr = 0;
    int last_topic_index = -1;
    set<string> seen;

    QuestionAndAnswers random_questions[MAX_FINAL_TEST_QUESTIONS_COUNT];
    while(curr < MAX_FINAL_TEST_QUESTIONS_COUNT) {
        int rand_topic_index = 0 + (rand() % TOPICS_COUNT);
        if(last_topic_index == rand_topic_index) continue;
            int rand_question_by_topic_index = 0 + (rand() % MAX_QUESTIONS_COUNT_PER_TOPIC);
            string question_id = topic_index_to_questions_file_map[rand_topic_index] + ":" + to_string(rand_question_by_topic_index);
            if(seen.count(question_id) <= 0) {
                seen.insert(question_id);
                random_questions[curr++] = topic_to_question_and_answers[rand_topic_index][rand_question_by_topic_index];
                last_topic_index = rand_topic_index;
            }
    }

    FuckedUpQuestion *fucked_up_questions = NULL;
    int fuckued_up_question_index = 0;

    for(int i = 0; i < MAX_FINAL_TEST_QUESTIONS_COUNT; i++) {
        QuestionAndAnswers question = random_questions[i];
        int correct_anwer_to_the_question = topic_to_question_answer[question.topic_index][question.number - 1];

        int answer = -1;
        while(true) {
            cout << endl << endl << "Q" << question.number << ": " << question.question << "\n " << question.answers << ": ";
            cin >> answer;
            if(answer > 0 && answer < 5) break;
        }

        if(correct_anwer_to_the_question != answer) {
            fucked_up_questions = (FuckedUpQuestion*)realloc(fucked_up_questions, sizeof(FuckedUpQuestion) * (fuckued_up_question_index + 1));

            FuckedUpQuestion fucked_up_question;
            fucked_up_question.number = question.number;
            fucked_up_question.question = question.question;

            fucked_up_questions[fuckued_up_question_index++] = fucked_up_question;
        }
    }

    cout << endl << "Your mark is " << calculate_mark(fuckued_up_question_index, MAX_FINAL_TEST_QUESTIONS_COUNT);
}

void init_quiz_components() {
    topic_title_to_index_map["T1"] = 0;
    topic_title_to_index_map["T2"] = 1;
    topic_title_to_index_map["T3"] = 2;

    topic_index_to_title_map[0] = "T1";
    topic_index_to_title_map[1] = "T2";
    topic_index_to_title_map[2] = "T3";

    topic_index_to_questions_file_map[0] = "q_and_a/questions_1.txt";
    topic_index_to_questions_file_map[1] = "q_and_a/questions_2.txt";
    topic_index_to_questions_file_map[2] = "q_and_a/questions_3.txt";

    topic_index_to_answers_file_map[0] = "q_and_a/correct_answers_1.txt";
    topic_index_to_answers_file_map[1] = "q_and_a/correct_answers_2.txt";
    topic_index_to_answers_file_map[2] = "q_and_a/correct_answers_3.txt";
}

void show_student_menu() {
    cout << endl << "------Student menu------" << endl;

    init_quiz_components();

    int menu_item = -1;
    while(true) {
         cout << "\n1 - Training by a topic"
        << "\n2 - Testing by a topic"
        << "\n3 - Final test"
        << "\n0 - Exit: ";
         cin >> menu_item;

        if(menu_item == 0) break;

        switch(menu_item) {
            case 1: train_by_selected_topic(); break;
            case 2: test_by_selected_topic(); break;
            case 3: pass_final_test(); break;
            default: cout << endl << "Menu item by " << menu_item << " cannot be found" << endl;
        }
    }
}

int main() {
    int menu_item = -1;

    while(true) {
         cout << endl << "Login yourself. "
         << "\n 1 - Teacher"
         << "\n 2 - Student"
         << "\n 0 - Exit: ";
         cin >> menu_item;

        if (menu_item == 0) break;

        switch(menu_item) {
            case 1: break; // todo login as a teacher
            case 2: show_student_menu(); break; // todo login as a student
            default: cout << endl << "Menu item by " << menu_item << " cannot be found" << endl; break;
        }
    }

    return 0;
}