package dao.impl;

// 引入相关类和接口
import dao.StudentDao; // StudentDao 接口，定义学生相关的数据访问方法
import domain.Course; // Course 实体类，表示课程数据
import domain.SelectCourse; // SelectCourse 实体类，表示学生选课信息
import domain.Student; // Student 实体类，表示学生数据
import org.springframework.dao.DataAccessException; // 数据访问异常
import org.springframework.jdbc.core.BeanPropertyRowMapper; // 将查询结果映射为 Java 对象
import org.springframework.jdbc.core.JdbcTemplate; // JDBC 操作模板
import utils.JDBCUtils; // 自定义工具类，用于获取数据库数据源

import java.util.ArrayList; // ArrayList 类，用于存储参数和结果
import java.util.List; // List 接口，表示列表
import java.util.Map; // Map 接口，用于存储查询条件
import java.util.Set; // Set 接口，用于存储条件的键集合

/**
 * StudentDaoImpl 实现了 StudentDao 接口，负责操作学生数据表。
 */
public class StudentDaoImpl implements StudentDao {

    // 使用 JdbcTemplate 来简化数据库操作，JDBCUtils 提供数据源
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());

    /**
     * 获取所有学生信息
     * @return 返回所有学生的 List；查询失败时返回 null
     */
    @Override
    public List<Student> findAll() {
        try {
            // SQL 语句：查询所有学生
            String sql = "select * from student";
            // 执行查询并返回结果，使用 BeanPropertyRowMapper 将结果映射为 Student 实体类
            List<Student> students = template.query(sql, new BeanPropertyRowMapper<Student>(Student.class));
            return students;
        } catch (DataAccessException e) {
            e.printStackTrace(); // 捕获并打印异常堆栈
            return null; // 查询失败时返回 null
        }
    }

    /**
     * 根据学生 ID 和密码查找学生
     * @param id 学生 ID
     * @param password 学生密码
     * @return 找到的学生；未找到时返回 null
     */
    @Override
    public Student findStudentidAndPassword(String id, String password) {
        try {
            // SQL 语句：根据学生 ID 和密码查询学生
            String sql = "select * from student where s_id = ? and s_password = ?";
            // 执行查询并返回结果
            Student student = template.queryForObject(sql, new BeanPropertyRowMapper<Student>(Student.class), id, password);
            return student;
        } catch (DataAccessException e) {
            e.printStackTrace(); // 捕获并打印异常堆栈
            return null; // 查询失败时返回 null
        }
    }

    /**
     * 根据学生 ID 查找学生
     * @param id 学生 ID
     * @return 找到的学生；未找到时返回 null
     */
    @Override
    public Student findStudentById(String id) {
        try {
            // SQL 语句：根据学生 ID 查询学生信息
            String sql = "select * from student where s_id = ?";
            // 执行查询并返回结果
            Student student = template.queryForObject(sql, new BeanPropertyRowMapper<Student>(Student.class), id);
            return student;
        } catch (DataAccessException e) {
            e.printStackTrace(); // 捕获并打印异常堆栈
            return null; // 查询失败时返回 null
        }
    }

    /**
     * 添加新学生
     * @param student 学生对象
     */
    @Override
    public void addStudent(Student student) {
        try {
            // SQL 语句：插入学生数据
            String sql = "insert into student(s_id, s_password) values(?, ?)";
            // 执行插入操作
            template.update(sql, student.getS_id(), student.getS_password());
        } catch (DataAccessException e) {
            e.printStackTrace(); // 捕获并打印异常堆栈
        }
    }

    /**
     * 更新学生信息
     * @param student 学生对象，包含要更新的信息
     */
    @Override
    public void updateInfo(Student student) {
        try {
            // SQL 语句：更新学生信息
            String sql = "update student set s_name = ?, s_sex = ?, s_age = ?, s_phone = ?, s_email = ?, s_address = ?, s_college = ?, s_department = ?, s_class = ? where s_id = ?";
            // 执行更新操作
            template.update(sql, student.getS_name(), student.getS_sex(), student.getS_age(),
                            student.getS_phone(), student.getS_email(), student.getS_address(),
                            student.getS_college(), student.getS_department(), student.getS_class(), student.getS_id());
        } catch (Exception e) {
            e.printStackTrace(); // 捕获并打印异常堆栈
        }
    }

    /**
     * 更新学生密码
     * @param studentid 学生 ID
     * @param newpassword 新密码
     */
    @Override
    public void updatePassword(String studentid, String newpassword) {
        try {
            // SQL 语句：更新学生密码
            String sql = "update student set s_password = ? where s_id = ?";
            // 执行更新操作
            template.update(sql, newpassword, studentid);
        } catch (Exception e) {
            e.printStackTrace(); // 捕获并打印异常堆栈
        }
    }

    /**
     * 查找指定学生的所有选课信息
     * @param studentid 学生 ID
     * @return 包含学生选课信息的 List；查询失败时返回 null
     */
    @Override
    public List<SelectCourse> findAllSelectCourse(String studentid) {
        try {
            // SQL 语句：查询学生的所有选课信息
            String sql = "select student.s_id, student.s_name, course.c_id, course.c_name, course.c_info, teacher.t_id, t_name, select_course.score " +
                         "from select_course, student, course, teacher " +
                         "where student.s_id = select_course.s_id " +
                         "and select_course.c_id = course.c_id " +
                         "and course.t_id = teacher.t_id " +
                         "and student.s_id = ?";
            // 执行查询并返回结果
            List<SelectCourse> scs = template.query(sql, new BeanPropertyRowMapper<SelectCourse>(SelectCourse.class), studentid);
            return scs;
        } catch (DataAccessException e) {
            e.printStackTrace(); // 捕获并打印异常堆栈
            return null; // 查询失败时返回 null
        }
    }

    /**
     * 获取所有可选课程
     * @return 包含所有可选课程的 List；查询失败时返回 null
     */
    @Override
    public List<Course> findAllOptionalCourse() {
        try {
            // SQL 语句：查询所有可选课程
            String sql = "select course.c_id, course.c_name, course.c_info, teacher.t_id, t_name " +
                         "from course, teacher " +
                         "where course.t_id = teacher.t_id";
            // 执行查询并返回结果
            List<Course> cs = template.query(sql, new BeanPropertyRowMapper<Course>(Course.class));
            return cs;
        } catch (DataAccessException e) {
            e.printStackTrace(); // 捕获并打印异常堆栈
            return null; // 查询失败时返回 null
        }
    }

    /**
     * 学生选修课程
     * @param studentid 学生 ID
     * @param courseid 课程 ID
     */
    @Override
    public void addSelectCourse(String studentid, String courseid) {
        try {
            // SQL 语句：学生选修课程
            String sql = "insert into select_course(s_id, c_id) values(?, ?)";
            // 执行插入操作
            template.update(sql, studentid, courseid);
        } catch (DataAccessException e) {
            e.printStackTrace(); // 捕获并打印异常堆栈
        }
    }

    /**
     * 根据学生 ID 删除学生
     * @param studentid 学生 ID
     */
    @Override
    public void deleteStudentById(String studentid) {
        try {
            // SQL 语句：删除学生
            String sql = "delete from student where s_id = ?";
            // 执行删除操作
            template.update(sql, studentid);
        } catch (DataAccessException e) {
            e.printStackTrace(); // 捕获并打印异常堆栈
        }
    }

    /**
     * 查找符合条件的学生总数
     * @param condition 查询条件
     * @return 符合条件的学生总数
     */
    @Override
    public int findTotalCount(Map<String, String[]> condition) {
        // 初始化 SQL 语句
        String sql = "select count(*) from student where 1 = 1";
        StringBuilder sb = new StringBuilder(sql);
        List<Object> params = new ArrayList<Object>(); // 存储查询参数
        // 遍历查询条件
        Set<String> keySet = condition.keySet();
        for (String key : keySet) {
            // 排除分页相关的参数
            if ("currentPage".equals(key) || "rows".equals(key)) {
                continue;
            }
            String value = condition.get(key)[0];
            if (value != null && !"".equals(value)) {
                // 添加条件到 SQL 语句
                sb.append(" and " + key + " like ? ");
                params.add("%" + value + "%"); // ? 条件的值
            }
        }
        // 执行查询并返回结果
        return template.queryForObject(sb.toString(), Integer.class, params.toArray());
    }

    /**
     * 添加学生的所有信息
     * @param s 学生对象，包含所有信息
     */
    @Override
    public void addStudentAllInfo(Student s) {
        try {
            // SQL 语句：插入学生所有信息
            String sql = "insert into student(s_id, s_college, s_department, s_class, s_name, s_sex, s_age, s_phone, s_email, s_address) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
            // 执行插入操作
            template.update(sql, s.getS_id(), s.getS_college(), s.getS_department(), s.getS_class(), s.getS_name(),
                            s.getS_sex(), s.getS_age(), s.getS_phone(), s.getS_email(), s.getS_address());
        } catch (DataAccessException e) {
            e.printStackTrace(); // 捕获并打印异常堆栈
        }
    }

    /**
     * 获取所有学生的选课信息
     * @return 所有学生的选课信息；查询失败时返回 null
     */
    @Override
    public List<SelectCourse> findSelectCourseAllStudent() {
        try {
            // SQL 语句：查询所有学生的选课信息
            String sql = "select student.s_id, student.s_name, course.c_id, course.c_name, course.c_info, teacher.t_id, t_name, select_course.score " +
                         "from select_course, student, course, teacher " +
                         "where student.s_id = select_course.s_id " +
                         "and select_course.c_id = course.c_id " +
                         "and course.t_id = teacher.t_id";
            // 执行查询并返回结果
            List<SelectCourse> scs = template.query(sql, new BeanPropertyRowMapper<SelectCourse>(SelectCourse.class));
            return scs;
        } catch (DataAccessException e) {
            e.printStackTrace(); // 捕获并打印异常堆栈
            return null; // 查询失败时返回 null
        }
    }

    /**
     * 根据条件分页查询学生
     * @param start 起始记录
     * @param rows 每页记录数
     * @param condition 查询条件
     * @return 符合条件的学生列表
     */
    @Override
    public List<Student> findByPage(int start, int rows, Map<String, String[]> condition) {
        try {
            // 初始化 SQL 语句
            String sql = "select * from student where 1 = 1";
            StringBuilder sb = new StringBuilder(sql);
            List<Object> params = new ArrayList<Object>(); // 存储查询参数
            // 遍历查询条件
            Set<String> keySet = condition.keySet();
            for (String key : keySet) {
                // 排除分页相关的参数
                if ("currentPage".equals(key) || "rows".equals(key)) {
                    continue;
                }
                String value = condition.get(key)[0];
                if (value != null && !"".equals(value)) {
                    // 添加条件到 SQL 语句
                    sb.append(" and " + key + " like ? ");
                    params.add("%" + value + "%"); // ? 条件的值
                }
            }
            // 添加分页条件
            sb.append(" limit ?, ?");
            params.add(start);
            params.add(rows);
            // 执行查询并返回结果
            return template.query(sb.toString(), new BeanPropertyRowMapper<Student>(Student.class), params.toArray());
        } catch (DataAccessException e) {
            e.printStackTrace(); // 捕获并打印异常堆栈
            return null; // 查询失败时返回 null
        }
    }
}