package utils;

import model.Question;
import model.User;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.Type;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class FileUtil {
    private static final String USERS_FILE = "data/users.json";
    private static final String CURRENT_EXAM_FILE = "data/current_exam.json";
    private static final Gson gson = new GsonBuilder().setPrettyPrinting().create();

    static {
        new File("data").mkdirs();
    }

    /**
     * 清理未注册成功的用户（未设置密码的用户）
     */
    public static void cleanupUnregisteredUsers() {
        try {
            Map<String, User> users = loadAllUsers();
            boolean hasChanges = false;
            long currentTime = System.currentTimeMillis();

            // 使用迭代器安全删除
            Iterator<Map.Entry<String, User>> iterator = users.entrySet().iterator();
            while (iterator.hasNext()) {
                Map.Entry<String, User> entry = iterator.next();
                User user = entry.getValue();

                // 删除条件：未设置密码 或 未完成注册 且 创建时间超过24小时
                if ((user.getPassword() == null || user.getPassword().isEmpty() || !user.isRegistered())) {
                    iterator.remove();
                    hasChanges = true;
                    System.out.println("清理未注册用户: " + user.getUsername() + " (" + user.getEmail() + ")");
                }
            }

            if (hasChanges) {
                saveAllUsers(users);

            } else {
                System.out.println("没有需要清理的未注册用户");
            }

        } catch (Exception e) {
            System.err.println("清理未注册用户时出错: " + e.getMessage());
            e.printStackTrace();
        }
    }

    public static void saveAllUsers(Map<String, User> users) {
        try (FileWriter writer = new FileWriter(USERS_FILE)) {
            gson.toJson(users, writer);
        } catch (IOException e) {
            System.err.println("保存用户数据失败: " + e.getMessage());
        }
    }

    // 用户相关方法保持不变...
    public static void saveUser(User user) {
        try {
            Map<String, User> users = loadAllUsers();
            users.put(user.getUsername(), user);
            saveAllUsers(users);
        } catch (Exception e) {
            System.err.println("保存用户数据失败: " + e.getMessage());
        }
    }

    public static Map<String, User> loadAllUsers() {
        try {
            File file = new File(USERS_FILE);
            if (!file.exists()) {
                return new HashMap<>();
            }

            try (FileReader reader = new FileReader(file)) {
                Type type = new TypeToken<Map<String, User>>(){}.getType();
                Map<String, User> users = gson.fromJson(reader, type);

                // 修复现有数据中的问题
                if (users != null) {
                    for (Map.Entry<String, User> entry : users.entrySet()) {
                        User user = entry.getValue();
                        // 确保用户名不为空
                        if (user.getUsername() == null) {
                            user.setUsername(entry.getKey());
                        }
                        // 确保密码不为null
                        if (user.getPassword() == null) {
                            user.setPassword("");
                        }
                    }
                }

                return users != null ? users : new HashMap<>();
            }
        } catch (IOException e) {
            System.err.println("加载用户数据失败: " + e.getMessage());
            return new HashMap<>();
        }
    }

    public static User loadUserByUsername(String username) {
        Map<String, User> users = loadAllUsers();
        return users.get(username);
    }

    public static User loadUserByEmail(String email) {
        Map<String, User> users = loadAllUsers();
        for (User user : users.values()) {
            if (user.getEmail().equals(email)) {
                return user;
            }
        }
        return null;
    }

    public static boolean usernameExists(String username) {
        return loadAllUsers().containsKey(username);
    }

    public static boolean emailExists(String email) {
        return loadUserByEmail(email) != null;
    }

    // ========== 试卷保存相关方法 ==========

    /**
     * 保存当前试卷到本地文件（覆盖之前的试卷）
     */
    public static void saveCurrentExam(List<Question> questions, String difficulty, int questionCount) {
        try {
            ExamData examData = new ExamData(questions, difficulty, questionCount, new Date());

            try (FileWriter writer = new FileWriter(CURRENT_EXAM_FILE)) {
                gson.toJson(examData, writer);
            }
            System.out.println("✅ 试卷已保存到本地: " + CURRENT_EXAM_FILE);

        } catch (IOException e) {
            System.err.println("保存试卷失败: " + e.getMessage());
        }
    }

    /**
     * 从本地文件加载当前试卷
     */
    public static ExamData loadCurrentExam() {
        try {
            File file = new File(CURRENT_EXAM_FILE);
            if (!file.exists()) {
                return null;
            }

            try (FileReader reader = new FileReader(file)) {
                return gson.fromJson(reader, ExamData.class);
            }
        } catch (IOException e) {
            System.err.println("加载试卷失败: " + e.getMessage());
            return null;
        }
    }

    /**
     * 试卷数据包装类
     */
    public static class ExamData {
        private List<Question> questions;
        private String difficulty;
        private int questionCount;
        private Date generateTime;

        public ExamData(List<Question> questions, String difficulty, int questionCount, Date generateTime) {
            this.questions = questions;
            this.difficulty = difficulty;
            this.questionCount = questionCount;
            this.generateTime = generateTime;
        }

        // Getters
        public List<Question> getQuestions() { return questions; }
        public String getDifficulty() { return difficulty; }
        public int getQuestionCount() { return questionCount; }
        public Date getGenerateTime() { return generateTime; }
    }
}