package com.studentmanagement;

import com.studentmanagement.exception.DuplicateStudentException;
import com.studentmanagement.exception.StudentNotFoundException;
import com.studentmanagement.model.Student;
import com.studentmanagement.model.StudentDAO;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.util.List;

import static org.junit.jupiter.api.Assertions.*;

/**
 * 学生管理系统测试类
 * 使用JUnit 5测试学生管理系统的核心功能
 */
public class StudentManagementTest {
    private StudentDAO studentDAO;

    @BeforeEach
    public void setUp() {
        // 使用单例的StudentDAO实例
        studentDAO = StudentDAO.getInstance();
        
        // 为了确保测试的独立性，我们可以清理现有的数据
        // 注意：在实际项目中，可能需要更复杂的测试数据管理策略
    }

    @Test
    public void testAddAndGetStudent() throws DuplicateStudentException, StudentNotFoundException {
        // 创建测试学生
        Student testStudent = new Student("999", "测试学生", 20, "男");
        testStudent.addCourseGrade("数学", 90.5);
        
        // 添加学生
        studentDAO.addStudent(testStudent);
        
        // 获取学生并验证
        Student retrievedStudent = studentDAO.getStudentById("999");
        assertNotNull(retrievedStudent);
        assertEquals("测试学生", retrievedStudent.getName());
        assertEquals(90.5, retrievedStudent.getCourseGrade("数学"));
        
        // 清理测试数据
        studentDAO.deleteStudent("999");
    }

    @Test
    public void testDuplicateStudentException() throws DuplicateStudentException {
        // 创建测试学生
        Student testStudent = new Student("888", "重复测试", 21, "女");
        studentDAO.addStudent(testStudent);
        
        // 尝试添加相同ID的学生，应该抛出异常
        Student duplicateStudent = new Student("888", "重复的学生", 22, "男");
        assertThrows(DuplicateStudentException.class, () -> {
            studentDAO.addStudent(duplicateStudent);
        });
        
        // 清理测试数据
        try {
            studentDAO.deleteStudent("888");
        } catch (StudentNotFoundException e) {
            // 忽略异常
        }
    }

    @Test
    public void testStudentNotFoundException() {
        // 尝试获取不存在的学生，应该抛出异常
        assertThrows(StudentNotFoundException.class, () -> {
            studentDAO.getStudentById("不存在的ID");
        });
    }

    @Test
    public void testUpdateStudent() throws DuplicateStudentException, StudentNotFoundException {
        // 创建并添加测试学生
        Student testStudent = new Student("777", "要更新的学生", 19, "男");
        studentDAO.addStudent(testStudent);
        
        // 更新学生信息
        Student updatedStudent = new Student("777", "更新后的学生", 20, "男");
        updatedStudent.addCourseGrade("物理", 85.0);
        studentDAO.updateStudent(updatedStudent);
        
        // 验证更新是否成功
        Student retrievedStudent = studentDAO.getStudentById("777");
        assertEquals("更新后的学生", retrievedStudent.getName());
        assertEquals(20, retrievedStudent.getAge());
        assertEquals(85.0, retrievedStudent.getCourseGrade("物理"));
        
        // 清理测试数据
        studentDAO.deleteStudent("777");
    }

    @Test
    public void testDeleteStudent() throws DuplicateStudentException, StudentNotFoundException {
        // 创建并添加测试学生
        Student testStudent = new Student("666", "要删除的学生", 22, "女");
        studentDAO.addStudent(testStudent);
        
        // 删除学生
        studentDAO.deleteStudent("666");
        
        // 验证学生已被删除
        assertThrows(StudentNotFoundException.class, () -> {
            studentDAO.getStudentById("666");
        });
    }

    @Test
    public void testGetAllStudents() {
        // 获取所有学生
        List<Student> allStudents = studentDAO.getAllStudents();
        assertNotNull(allStudents);
        // 至少应该有示例数据中的学生
        assertTrue(allStudents.size() >= 3);
    }

    @Test
    public void testFilterStudentsByCourse() {
        // 使用示例数据中的"数学"课程进行测试
        List<Student> mathStudents = studentDAO.getStudentsByCourse("数学");
        assertNotNull(mathStudents);
        // 示例数据中所有学生都应该选修了数学
        assertTrue(mathStudents.size() >= 3);
        
        // 测试不存在的课程
        List<Student> noStudents = studentDAO.getStudentsByCourse("不存在的课程");
        assertTrue(noStudents.isEmpty());
    }

    @Test
    public void testFilterStudentsByGradeRange() {
        // 测试80-90分的学生
        List<Student> studentsInRange = studentDAO.getStudentsByGradeRange(80.0, 90.0);
        assertNotNull(studentsInRange);
        
        // 验证筛选结果是否在范围内
        for (Student student : studentsInRange) {
            double avgGrade = student.calculateAverageGrade();
            assertTrue(avgGrade >= 80.0 && avgGrade <= 90.0);
        }
        
        // 测试不可能的范围
        List<Student> noStudents = studentDAO.getStudentsByGradeRange(100.0, 110.0);
        assertTrue(noStudents.isEmpty());
    }

    @Test
    public void testCalculateAverageGrade() {
        // 创建一个测试学生，添加成绩并计算平均成绩
        Student testStudent = new Student("555", "平均成绩测试", 20, "男");
        testStudent.addCourseGrade("数学", 80.0);
        testStudent.addCourseGrade("英语", 90.0);
        testStudent.addCourseGrade("计算机", 85.0);
        
        double avgGrade = testStudent.calculateAverageGrade();
        assertEquals(85.0, avgGrade, 0.01); // 使用容差处理浮点数比较
    }
}