// 声明当前类所在的包，该包属于系统用户控制器模块
package com.yf.exam.modules.sys.user.controller;

// 导入 MyBatis-Plus 的查询条件构造器，用于构建数据库查询条件
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
// 导入 MyBatis-Plus 的分页元数据接口，用于处理分页查询结果
import com.baomidou.mybatisplus.core.metadata.IPage;
// 导入自定义的 API 统一响应类，用于封装接口返回数据
import com.yf.exam.core.api.ApiRest;
// 导入自定义的基础控制器类，提供一些通用的控制器方法
import com.yf.exam.core.api.controller.BaseController;
// 导入自定义的基础多个 ID 请求数据传输对象类，用于批量操作时传递 ID 列表
import com.yf.exam.core.api.dto.BaseIdsReqDTO;
// 导入自定义的基础状态请求数据传输对象类，用于传递状态修改请求
import com.yf.exam.core.api.dto.BaseStateReqDTO;
// 导入自定义的分页请求数据传输对象类，用于分页查询时传递请求参数
import com.yf.exam.core.api.dto.PagingReqDTO;
// 导入系统用户数据传输对象类，用于在不同层之间传输用户信息
import com.yf.exam.modules.sys.user.dto.SysUserDTO;
// 导入系统用户登录请求数据传输对象类，用于用户登录时传递请求信息
import com.yf.exam.modules.sys.user.dto.request.SysUserLoginReqDTO;
// 导入系统用户保存请求数据传输对象类，用于保存或修改用户信息时传递请求信息
import com.yf.exam.modules.sys.user.dto.request.SysUserSaveReqDTO;
// 导入系统用户登录响应数据传输对象类，用于用户登录成功后返回响应信息
import com.yf.exam.modules.sys.user.dto.response.SysUserLoginDTO;
// 导入系统用户实体类，对应数据库中的用户表
import com.yf.exam.modules.sys.user.entity.SysUser;
// 导入系统用户服务接口，用于调用用户相关的业务逻辑
import com.yf.exam.modules.sys.user.service.SysUserService;
// 导入 Swagger 注解，用于生成 API 文档，标记控制器的标签
import io.swagger.annotations.Api;
// 导入 Swagger 注解，用于生成 API 文档，标记接口的操作描述
import io.swagger.annotations.ApiOperation;
// 导入 Shiro 注解，用于权限控制，要求用户具有指定角色才能访问接口
import org.apache.shiro.authz.annotation.RequiresRoles;
// 导入 Spring 框架的依赖注入注解，用于自动注入依赖的 Bean
import org.springframework.beans.factory.annotation.Autowired;
// 导入 Spring 框架的跨域请求注解，允许跨域访问该接口
import org.springframework.web.bind.annotation.CrossOrigin;
// 导入 Spring 框架的请求体注解，用于将请求体中的数据绑定到方法参数上
import org.springframework.web.bind.annotation.RequestBody;
// 导入 Spring 框架的请求映射注解，用于映射请求路径
import org.springframework.web.bind.annotation.RequestMapping;
// 导入 Spring 框架的请求方法注解，用于指定请求的 HTTP 方法
import org.springframework.web.bind.annotation.RequestMethod;
// 导入 Spring 框架的请求参数注解，用于获取请求参数
import org.springframework.web.bind.annotation.RequestParam;
// 导入 Spring 框架的控制器注解，标记该类为 RESTful 风格的控制器
import org.springframework.web.bind.annotation.RestController;

// 导入 HttpServletRequest 类，用于获取 HTTP 请求信息
import javax.servlet.http.HttpServletRequest;

/**
 * <p>
 * 管理用户控制器，处理与系统用户相关的各种请求，如登录、登出、修改资料等操作。
 * </p>
 *
 * @author 聪明笨狗
 * @since 2020-04-13 16:57
 */
// 为 Swagger 文档标记该控制器的标签为 "管理用户"
@Api(tags = {"管理用户"})
// 标记该类为 RESTful 风格的控制器，返回数据直接作为 HTTP 响应体
@RestController
// 定义该控制器处理的请求路径前缀
@RequestMapping("/exam/api/sys/user")
public class SysUserController extends BaseController {

    // 自动注入系统用户服务实例，用于调用用户相关的业务逻辑
    @Autowired
    private SysUserService baseService;

    /**
     * 用户登录接口，接收用户登录请求信息，调用服务层方法进行登录验证，并返回登录结果。
     *
     * @param reqDTO 包含用户登录信息的请求数据传输对象
     * @return 封装了用户登录响应信息的 API 统一响应对象
     */
    @CrossOrigin
    @ApiOperation(value = "用户登录")
    @RequestMapping(value = "/login", method = {RequestMethod.POST})
    public ApiRest<SysUserLoginDTO> login(@RequestBody SysUserLoginReqDTO reqDTO) {
        // 调用服务层的登录方法，传入用户名和密码，获取登录响应信息
        SysUserLoginDTO respDTO = baseService.login(reqDTO.getUsername(), reqDTO.getPassword());
        // 调用父类的成功响应方法，返回包含登录响应信息的响应对象
        return super.success(respDTO);
    }

    /**
     * 用户登出接口，接收 HTTP 请求，从请求头中获取 token，调用服务层方法进行登出操作，并返回操作结果。
     *
     * @param request HTTP 请求对象，用于获取请求头中的 token
     * @return 封装了登出操作结果的 API 统一响应对象
     */
    @CrossOrigin
    @ApiOperation(value = "用户登录")
    @RequestMapping(value = "/logout", method = {RequestMethod.POST})
    public ApiRest logout(HttpServletRequest request) {
        // 从请求头中获取 token
        String token = request.getHeader("token");
        // 打印当前会话的 token 信息
        System.out.println("+++++当前会话为："+token);
        // 调用服务层的登出方法，传入 token 进行登出操作
        baseService.logout(token);
        // 调用父类的成功响应方法，返回操作成功的响应对象
        return super.success();
    }

    /**
     * 获取会话信息接口，接收 token 参数，调用服务层方法根据 token 获取用户会话信息，并返回会话信息。
     *
     * @param token 用户的 token，用于验证用户身份并获取会话信息
     * @return 封装了用户会话信息的 API 统一响应对象
     */
    @ApiOperation(value = "获取会话")
    @RequestMapping(value = "/info", method = {RequestMethod.POST})
    public ApiRest info(@RequestParam("token") String token) {
        // 调用服务层的 token 方法，传入 token 获取用户会话信息
        SysUserLoginDTO respDTO = baseService.token(token);
        // 调用父类的成功响应方法，返回包含会话信息的响应对象
        return success(respDTO);
    }

    /**
     * 修改用户资料接口，接收用户资料修改请求信息，调用服务层方法进行用户资料修改，并返回操作结果。
     *
     * @param reqDTO 包含用户资料修改信息的请求数据传输对象
     * @return 封装了用户资料修改操作结果的 API 统一响应对象
     */
    @ApiOperation(value = "修改用户资料")
    @RequestMapping(value = "/update", method = {RequestMethod.POST})
    public ApiRest update(@RequestBody SysUserDTO reqDTO) {
        // 调用服务层的更新方法，传入用户资料修改信息进行用户资料修改
        baseService.update(reqDTO);
        // 调用父类的成功响应方法，返回操作成功的响应对象
        return success();
    }

    /**
     * 保存或修改系统用户接口，要求用户具有 "sa" 角色，接收用户保存或修改请求信息，调用服务层方法进行用户保存或修改操作，并返回操作结果。
     *
     * @param reqDTO 包含用户保存或修改信息的请求数据传输对象
     * @return 封装了用户保存或修改操作结果的 API 统一响应对象
     */
    @RequiresRoles("sa")
    @ApiOperation(value = "保存或修改")
    @RequestMapping(value = "/save", method = {RequestMethod.POST})
    public ApiRest save(@RequestBody SysUserSaveReqDTO reqDTO) {
        // 调用服务层的保存方法，传入用户保存或修改信息进行用户保存或修改操作
        baseService.save(reqDTO);
        // 调用父类的成功响应方法，返回操作成功的响应对象
        return success();
    }

    /**
     * 批量删除用户接口，要求用户具有 "sa" 角色，接收包含多个用户 ID 的请求信息，调用服务层方法根据 ID 批量删除用户，并返回操作结果。
     *
     * @param reqDTO 包含多个用户 ID 的请求数据传输对象，用于指定要删除的用户
     * @return 封装了批量删除用户操作结果的 API 统一响应对象
     */
    @RequiresRoles("sa")
    @ApiOperation(value = "批量删除")
    @RequestMapping(value = "/delete", method = { RequestMethod.POST})
    public ApiRest edit(@RequestBody BaseIdsReqDTO reqDTO) {
        // 根据传入的用户 ID 列表，调用服务层的删除方法批量删除用户
        baseService.removeByIds(reqDTO.getIds());
        // 调用父类的成功响应方法，返回操作成功的响应对象
        return super.success();
    }

    /**
     * 分页查找用户接口，要求用户具有 "sa" 角色，接收分页请求信息，调用服务层方法进行分页查询，并返回分页查询结果。
     *
     * @param reqDTO 包含分页查询条件和参数的请求数据传输对象
     * @return 封装了分页查询结果的 API 统一响应对象
     */
    @RequiresRoles("sa")
    @ApiOperation(value = "分页查找")
    @RequestMapping(value = "/paging", method = { RequestMethod.POST})
    public ApiRest<IPage<SysUserDTO>> paging(@RequestBody PagingReqDTO<SysUserDTO> reqDTO) {
        // 调用服务层的分页查询方法，传入分页请求信息进行分页查询并转换结果
        IPage<SysUserDTO> page = baseService.paging(reqDTO);
        // 调用父类的成功响应方法，返回包含分页查询结果的响应对象
        return super.success(page);
    }

    /**
     * 修改用户状态接口，要求用户具有 "sa" 角色，接收用户状态修改请求信息，构建查询条件，调用服务层方法修改用户状态，并返回操作结果。
     *
     * @param reqDTO 包含用户状态修改信息的请求数据传输对象
     * @return 封装了用户状态修改操作结果的 API 统一响应对象
     */
    @RequiresRoles("sa")
    @ApiOperation(value = "修改状态")
    @RequestMapping(value = "/state", method = { RequestMethod.POST})
    public ApiRest state(@RequestBody BaseStateReqDTO reqDTO) {
        // 创建 MyBatis-Plus 的查询条件构造器，用于构建查询条件
        QueryWrapper<SysUser> wrapper = new QueryWrapper<>();
        // 使用 Lambda 表达式构建查询条件，筛选出 ID 在请求 ID 列表中且用户名不为 "admin" 的用户
        wrapper.lambda()
                .in(SysUser::getId, reqDTO.getIds())
                .ne(SysUser::getUserName, "admin");

        // 创建一个新的用户实体对象，用于设置要修改的状态
        SysUser record = new SysUser();
        // 设置用户状态为请求中的状态
        record.setState(reqDTO.getState());
        // 调用服务层的更新方法，根据查询条件更新用户状态
        baseService.update(record, wrapper);

        // 调用父类的成功响应方法，返回操作成功的响应对象
        return super.success();
    }

    /**
     * 学员注册接口，接收学员注册请求信息，调用服务层方法进行学员注册，并返回注册结果。
     *
     * @param reqDTO 包含学员注册信息的请求数据传输对象
     * @return 封装了学员注册响应信息的 API 统一响应对象
     */
    @ApiOperation(value = "学员注册")
    @RequestMapping(value = "/reg", method = {RequestMethod.POST})
    public ApiRest<SysUserLoginDTO> reg(@RequestBody SysUserDTO reqDTO) {
        // 调用服务层的注册方法，传入学员注册信息进行学员注册，获取注册响应信息
        SysUserLoginDTO respDTO = baseService.reg(reqDTO);
        // 调用父类的成功响应方法，返回包含注册响应信息的响应对象
        return success(respDTO);
    }

    /**
     * 快速注册接口，接收用户信息，调用服务层方法进行快速注册，如果手机号存在则登录，不存在就注册，并返回操作结果。
     *
     * @param reqDTO 包含用户信息的请求数据传输对象
     * @return 封装了快速注册响应信息的 API 统一响应对象
     */
    @ApiOperation(value = "快速注册")
    @RequestMapping(value = "/quick-reg", method = {RequestMethod.POST})
    public ApiRest<SysUserLoginDTO> quick(@RequestBody SysUserDTO reqDTO) {
        // 调用服务层的快速注册方法，传入用户信息进行快速注册，获取注册或登录响应信息
        SysUserLoginDTO respDTO = baseService.quickReg(reqDTO);
        // 调用父类的成功响应方法，返回包含注册或登录响应信息的响应对象
        return success(respDTO);
    }
}