package com.controller;

import java.util.Arrays;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import com.service.UsersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.annotation.IgnoreAuth;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.UsersEntity;
import com.service.TokenService;
import com.utils.MPUtil;
import com.utils.PageUtils;
import com.utils.R;

/**
 * 登录相关
 */
// 定义请求映射路径，所有以/users开头的请求会被该控制器处理
@RequestMapping("users")
// 声明该类为一个RESTful风格的控制器，用于处理HTTP请求并返回JSON数据
@RestController
public class UsersController {

	// 自动注入UsersService，用于处理与用户相关的业务逻辑
	@Autowired
	private UsersService usersService;

	// 自动注入TokenService，用于处理与令牌相关的业务逻辑
	@Autowired
	private TokenService tokenService;

	/**
	 * 处理用户登录请求
	 * @param username 用户名
	 * @param password 密码
	 * @param captcha 验证码（当前代码未实际使用该参数）
	 * @param request HTTP请求对象
	 * @return R类型的响应对象，包含登录结果信息
	 */
	@IgnoreAuth // 忽略权限验证的注解
	@PostMapping(value = "/login")
	public R login(String username, String password, String captcha, HttpServletRequest request) {
		// 根据用户名查询用户实体
		UsersEntity user = usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
		// 如果用户不存在或者用户输入的密码与数据库中存储的密码不匹配
		if (user == null || !user.getPassword().equals(password)) {
			// 返回错误响应，提示账号或密码不正确
			return R.error("账号或密码不正确");
		}
		// 生成用户令牌，参数依次为用户ID、用户名、用户类型标识、用户角色
		String token = tokenService.generateToken(user.getId(), username, "users", user.getRole());
		// 创建一个成功的响应对象
		R r = R.ok();
		// 将生成的令牌放入响应数据中
		r.put("token", token);
		// 将用户的角色信息放入响应数据中
		r.put("role", user.getRole());
		// 将用户的ID信息放入响应数据中
		r.put("userId", user.getId());
		// 返回响应对象
		return r;
	}

	/**
	 * 注册
	 */
	@IgnoreAuth
	@PostMapping(value = "/register")
	public R register(@RequestBody UsersEntity user) {
//    	ValidatorUtils.validateEntity(user); // 被注释掉的代码，可能用于验证用户实体的合法性，目前未启用
		// 根据用户名查询数据库，判断用户是否已经存在
		if (usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) != null) {
			// 如果用户已存在，返回错误响应
			return R.error("用户已存在");
		}
		// 将新用户插入到数据库中
		usersService.insert(user);
		// 返回成功响应
		return R.ok();
	}

	/**
	 * 退出
	 */
	@GetMapping(value = "logout")
	public R logout(HttpServletRequest request) {
		// 使当前用户的会话失效，实现退出登录
		request.getSession().invalidate();
		// 返回成功响应，并附带退出成功的提示信息
		return R.ok("退出成功");
	}

	/**
	 * 处理用户密码重置请求
	 * @param username 用户名
	 * @param request HTTP请求对象
	 * @return R类型的响应对象，包含密码重置结果信息
	 */
	@IgnoreAuth // 忽略权限验证的注解
	@RequestMapping(value = "/resetPass")
	public R resetPass(String username, HttpServletRequest request) {
		// 根据用户名查询用户实体
		UsersEntity user = usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
		// 如果用户不存在
		if (user == null) {
			// 返回错误响应，提示账号不存在
			return R.error("账号不存在");
		}
		// 将用户密码重置为默认值123456
		user.setPassword("123456");
		// 更新用户信息到数据库（第二个参数为null，可能表示更新时不设置额外的条件）
		usersService.update(user, null);
		// 返回成功响应，并附带密码已重置的提示信息
		return R.ok("密码已重置为：123456");
	}

	/**
	 * 处理获取用户列表的分页请求
	 * @param params 包含分页和查询条件的参数Map
	 * @param user 用户实体对象，可能用于构建查询条件
	 * @return R类型的响应对象，包含分页后的用户列表数据
	 */
	@RequestMapping("/page")
	public R page(@RequestParam Map<String, Object> params, UsersEntity user) {
		// 创建一个EntityWrapper对象，用于构建查询条件
		EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
		// 调用usersService的queryPage方法进行分页查询，MPUtil.sort等方法用于处理查询条件和排序
		PageUtils page = usersService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
		// 返回成功响应，并将分页结果数据放入响应中
		return R.ok().put("data", page);
	}

	/**
	 * 处理获取用户列表的请求
	 * @param user 用户实体对象，用于构建查询条件
	 * @return R类型的响应对象，包含用户列表数据
	 */
	@RequestMapping("/list")
	public R list(UsersEntity user) {
		// 创建一个EntityWrapper对象
		EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
		// 根据用户实体对象构建查询条件，使用MPUtil.allEQMapPre方法设置相等条件
		ew.allEq(MPUtil.allEQMapPre(user, "user"));
		// 调用usersService的selectListView方法查询用户列表，并将结果放入响应中返回
		return R.ok().put("data", usersService.selectListView(ew));
	}

	/**
	 * 处理获取指定用户信息的请求
	 * @param id 用户ID，通过路径变量获取
	 * @return R类型的响应对象，包含指定用户的信息
	 */
	@RequestMapping("/info/{id}")
	public R info(@PathVariable("id") String id) {
		// 根据用户ID查询用户实体
		UsersEntity user = usersService.selectById(id);
		// 返回成功响应，并将用户信息放入响应中
		return R.ok().put("data", user);
	}

	/**
	 * 处理获取当前会话用户信息的请求
	 * @param request HTTP请求对象
	 * @return R类型的响应对象，包含当前会话用户的信息
	 */
	@RequestMapping("/session")
	public R getCurrUser(HttpServletRequest request) {
		// 从当前会话中获取用户ID
		Integer id = (Integer) request.getSession().getAttribute("userId");
		// 根据用户ID查询用户实体
		UsersEntity user = usersService.selectById(id);
		// 返回成功响应，并将用户信息放入响应中
		return R.ok().put("data", user);
	}

	/**
	 * 处理保存新用户的请求
	 * @param user 用户实体对象，通过请求体获取
	 * @return R类型的响应对象，包含保存结果信息
	 */
	@PostMapping("/save")
	public R save(@RequestBody UsersEntity user) {
//    	ValidatorUtils.validateEntity(user); // 被注释掉的代码，可能用于验证用户实体的合法性，目前未启用
		// 根据用户名查询数据库，判断用户是否已经存在
		if (usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) != null) {
			// 如果用户已存在，返回错误响应
			return R.error("用户已存在");
		}
		// 设置用户密码为默认值123456
		user.setPassword("123456");
		// 将用户插入到数据库中
		usersService.insert(user);
		// 返回成功响应
		return R.ok();
	}

	/**
	 * 处理更新用户信息的请求
	 * @param user 用户实体对象，通过请求体获取
	 * @return R类型的响应对象，包含更新结果信息
	 */
	@RequestMapping("/update")
	public R update(@RequestBody UsersEntity user) {
//        ValidatorUtils.validateEntity(user); // 被注释掉的代码，可能用于验证用户实体的合法性，目前未启用
		// 根据用户ID更新用户信息到数据库
		usersService.updateById(user); // 全部更新
		// 返回成功响应
		return R.ok();
	}

	/**
	 * 处理删除用户的请求
	 * @param ids 要删除的用户ID数组，通过请求体获取
	 * @return R类型的响应对象，包含删除结果信息
	 */
	@RequestMapping("/delete")
	public R delete(@RequestBody Long[] ids) {
		// 根据用户ID数组批量删除用户
		usersService.deleteBatchIds(Arrays.asList(ids));
		// 返回成功响应
		return R.ok();
	}
}