lesson_test.cpp

#include "lesson_test.hpp"
#include "zip/miniz.h"
#include <algorithm>
#include <cstdint>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <sstream>

#if _WIN32
#include <windows.h>
#endif

namespace lesson_test
{

std::string read()
{
    std::string str;
    std::getline(std::cin, str);
    while (!str.empty())
    {
        auto back = str.back();
        if (back == '\n' || back == '\t' || back == ' ')
        {
            str.pop_back();
            continue;
        }
        break;
    }
    return str;
}

MCQ::MCQ(std::string_view question, std::vector<std::pair<std::string_view, bool>> &&options, std::string_view hint,
         std::string_view solution)
{
    this->info.question = std::string{question};
    std::uint32_t index{0};
    for (const auto &[text, is_answer] : options)
    {
        this->info.options.emplace_back(std::string{text});
        if (is_answer)
            this->info.answer += static_cast<char>('A' + index);
        ++index;
    }
    this->info.hint = std::string{hint};
    this->info.solution = std::string{solution};
}

void MCQ::test() const
{
    std::cout << this->info.question << std::endl << std::endl;
    std::cout << "选项：" << std::endl;
    std::size_t index{0};
    for (const auto context : this->info.options)
    {
        std::cout << static_cast<char>('A' + index) << '.' << context << std::endl;
        ++index;
    }
    std::cout << std::endl;
    if (!this->info.hint.empty())
        std::cout << "ℹ️ 提示：" << info.hint << std::endl << std::endl;
    bool is_correct{false};
    bool has_input{false};
    while (true)
    {
        std::cout << "输入你的答案：";
        auto user_input = read();
        user_input.erase(std::remove_if(user_input.begin(), user_input.end(), [](auto ch) { return std::isspace(ch); }),
                         user_input.end());
        if (user_input.length() >= 1)
        {
            has_input = true;
            std::transform(user_input.begin(), user_input.end(), user_input.begin(),
                           [](auto ch) { return std::toupper(ch); });
            std::sort(user_input.begin(), user_input.end());
            if (user_input == this->info.answer)
            {
                is_correct = true;
                if (this->type == test_type::practice)
                    std::cout << "✅ 正确" << std::endl << std::endl;
            }
            else if (this->type == test_type::practice)
            {
                std::cout << "❌ 错误" << std::endl << std::endl;
            }
        }
        else
        {
            std::cout << "你没有输入任何字符" << std::endl << std::endl;
        }
        if (type == test_type::examination && has_input)
        {
            std::cout << std::endl;
            score_percent = 0;
            return;
        }
        if (is_correct)
            break;
    }
    if (!this->info.solution.empty())
        std::cout << "📝 解析：" << this->info.solution << std::endl << std::endl;
    score_percent = 1;
    return;
}

CRP::CRP(std::string_view source_code)
{
    this->source_code = source_code;
}

void CRP::add(std::string_view input, std::string_view answer, std::string_view hint, std::string_view solution)
{
    test_info info;
    info.input = std::string{input};
    info.answer = this->split(answer);
    info.hint = std::string{hint};
    info.solution = std::string{solution};
    this->infos.emplace_back(std::move(info));
}

void CRP::add(std::string_view input, const std::function<void()> &answer, std::string_view hint,
              std::string_view solution)
{
    test_info info;
    info.input = std::string{input};
    std::ostringstream oss;
    std::streambuf *oldBuf = std::cout.rdbuf(oss.rdbuf());
    answer();
    std::cout.rdbuf(oldBuf);
    info.answer = this->split(oss.str());
    info.hint = std::string{hint};
    info.solution = std::string{solution};
    this->infos.emplace_back(std::move(info));
}

std::vector<std::string> CRP::split(std::string_view output) const
{
    std::istringstream iss{std::string{output}};
    std::vector<std::string> realLines;
    std::string line;
    while (std::getline(iss, line))
    {
        realLines.push_back(line);
    }
    return realLines;
}

void CRP::test() const
{
    std::cout << "源代码：" << std::endl;
    std::cout << this->source_code << std::endl << std::endl;
    std::uint64_t test_group_number{this->infos.size()};
    std::int32_t pass_number{0};
    for (auto info : this->infos)
    {
        std::int32_t attempt{1};
        while (true)
        {
            if (!info.input.empty())
            {
                std::cout << "输入：" << std::endl;
                std::cout << info.input << std::endl << std::endl;
            }

            if (!info.hint.empty())
                std::cout << "ℹ️ 提示：" << info.hint << std::endl << std::endl;

            std::cout << "程序应该输出：" << std::endl;

            bool all_correct{true};
            for (size_t i = 0; i < info.answer.size(); ++i)
            {
                std::cout << "第 " << (i + 1) << " 行: ";
                auto user_ans = read();
                if (user_ans == info.answer[i])
                {
                    if (this->type == test_type::practice)
                        std::cout << "✅ 正确" << std::endl << std::endl;
                }
                else
                {
                    if (this->type == test_type::practice)
                        std::cout << "❌ 错误" << std::endl << std::endl;
                    all_correct = false;
                    break;
                }
            }
            if (type == test_type::examination)
            {
                std::cout << std::endl;
                if (all_correct)
                    ++pass_number;
                break;
            }

            if (all_correct)
            {
                std::cout << "全部正确！共 " << info.answer.size() << " 行，尝试次数：" << attempt << std::endl
                          << std::endl;
                break;
            }
            ++attempt;
        }

        if (!info.solution.empty())
        {
            if (type == test_type::practice)
                std::cout << "📝 解析：" << info.solution << std::endl << std::endl;
        }
    }
    score_percent = static_cast<double>(pass_number) / test_group_number;
    return;
}

ICP::ICP(unsigned char *zip, unsigned int size, std::string_view path, std::string_view key)
{
    info.data = zip;
    info.size = size;
    info.path = std::string{path};
    info.key = std::string{path};
}

void ICP::write_zip() const
{
    std::ofstream f(info.path, std::ios::binary);
    f.write((const char *)info.data, info.size);
}

void ICP::unzip() const
{
    mz_zip_archive zip{};
    mz_zip_zero_struct(&zip);
    mz_zip_reader_init_file(&zip, info.path.c_str(), 0);
    int file_count = (int)mz_zip_reader_get_num_files(&zip);
    for (int i = 0; i < file_count; i++)
    {
        mz_zip_archive_file_stat st;
        mz_zip_reader_file_stat(&zip, i, &st);
        std::string out_path = std::string{"./"} + st.m_filename;
        if (st.m_is_directory)
        {
            std::filesystem::create_directories(out_path);
        }
        else
        {
            std::filesystem::create_directories(std::filesystem::path(out_path).parent_path());
            mz_zip_reader_extract_to_file(&zip, i, out_path.c_str(), 0);
        }
    }
    mz_zip_reader_end(&zip);
}

void ICP::test() const
{
    while (true)
    {
        std::cout << "输入你获取到的key：";
        auto user_input = read();
        if (user_input.empty())
        {
            std::cout << "你没有输入任何字符" << std::endl << std::endl;
            continue;
        }
        if (user_input == info.key)
            this->score_percent = 1;
        if (type == test_type::examination)
            break;
        if (this->score_percent == 1)
        {
            std::cout << "✅ 正确" << std::endl << std::endl;
            break;
        }
        else
            std::cout << "❌ 错误" << std::endl << std::endl;
    }
}

void interact_tester::set_console_utf8()
{
#if _WIN32
    SetConsoleCP(CP_UTF8);
    SetConsoleOutputCP(CP_UTF8);
#endif
}

interact_tester::interact_tester()
{
#if _WIN32
    this->set_console_utf8();
#endif
}

interact_tester::interact_tester(std::string_view title)
{
#if _WIN32
    this->set_console_utf8();
#endif
    this->title = std::string{title};
}

void interact_tester::add(base_question *question)
{
    this->question_list.emplace_back(question);
}

void interact_tester::run(test_type type)
{
    if (!this->title.empty())
    {
        std::cout << "😀 欢迎来到 " << title << " 测试程序!" << std::endl;
    }
    std::cout << "本次测试共有 " << question_list.size() << " 道题目" << std::endl << std::endl;
    std::uint64_t average_score{100 / question_list.size()};
    std::int32_t real_score{0};
    std::int32_t id{0};
    for (const auto question : question_list)
    {
        std::cout << "第 " << ++id << " 题：" << std::endl << std::endl;
        question->test();
        real_score += question->score_percent * average_score;
    }
    if (type == test_type::practice)
        std::cout << "🎉 恭喜通过所有测试！ 按回车键退出程序" << std::endl;
    else
        std::cout << "🎉 恭喜完成考试！ 得分：" << real_score << " 分 按回车键退出程序" << std::endl;
    std::cin.get();
}

} // namespace lesson_test