package com.hxzk.gps.controller.User;

import cn.dev33.satoken.annotation.SaCheckLogin;
import cn.dev33.satoken.stp.StpUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.hxzk.gps.controller.User.Results.MenuListResult;
import com.hxzk.gps.controller.User.Results.UserTreeTableDto;
import com.hxzk.gps.controller.User.Results.UserResult;
import com.hxzk.gps.entity.Role.Role;
import com.hxzk.gps.entity.User.TbUser;
import com.hxzk.gps.entity.User.dto.LoginResult;
import com.hxzk.gps.service.Role.IRoleService;
import com.hxzk.gps.service.User.TbUserService;
import com.hxzk.gps.util.GetUser.UserInfoUtil;
import com.hxzk.gps.util.MessageUtils.MessageUtils;
import com.hxzk.gps.util.Result.ReturnMessage;
import com.hxzk.gps.util.SMS.TenSMS;
import com.hxzk.gps.util.Time.TimeUtil;
import com.tencentcloudapi.common.exception.TencentCloudSDKException;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static com.hxzk.gps.util.AES.AES.encrypt;

/**
 * <p>
 *  前端控制器
 *  用户管理
 * </p>
 *
 * @author YuZhiTong
 * @since 2025-04-17
 */
@RestController
@RequestMapping("/User")
@Api(tags="用户管理")
public class TbUserController {
    @Autowired
    private TbUserService tbUserService;
    @Autowired
    IRoleService roleService;
    // 登录

    Map<String,String> UserSmsMap = new HashMap<>();
    @ApiOperation(value = "用户密码登录接口", notes = "该接口用于用户登录系统，接收用户名和密码作为参数，返回加密Token信息")
    @PostMapping("/Login")
    public LoginResult Login(@RequestBody TbUser user, HttpServletRequest request) {
        String clientIp = getClientIp(request);
        return tbUserService.Login(user.getUsername(),user.getPassword(),user.getStatus(),clientIp);
    }
    @ApiOperation(value = "用户手机号登录接口", notes = "该接口用于用户登录系统，接收用户名和密码作为参数，返回加密Token信息")
    @PostMapping("/phoneLogin")
    public LoginResult phoneLogin(@RequestBody TbUser user, HttpServletRequest request) {
        String clientIp = getClientIp(request);
        String code = UserSmsMap.get(user.getPhone());
        if (code.equals(user.getPassword())){
            //登录成功
            unfreezeUser(user);
            return tbUserService.phoneLogin(user.getPhone(),clientIp);
        }else{
            return new LoginResult(201, MessageUtils.getMessage("LoginSmSError"), "000");
        }
    }
    @RequestMapping("GetToken")
    public TbUser GetToken(@RequestBody TbUser user) throws Exception {
        TbUser user1 = new TbUser();
        user1.setUsername(encrypt(user.getUsername()));
        user1.setPassword(encrypt(user.getPassword()));
        return user1;
    }
    @ApiOperation(value = "用户冻结接口", notes = "该接口用于用户冻结")
    @PostMapping("/freezeUser")
    public boolean freezeUser(@RequestBody TbUser user) {
       QueryWrapper queryWrapper = new QueryWrapper<>();
       queryWrapper.eq("username",user.getUsername());
       user.setStatus("1");
       return tbUserService.update(user,queryWrapper);
    }

    @ApiOperation(value = "用户解冻接口", notes = "该接口用于用户冻结")
    @PostMapping("/unfreezeUser")
    public boolean unfreezeUser(@RequestBody TbUser user) {
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("username",user.getUsername());
        user.setStatus("0");
        return tbUserService.update(user,queryWrapper);
    }

    @ApiOperation(value = "检查登录接口", notes = "该接口用于检查用户是否还在登录状态，返回布尔值表示是否登录")
    @RequestMapping("isLogin")
    public boolean isLogin(){
        return StpUtil.isLogin();
    }

    @ApiOperation(value = "用户菜单接口", notes = "该接口用于展示用户导航菜单信息")
    @SaCheckLogin
    @RequestMapping("MenuList")
    public MenuListResult MenuList(){
      return tbUserService.UserMenu();
    }


    @SaCheckLogin
    @ApiOperation(value = "平台用户列表接口", notes = "该接口提供了平台用户的信息查询功能")
    @PostMapping("FindUserInfo")
    public UserResult FindUserInfo(@RequestBody UserTreeTableDto userTreeTableDto){
        return tbUserService.FindUserInfo(userTreeTableDto);
    }
    @SaCheckLogin
    @ApiOperation(value = "平台导航菜单列表接口", notes = "该接口提供了平台导航菜单列表信息")
    @PostMapping("Menu/All")
    public MenuListResult MenuAll(){
        return tbUserService.MenuAll();
    }


    @PostMapping("/sendSmsApi")
    public ReturnMessage SendMsage(@RequestBody TbUser user) throws TencentCloudSDKException {
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("phone",user.getPhone());
        Integer result = Math.toIntExact(tbUserService.getBaseMapper().selectCount(queryWrapper));
        if (result >= 1){
           //发送短信
            TenSMS tenSMS = new TenSMS();
            String code = generateVerificationCode();
            tenSMS.sms(user.getPhone(),code);
            UserSmsMap.put(user.getPhone(),code);
            return ReturnMessage.ReturnMessageSuccess("SmsSuccess");
        }else{
            return ReturnMessage.ReturnMessageError("PhoneError");
        }
    }


    @PostMapping("/SendWarning")
    public ReturnMessage SendWarning(@RequestBody TbUser user) throws TencentCloudSDKException {
        TenSMS tenSMS = new TenSMS();
        tenSMS.smsWarning(user.getPhone(), user.getStatus());
        return ReturnMessage.ReturnMessageSuccess("SmsSuccess");
    }

    @SaCheckLogin
    @ApiOperation(value = "平台用户退出接口", notes = "该接口提供了平台用户退出")
    @PostMapping("logout")
    public String logout(){
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("username",UserInfoUtil.getUserName());
        TbUser user = new TbUser();
        user.setStatus("0");
        user.setUsername(UserInfoUtil.getUserName());
        tbUserService.getBaseMapper().update(user,queryWrapper);
        StpUtil.logout();
        return "已退出";
    }

    @SaCheckLogin
    @ApiOperation(value = "平台用户添加接口", notes = "该接口提供了平台用户添加功能")
    @PostMapping("add")
    public ReturnMessage add(@RequestBody TbUser user){
        return tbUserService.add(user);
    }

    @SaCheckLogin
    @ApiOperation(value = "平台用户修改接口", notes = "该接口提供了平台用户修改功能")
    @PostMapping("update")
    public ReturnMessage update(@RequestBody TbUser user){
        return tbUserService.update(user);
    }

    @SaCheckLogin
    @ApiOperation(value = "平台用户删除接口", notes = "该接口提供了平台用户删除功能")
    @PostMapping("delete")
    public ReturnMessage delete(@RequestBody TbUser user){
        return tbUserService.delete(user);
    }

    @SaCheckLogin
    @ApiOperation(value = "平台获取用户名称接口", notes = "该接口提供了平台获取用户名称功能")
    @PostMapping("FindUserName")
    public TbUser FindUserName(){
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("username",UserInfoUtil.getUserName());
        TbUser user = tbUserService.getBaseMapper().selectOne(queryWrapper);
        return user;
    }


    @SaCheckLogin
    @ApiOperation(value = "平台用户权限接口", notes = "该接口提供了平台用户权限查询功能")
    @GetMapping("buttons")
    public Map loginTest1(){
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("username", UserInfoUtil.getUserName());
        TbUser user1 = tbUserService.getBaseMapper().selectOne(queryWrapper);
        QueryWrapper queryWrapper1  = new QueryWrapper<>();
        queryWrapper1.eq("id",user1.getJueseid());
        Role role = roleService.getBaseMapper().selectOne(queryWrapper1);
        List<String> user = new ArrayList<>();
        if (role.isAddrole()){
            user.add("add");
        }
        if (role.isEditrole()){
            user.add("edit");
        }
        if (role.isDeleterole()){
            user.add("delete");
        }
        // 创建权限数据对象
        Map<String, List<String>> data = new HashMap<>();
        data.put("role", user);
        // 创建响应对象
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);
        map.put("data", data);
        return map;
    }



    private String getClientIp(HttpServletRequest request) {
        String xffHeader = request.getHeader("X-Forwarded-For");
        if (xffHeader == null || xffHeader.isEmpty() || "unknown".equalsIgnoreCase(xffHeader)) {
            // 如果 X-Forwarded-For 头不存在或者无效，则尝试从其他常见的头获取
            String proxyClientIp = request.getHeader("Proxy-Client-IP");
            if (proxyClientIp != null && !proxyClientIp.isEmpty() && !"unknown".equalsIgnoreCase(proxyClientIp)) {
                return proxyClientIp;
            }
            String wlProxyClientIp = request.getHeader("WL-Proxy-Client-IP");
            if (wlProxyClientIp != null && !wlProxyClientIp.isEmpty() && !"unknown".equalsIgnoreCase(wlProxyClientIp)) {
                return wlProxyClientIp;
            }
            // 若都没有，直接使用 request.getRemoteAddr()
            return request.getRemoteAddr();
        } else {
            // X-Forwarded-For 头存在，取第一个 IP 地址
            int index = xffHeader.indexOf(',');
            if (index != -1) {
                return xffHeader.substring(0, index);
            } else {
                return xffHeader;
            }
        }
    }

/*
* 生成六位数随机验证码
* */
    public static String generateVerificationCode() {
        // 生成 0 到 999999 之间的随机整数
        int randomNum = (int) (Math.random() * 1000000);
        // 将随机整数格式化为 6 位字符串，不足 6 位时前面补 0
        return String.format("%06d", randomNum);
    }
}