#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <sstream>
#include <iomanip>
#include <ctime>
#include <cstdlib>
#include <algorithm>
#include <dirent.h>
#include <sys/stat.h>
#include <cmath>
#include <memory>

#ifdef _WIN32
    #include <direct.h>
    #define MKDIR(path) _mkdir(path)
#endif

using namespace std;


// 题目生成器接口：用于生成不同类型的数学题目
class IQuestionGenerator {
public:
    virtual ~IQuestionGenerator() = default;
    virtual string generateQuestion() = 0;
    virtual string getType() const = 0;
};

// 用户管理器接口：用于管理用户登录、切换类型、记录题目等
class IUserManager {
public:
    virtual ~IUserManager() = default;
    virtual bool login(const string& username, const string& password) = 0;
    virtual void logout() = 0;
    virtual bool switchType(const string& type) = 0;
    virtual bool isQuestionDuplicate(const string& question) = 0;
    virtual void addQuestionToUserRecord(const string& question) = 0;
    virtual string getCurrentUser() const = 0;
    virtual string getCurrentType() const = 0;
    virtual bool getIsLoggedIn() const = 0;
};

// 文件操作接口：用于处理文件和目录相关操作
class IFileManager {
public:
    virtual ~IFileManager() = default;
    virtual bool createDirectory(const string& path) = 0;
    virtual bool directoryExists(const string& path) = 0;
    virtual vector<string> getFilesInDirectory(const string& path) = 0;
    virtual string trim(const string& str) = 0;
};


// 账户结构体：存储用户的用户名、密码和题目类型
struct Account {
    string username;
    string password;
    string type;
};

// 文件操作具体实现：实现文件和目录的创建、判断、遍历等功能
class FileManager : public IFileManager {
public:
    bool createDirectory(const string& path) override {
        return MKDIR(path.c_str()) == 0;
    }
    
    bool directoryExists(const string& path) override {
        DIR* dir = opendir(path.c_str());
        if (dir) {
            closedir(dir);
            return true;
        }
        return false;
    }
    
    vector<string> getFilesInDirectory(const string& path) override {
        vector<string> files;
        DIR* dir = opendir(path.c_str());
        if (dir) {
            struct dirent* entry;
            while ((entry = readdir(dir)) != nullptr) {
                string filename = entry->d_name;
                if (filename != "." && filename != "..") {
                    files.push_back(filename);
                }
            }
            closedir(dir);
        }
        return files;
    }
    
    string trim(const string& str) override {
        size_t start = str.find_first_not_of(" \t\n\r");
        size_t end = str.find_last_not_of(" \t\n\r");
        if (start == string::npos || end == string::npos) {
            return "";
        }
        return str.substr(start, end - start + 1);
    }
};

// 题目生成器基类：为题目生成器提供公共的随机数和表达式构建方法
class BaseQuestionGenerator : public IQuestionGenerator {
protected:
    int randomNumber(int min, int max) {
        return rand() % (max - min + 1) + min;
    }
    
    bool shouldAddParentheses(int operandCount) {
        if (operandCount <= 2) return false;
        return randomNumber(0, 1) == 1;
    }
    
    string addParenthesesToExpression(const vector<int>& operands, const vector<char>& operators) {
        if (operands.size() <= 2) {
            return buildExpression(operands, operators);
        }
        
        int parenthesesPos = randomNumber(0, operands.size() - 2);
        
        string expression;
        for (size_t i = 0; i < operands.size(); i++) {
            if (i == parenthesesPos) {
                expression += "(";
            }
            
            expression += to_string(operands[i]);
            
            if (i == parenthesesPos + 1) {
                expression += ")";
            }
            
            if (i < operators.size()) {
                expression += " " + string(1, operators[i]) + " ";
            }
        }
        
        return expression;
    }
    
    string buildExpression(const vector<int>& operands, const vector<char>& operators) {
        string expression = to_string(operands[0]);
        for (size_t i = 0; i < operators.size(); i++) {
            expression += " " + string(1, operators[i]) + " " + to_string(operands[i + 1]);
        }
        return expression;
    }
};

// 小学题目生成器：生成小学难度的数学题目
class PrimaryQuestionGenerator : public BaseQuestionGenerator {
public:
    string generateQuestion() override {
        int operandCount = randomNumber(2, 5);
        vector<int> operands;
        vector<char> operators;
        
        operands.push_back(randomNumber(1, 100));
        
        for (int i = 0; i < operandCount - 1; i++) {
            int opType = randomNumber(0, 3);
            int prev = operands.back();
            int next;
            switch (opType) {
                case 0:
                    next = randomNumber(1, 100);
                    operators.push_back('+');
                    operands.push_back(next);
                    break;
                case 1:
                    next = randomNumber(1, prev);
                    operators.push_back('-');
                    operands.push_back(next);
                    break;
                case 2:
                    next = randomNumber(1, 100);
                    operators.push_back('*');
                    operands.push_back(next);
                    break;
                case 3:
                    {
                        next = randomNumber(1, 10);
                        int result = randomNumber(1, 10);
                        int dividend = next * result;
                        operands.back() = dividend;
                        operators.push_back('/');
                        operands.push_back(next);
                    }
                    break;
            }
        }
        
        if (shouldAddParentheses(operandCount)) {
            return addParenthesesToExpression(operands, operators);
        } else {
            return buildExpression(operands, operators);
        }
    }
    
    string getType() const override {
        return "小学";
    }
};

// 初中题目生成器：生成初中难度的数学题目，包含平方和根号
class MiddleQuestionGenerator : public BaseQuestionGenerator {
private:
    string addParenthesesToAdvancedExpression(const string& expression, const vector<string>& operators) {
        if (operators.size() <= 1) return expression;
        
        vector<size_t> opPositions;
        size_t pos = 0;
        for (const auto& op : operators) {
            pos = expression.find(op, pos);
            if (pos != string::npos) {
                opPositions.push_back(pos);
                pos += op.length();
            }
        }
        
        if (opPositions.size() <= 1) return expression;
        
        int parenthesesPos = randomNumber(0, opPositions.size() - 2);
        
        string result = expression;
        
        size_t leftPos = opPositions[parenthesesPos];
        if (parenthesesPos > 0) {
            size_t prevOpEnd = opPositions[parenthesesPos - 1] + operators[parenthesesPos - 1].length();
            size_t numStart = result.find_first_not_of(" ", prevOpEnd);
            leftPos = numStart;
        } else {
            leftPos = 0;
        }
        
        result.insert(leftPos, "(");
        
        size_t rightPos = opPositions[parenthesesPos + 1];
        size_t numEnd = result.find_first_of("+-*/", rightPos + 1);
        if (numEnd == string::npos) {
            numEnd = result.length();
        } else {
            numEnd--;
        }
        
        result.insert(numEnd, ")");
        
        return result;
    }

public:
    string generateQuestion() override {
        int operandCount = randomNumber(2, 5);
        vector<int> operands;
        vector<string> operators;
        
        for (int i = 0; i < operandCount; i++) {
            operands.push_back(randomNumber(1, 100));
        }
        
        bool hasSquareOrRoot = false;
        
        string expression = "";
        for (int i = 0; i < operandCount; i++) {
            if (i > 0) {
                int opType = randomNumber(0, 3);
                switch (opType) {
                    case 0: operators.push_back("+"); break;
                    case 1: operators.push_back("-"); break;
                    case 2: operators.push_back("*"); break;
                    case 3: operators.push_back("/"); break;
                }
            }
            
            int specialOp = randomNumber(0, 3);
            if ((!hasSquareOrRoot && i == operandCount - 1) || (specialOp == 0 && i < operandCount - 1)) {
                if (randomNumber(0, 1) == 0) {
                    expression += to_string(operands[i]) + "²";
                } else {
                    expression += "√" + to_string(operands[i]);
                }
                hasSquareOrRoot = true;
            } else {
                expression += to_string(operands[i]);
            }
        }
        
        if (!hasSquareOrRoot) {
            int pos = randomNumber(0, operandCount - 1);
            size_t numStart = 0;
            for (int i = 0; i < pos; i++) {
                size_t opPos = expression.find_first_of("+-*/", numStart);
                if (opPos != string::npos) {
                    numStart = opPos + 3;
                }
            }
            
            if (randomNumber(0, 1) == 0) {
                expression.insert(numStart, "(");
                expression.insert(expression.find(' ', numStart), ")²");
            } else {
                expression.insert(numStart, "√(");
                expression.insert(expression.find(' ', numStart), ")");
            }
        }
        
        if (shouldAddParentheses(operandCount)) {
            expression = addParenthesesToAdvancedExpression(expression, operators);
        }
        
        return expression;
    }
    
    string getType() const override {
        return "初中";
    }
};

// 高中题目生成器：生成高中难度的数学题目，包含三角函数等
class HighQuestionGenerator : public BaseQuestionGenerator {
private:
    string addParenthesesToAdvancedExpression(const string& expression, const vector<string>& operators) {
        if (operators.size() <= 1) return expression;
        
        vector<size_t> opPositions;
        size_t pos = 0;
        for (const auto& op : operators) {
            pos = expression.find(op, pos);
            if (pos != string::npos) {
                opPositions.push_back(pos);
                pos += op.length();
            }
        }
        
        if (opPositions.size() <= 1) return expression;
        
        int parenthesesPos = randomNumber(0, opPositions.size() - 2);
        
        string result = expression;
        
        size_t leftPos = opPositions[parenthesesPos];
        if (parenthesesPos > 0) {
            size_t prevOpEnd = opPositions[parenthesesPos - 1] + operators[parenthesesPos - 1].length();
            size_t numStart = result.find_first_not_of(" ", prevOpEnd);
            leftPos = numStart;
        } else {
            leftPos = 0;
        }
        
        result.insert(leftPos, "(");
        
        size_t rightPos = opPositions[parenthesesPos + 1];
        size_t numEnd = result.find_first_of("+-*/", rightPos + 1);
        if (numEnd == string::npos) {
            numEnd = result.length();
        } else {
            numEnd--;
        }
        
        result.insert(numEnd, ")");
        
        return result;
    }

public:
    string generateQuestion() override {
        int operandCount = randomNumber(2, 5);
        vector<int> operands;
        
        for (int i = 0; i < operandCount; i++) {
            operands.push_back(randomNumber(1, 100));
        }
        
        bool hasTrigonometry = false;
        vector<string> operators;
        
        string expression = "";
        for (int i = 0; i < operandCount; i++) {
            if (i > 0) {
                int opType = randomNumber(0, 3);
                switch (opType) {
                    case 0: operators.push_back("+"); break;
                    case 1: operators.push_back("-"); break;
                    case 2: operators.push_back("*"); break;
                    case 3: operators.push_back("/"); break;
                }
            }
            
            int specialOp = randomNumber(0, 5);
            if ((!hasTrigonometry && i == operandCount - 1) || specialOp >= 2) {
                int opChoice = randomNumber(0, 4);
                switch (opChoice) {
                    case 0:
                        expression += to_string(operands[i]) + "²";
                        break;
                    case 1:
                        expression += "√" + to_string(operands[i]);
                        break;
                    case 2:
                        expression += "sin(" + to_string(operands[i]) + ")";
                        hasTrigonometry = true;
                        break;
                    case 3:
                        expression += "cos(" + to_string(operands[i]) + ")";
                        hasTrigonometry = true;
                        break;
                    case 4:
                        expression += "tan(" + to_string(operands[i]) + ")";
                        hasTrigonometry = true;
                        break;
                }
            } else {
                expression += to_string(operands[i]);
            }
        }
        
        if (!hasTrigonometry) {
            int pos = randomNumber(0, operandCount - 1);
            size_t numStart = 0;
            for (int i = 0; i < pos; i++) {
                size_t opPos = expression.find_first_of("+-*/", numStart);
                if (opPos != string::npos) {
                    numStart = opPos + 3;
                }
            }
            
            int trigChoice = randomNumber(0, 2);
            switch (trigChoice) {
                case 0: 
                    expression.insert(numStart, "sin(");
                    expression.insert(expression.find(' ', numStart), ")");
                    break;
                case 1:
                    expression.insert(numStart, "cos(");
                    expression.insert(expression.find(' ', numStart), ")");
                    break;
                case 2:
                    expression.insert(numStart, "tan(");
                    expression.insert(expression.find(' ', numStart), ")");
                    break;
            }
        }
        
        if (shouldAddParentheses(operandCount)) {
            expression = addParenthesesToAdvancedExpression(expression, operators);
        }
        
        return expression;
    }
    
    string getType() const override {
        return "高中";
    }
};

// 用户管理器具体实现：实现用户登录、切换类型、题目去重等功能
class UserManager : public IUserManager {
private:
    vector<Account> accounts;
    string currentUser;
    string currentType;
    bool isLoggedIn;
    map<string, set<string>> userQuestions;
    shared_ptr<IFileManager> fileManager;

public:
    UserManager(shared_ptr<IFileManager> fm) : fileManager(fm) {
        isLoggedIn = false;
        currentUser = "";
        currentType = "";
        
        accounts = {
            {"张三1", "123", "小学"},
            {"张三2", "123", "小学"},
            {"张三3", "123", "小学"},
            {"李四1", "123", "初中"},
            {"李四2", "123", "初中"},
            {"李四3", "123", "初中"},
            {"王五1", "123", "高中"},
            {"王五2", "123", "高中"},
            {"王五3", "123", "高中"}
        };
        
        for (const auto& account : accounts) {
            string folderPath = account.username;
            if (!fileManager->directoryExists(folderPath)) {
                fileManager->createDirectory(folderPath);
            }
            loadUserQuestions(account.username);
        }
    }
    
    void loadUserQuestions(const string& username) {
        userQuestions[username].clear();
        string folderPath = username;
        
        if (!fileManager->directoryExists(folderPath)) {
            return;
        }
        
        vector<string> files = fileManager->getFilesInDirectory(folderPath);
        for (const string& filename : files) {
            if (filename.length() > 4 && filename.substr(filename.length() - 4) == ".txt") {
                string filepath = folderPath + "/" + filename;
                ifstream file(filepath);
                string line;
                while (getline(file, line)) {
                    if (!line.empty() && isdigit(line[0])) {
                        size_t dotPos = line.find('.');
                        if (dotPos != string::npos && dotPos + 2 < line.length()) {
                            string question = line.substr(dotPos + 2);
                            userQuestions[username].insert(question);
                        }
                    }
                }
                file.close();
            }
        }
    }
    
    bool login(const string& username, const string& password) override {
        for (const auto& account : accounts) {
            if (account.username == username && account.password == password) {
                currentUser = username;
                currentType = account.type;
                isLoggedIn = true;
                return true;
            }
        }
        return false;
    }
    
    void logout() override {
        isLoggedIn = false;
        currentUser = "";
        currentType = "";
    }
    
    bool switchType(const string& type) override {
        string trimmedType = fileManager->trim(type);
        if (trimmedType == "小学" || trimmedType == "初中" || trimmedType == "高中") {
            currentType = trimmedType;
            return true;
        }
        return false;
    }
    
    bool isQuestionDuplicate(const string& question) override {
        return userQuestions[currentUser].find(question) != userQuestions[currentUser].end();
    }
    
    void addQuestionToUserRecord(const string& question) override {
        userQuestions[currentUser].insert(question);
    }
    
    string getCurrentUser() const override { return currentUser; }
    string getCurrentType() const override { return currentType; }
    bool getIsLoggedIn() const override { return isLoggedIn; }
};

// 题目生成器工厂：根据类型创建对应的题目生成器
class QuestionGeneratorFactory {
public:
    static unique_ptr<IQuestionGenerator> createGenerator(const string& type) {
        if (type == "小学") {
            return make_unique<PrimaryQuestionGenerator>();
        } else if (type == "初中") {
            return make_unique<MiddleQuestionGenerator>();
        } else if (type == "高中") {
            return make_unique<HighQuestionGenerator>();
        }
        return nullptr;
    }
};

// 数学卷子生成主类：负责题目生成、保存、用户交互等主流程
class MathPaperGenerator {
private:
    shared_ptr<IUserManager> userManager;
    unique_ptr<IQuestionGenerator> questionGenerator;
    shared_ptr<IFileManager> fileManager;
    
public:
    MathPaperGenerator(shared_ptr<IUserManager> um, shared_ptr<IFileManager> fm) 
        : userManager(um), fileManager(fm) {}
    
    vector<string> generateQuestions(int count) {
        vector<string> questions;
        set<string> generatedSet;
        int attempts = 0;
        const int MAX_ATTEMPTS = count * 10;
        
        
        questionGenerator = QuestionGeneratorFactory::createGenerator(userManager->getCurrentType());
        if (!questionGenerator) {
            cout << "题目生成器创建失败!" << endl;
            return questions;
        }
        
        while (questions.size() < count && attempts < MAX_ATTEMPTS) {
            string question = questionGenerator->generateQuestion();
            
            if (!userManager->isQuestionDuplicate(question) && generatedSet.find(question) == generatedSet.end()) {
                questions.push_back(question);
                generatedSet.insert(question);
                userManager->addQuestionToUserRecord(question);
            }
            attempts++;
        }
        
        
        while (questions.size() < count) {
            string question;
            string currentType = userManager->getCurrentType();
            
            if (currentType == "小学") {
                question = to_string(rand() % 100 + 1) + " + " + to_string(rand() % 100 + 1);
            } else if (currentType == "初中") {
                question = to_string(rand() % 100 + 1) + "² + " + to_string(rand() % 100 + 1);
            } else {
                question = "sin(" + to_string(rand() % 100 + 1) + ") + " + to_string(rand() % 100 + 1);
            }
            
            if (!userManager->isQuestionDuplicate(question)) {
                questions.push_back(question);
                userManager->addQuestionToUserRecord(question);
            }
        }
        
        return questions;
    }
    
    void saveQuestions(const vector<string>& questions) {
        time_t now = time(nullptr);
        tm* localTime = localtime(&now);
        
        stringstream filename;
        filename << setfill('0') 
                << localTime->tm_year + 1900 << "-"
                << setw(2) << localTime->tm_mon + 1 << "-"
                << setw(2) << localTime->tm_mday << "-"
                << setw(2) << localTime->tm_hour << "-"
                << setw(2) << localTime->tm_min << "-"
                << setw(2) << localTime->tm_sec << ".txt";
        
        string filepath = userManager->getCurrentUser() + "/" + filename.str();
        ofstream file(filepath);
        
        if (file.is_open()) {
            for (size_t i = 0; i < questions.size(); i++) {
                file << i + 1 << ". " << questions[i] << "\n";
                if (i < questions.size() - 1) {
                    file << "\n";
                }
            }
            file.close();
            cout << "题目已保存到: " << filepath << endl;
        } else {
            cout << "文件保存失败!" << endl;
        }
    }
    
    void processInput() {
        string input;
        getline(cin, input);
        
        input = fileManager->trim(input);
        
        if (input == "-1") {
            userManager->logout();
            return;
        }
        
        if (input.find("切换为") == 0) {
            string type = input.substr(3);
            type = fileManager->trim(type);
            
            if (userManager->switchType(type)) {
                cout << "切换成功！当前类型为：" << userManager->getCurrentType() << endl;
                return;
            } else {
                cout << "请输入小学、初中和高中三个选项中的一个" << endl;
                return;
            }
        }
        
        processCountInput(input);
    }
    
    void processCountInput(const string& input) {
        try {
            int count = stoi(input);
            if (count >= 10 && count <= 30) {
                vector<string> questions = generateQuestions(count);
                saveQuestions(questions);
            } else {
                cout << "题目数量应在10-30之间" << endl;
            }
        } catch (const exception& e) {
            cout << "请输入有效的数字" << endl;
        }
    }
    
    void run() {
        srand(time(nullptr));
        cout << "=== 中小学数学卷子自动生成程序 ===" << endl;
        
        while (true) {
            if (!userManager->getIsLoggedIn()) {
                cout << "请输入用户名和密码（用空格隔开）: ";
                string username, password;
                cin >> username >> password;
                cin.ignore();
                
                if (userManager->login(username, password)) {
                    cout << "登录成功！当前选择为" << userManager->getCurrentType() << "出题" << endl;
                } else {
                    cout << "请输入正确的用户名、密码" << endl;
                    continue;
                }
            }
            
            while (userManager->getIsLoggedIn()) {
                cout << endl << "准备生成" << userManager->getCurrentType() << "数学题目，请输入生成题目数量（输入-1将退出当前用户，重新登录）" << endl;
                cout << "或者输入\"切换为小学/初中/高中\"来切换题目类型: ";
                
                cin.clear();
                processInput();
            }
        }
    }
};

int main() {
    
    auto fileManager = make_shared<FileManager>();
    auto userManager = make_shared<UserManager>(fileManager);
    MathPaperGenerator generator(userManager, fileManager);
    
    generator.run();
    return 0;
}