package vvpkassistant.controller;
import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.bean.BeanUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import vvpkassistant.CoinRecords.CoinRecords;
import vvpkassistant.CoinRecords.CoinRecordsDao;
import vvpkassistant.Data.ResponseData;
import vvpkassistant.Data.ResponseInfo;
import vvpkassistant.Data.WxChatParam;
import vvpkassistant.User.mapper.UserDao;
import vvpkassistant.User.model.DTO.ScanInfoDTO;
import vvpkassistant.User.model.DTO.UserModelDTO;
import vvpkassistant.User.model.UserModel;
import vvpkassistant.User.model.UserModelVO;
import vvpkassistant.User.service.UserService;
import vvpkassistant.common.ErrorCode;
import vvpkassistant.config.FunctionConfigHolder;
import vvpkassistant.Tools.VVRequester;
import vvpkassistant.Tools.VVTools;
import vvpkassistant.exception.BusinessException;
import vvpkassistant.mail.model.MailModel;
import vvpkassistant.mail.service.MailService;
import vvpkassistant.pk.mapper.PkInfoDao;
import vvpkassistant.pk.model.PkInfoModel;
import vvpkassistant.pk.model.PkRecordDetail;
import vvpkassistant.pk.mapper.PkRecordDetailDao;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("user")
public class UserController {

    @Autowired
    private UserDao userDao;

    @Autowired
    private PkInfoDao pkInfoDao;

    @Autowired
    private PkRecordDetailDao detailDao;

    @Autowired
    private CoinRecordsDao coinRecordsDao;

    @Autowired
    private WxChatParam wxChatParam;

    @Autowired
    private VVRequester vvRequester;


    @Resource
    private UserService userService;

    @Resource
    private MailService mailService;

    // 配置用户信息
    @PostMapping("inputUserInfo")
    public ResponseData<Object> inputUserInfo(@RequestBody Map<String,Object> param) {

        if (!param.containsKey("code")) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR,"code不能为空");
        }

        if (!param.containsKey("id")) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR,"id不能为空");
        }

        //获取前端传递过来的code
        String code = param.get("code").toString();

        // 调用微信获取openid接口
        Map<String, Object> wx_result = vvRequester.loginApp(code);

        // 错误处理
        if (wx_result.containsKey("errcode")) {
            Integer errcode = Integer.valueOf(wx_result.get("errcode").toString());

            if (errcode == 45011) {
                throw new BusinessException(ErrorCode.WX_API_CALL_TOO_FREQUENT);
            }

            if (errcode == 40029) {
                throw new BusinessException(ErrorCode.WX_INVALID_JSCODE);
            }

            if (errcode == 40226) {
                throw new BusinessException(ErrorCode.WX_RISK_ACCOUNT);
            }

            if (errcode == -1) {
                throw new BusinessException(ErrorCode.WX_SYSTEM_BUSY);
            }

            if (!wx_result.containsKey("openid")) {
               throw new BusinessException(ErrorCode.WX_GET_USER_INFO_FAILED);
            }
        }

        //查询用户
        String openId = wx_result.get("openid").toString();
        String sessionKey = wx_result.get("session_key").toString();

        // 创建一个临时model
        UserModel tempModel = new UserModel();
        tempModel.setId(Integer.valueOf(param.get("id").toString()));
        tempModel.setUserChatId(openId);
        int i = userDao.updateById(tempModel);
        if (i == 1) {
//            String usersig = param.get("usersig").toString();
//            // 注册聊天账号
//            Integer createAccountResult = vvRequester.createChatAccount(tempModel, usersig);
//            if (createAccountResult != 0) {
//                return ResponseData.error(ResponseInfo.ERROR,"创建聊天账号失败，请稍后再试");
//            }
            Map<String,Object> result = new HashMap<>();
            StpUtil.login(tempModel.getId());
            UserModelVO userModelVO = BeanUtil.copyProperties(tempModel, UserModelVO.class);
            userModelVO.setToken(StpUtil.getTokenValue());
            result.put("info", userModelVO);
            result.put("newAccount",false);
            //否则直接返回用户
            return ResponseData.success(result);
        }
        throw new BusinessException(ErrorCode.SYSTEM_ERROR);
    }

    // 手机号登录  / 注册
    @PostMapping("loginWithPhoneNumber")
    public ResponseData<Object> loginWithPhoneNumber(@RequestBody Map<String,Object> param) {

        if (!param.containsKey("code")) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR,"code不能为空");
        }

        String code = param.get("code").toString();
        String phoneNumber = vvRequester.queryPhoneNumber(code);
        if (phoneNumber.isEmpty()) {
            throw  new BusinessException(ErrorCode.PARAMS_ERROR,"手机号码无法查询");
        }

        // 查询是否存在用户。如果用户存在直接返回 如果用户不存在则新建用户
        UserModel model = userDao.queryWithPhoneNumber(phoneNumber);
        Map<String,Object> result = new HashMap<>();
        if (model != null) { // 老用户
            UserModelVO userModelVO = BeanUtil.copyProperties(model, UserModelVO.class);
            StpUtil.login(userModelVO.getId());
            userModelVO.setToken(StpUtil.getTokenValue());
            result.put("info",userModelVO);
            result.put("newAccount", false);
            result.put("chatInfo",wxChatParam);
            return ResponseData.success(result);
        }else{ // 新用户
            UserModel tempModel = new UserModel();
            //设置状态为正常
            tempModel.setStatus(0);
            //设置积分为0
            tempModel.setPoints(0);
            userDao.insert(tempModel);

            // 判断用户是否为邀请用户
            if (param.containsKey("inviterId")) {
                int inviterId = (int) param.get("inviterId");
                // 查询用户增加积分
                UserModel oldUser = userDao.selectById(inviterId);
                oldUser.setPoints(oldUser.getPoints() + 10);
                userDao.updateById(oldUser);
            }

            UserModelVO userModelVO = BeanUtil.copyProperties(tempModel, UserModelVO.class);
            StpUtil.login(userModelVO.getId());
            userModelVO.setToken(StpUtil.getTokenValue());
            result.put("info",userModelVO);
            result.put("newAccount",true);
            result.put("chatInfo",wxChatParam);

            return ResponseData.success(result);

        }

    }


    // 修改用户信息
    @PostMapping("updateUserInfo")
    public ResponseData<Object> updateUserInfo(@RequestBody UserModelDTO userModelDTO) {
//        UserModelVO userModelVO = userService.updateUserInfo( userModelDTO);
//        return ResponseData.success(userModelVO);
        return null;
    }

    // 获取用户信息
    @PostMapping("getUserInfo")
    public ResponseData<Object> getUserInfo(@RequestBody UserModelDTO userModelDTO) {
        if (userModelDTO.getId() == null){
            throw new BusinessException(ErrorCode.PARAMS_ERROR);
        }
        UserModel userModel = userDao.selectById(userModelDTO.getId());
        if (userModel == null) {
            throw new BusinessException(ErrorCode.USER_DOES_NOT_EXIST);
        }
        UserModelVO userModelVO = BeanUtil.copyProperties(userModel, UserModelVO.class);
        return ResponseData.success(userModelVO);
    }

    // 查询用户所有pk数据
    @PostMapping("queryMyAllPkData")
    public ResponseData<Object> queryMyAllPkData(@RequestBody Map<String,Integer> map) {
        Integer userId = map.get("userId");
        Integer page = map.get("page");
        Integer size = map.get("size");
        List<PkInfoModel> pkInfoModels = pkInfoDao.queryAllPkData(userId, page * size, size);
        long currentTimeStamp = VVTools.currentTimeStamp();
        // 查找置顶的数据
        for (PkInfoModel pkInfoModel : pkInfoModels) {
            pkInfoModel.setIsPin(pkInfoModel.getPinExpireTime() > currentTimeStamp);
        }
        return ResponseData.success(pkInfoModels);
    }

    // 查询我的pk记录 列表
    @PostMapping("handlePkInfo")
    public ResponseData<Object> handlePkInfo(@RequestBody Map<String,Integer> map) {
        Integer type = map.get("type");
        Integer id = map.get("userId");
        Integer page = map.get("page");
        Integer size = map.get("size");

        // 我发起的pk数据
        if (type == 1) {
            return ResponseData.success(userDao.findCreatedPk(id, page * size, size));
        }else if (type == 2){
            // 别人邀请我的pk数据
            return ResponseData.success(userDao.getMyGuestPkList(id, page * size, size));
        }
        throw new BusinessException(ErrorCode.SYSTEM_ERROR);
    }


    // 查詢单条pk记录详情
    @PostMapping("pkRecordDetail")
    public ResponseData<Object> pkRecordDetail(@RequestBody Map<String,Integer> map) {
        Integer id = map.get("id");
        List<PkRecordDetail> pkRecordDetails = detailDao.queryDetail(id);
        return ResponseData.success(pkRecordDetails);
    }

    // 签到
    @PostMapping("signIn")
    public ResponseData<Object> signIn() {
        int userId = Integer.parseInt(StpUtil.getLoginId().toString());
        int i = userDao.checkSignStatus(userId);
        if (i != 0) {
            throw new BusinessException(ErrorCode.SIGN_IN_FAIL);
        }

        int result = userDao.signIn(userId);
        UserModel userModel = userDao.selectById(userId);
        int count = Integer.parseInt(FunctionConfigHolder.getValue("签到增加积分"));

        // 增加积分
        userModel.setPoints(userModel.getPoints() + count);

        // 入库
        userDao.updateById(userModel);

        if (result == 1) {
            // 增加记录
            CoinRecords coinRecords = new CoinRecords("签到增加积分",userId,count, (int) VVTools.currentTimeStamp(),1);
            coinRecordsDao.insert(coinRecords);
            return ResponseData.success(null);
        }else {
           throw new BusinessException(ErrorCode.SYSTEM_ERROR,"签到失败");
        }
    }

    // 查询用户当天签到状态
    @GetMapping("checkSignStatus")
    public ResponseData<Object> checkSignStatus(Integer userId) {
        int i = userDao.checkSignStatus(userId);
        return i == 0 ? ResponseData.success(true) : ResponseData.success(false);
    }

    // 置顶文章
    @PostMapping("pinToTop")
    public ResponseData<Object> pinToTop(@RequestBody Map<String,Integer> map) {
        // 文章id
        Integer articleId = map.get("articleId");
        PkInfoModel pkInfoModel = pkInfoDao.selectById(articleId);
        Integer userId = pkInfoModel.getSenderId();
        // 到期时间戳
        Integer pinExpireTime = map.get("pinExpireTime");

        long currentTimeStamp = VVTools.currentTimeStamp();
        long hour = VVTools.calculateHoursRound(pinExpireTime, currentTimeStamp);
        String coin = FunctionConfigHolder.getValue("置顶扣除积分");
        int totalCoin = (int) (Integer.parseInt(coin) * hour);

        UserModel userModel = userDao.selectById(userId);
        if (userModel != null) {
            // 扣除积分 更新数据
            Integer points = userModel.getPoints();
            if (points - totalCoin > 0) {
                userModel.setPoints(userModel.getPoints() - totalCoin);
                userDao.updateById(userModel);
                // 设置置顶到期时间
                pkInfoModel.setPinExpireTime(pinExpireTime);
                // 设置创建置顶的时间
                pkInfoModel.setPinCreateTime((int) VVTools.currentTimeStamp());
                // 更新pk文章数据
                int i = pkInfoDao.updateById(pkInfoModel);
                if (i == 1) {
                    String info = String.format("置顶成功，扣除%d积分",totalCoin);
                    // 增加积分变动记录
                    CoinRecords coinRecords = new CoinRecords("置顶扣除积分",userId,totalCoin, (int) VVTools.currentTimeStamp(),0);
                    coinRecordsDao.insert(coinRecords);
                    // 返回给前端数据
                    return ResponseData.success(info);
                }else {
                    throw new BusinessException(ErrorCode.SYSTEM_ERROR);
                }
            }else {
                throw new BusinessException(ErrorCode.SYSTEM_ERROR,String.format("积分不足,需要%d积分",totalCoin));
            }
        }else {
            throw new BusinessException(ErrorCode.SYSTEM_ERROR,"用户不存在");
        }
    }

    // 取消置顶
    @PostMapping("cancelPin")
    public ResponseData<Object> cancelPin(@RequestBody Map<String,Integer> map) {
        Integer articleId = map.get("articleId");
        PkInfoModel pkInfoModel = pkInfoDao.selectById(articleId);
        Integer pinExpireTime = pkInfoModel.getPinExpireTime();
        long hour = VVTools.calculateHoursFloor(pinExpireTime, VVTools.currentTimeStamp());

        String coin = FunctionConfigHolder.getValue("置顶扣除积分");
        // 计算总积分。用于返还给用户
        int totalCoin = (int) (Integer.parseInt(coin) * hour);

        // 获取用户对象
        UserModel userModel = userDao.selectById(pkInfoModel.getSenderId());
        Integer points = userModel.getPoints();
        // 返还用户积分
        userModel.setPoints(points + totalCoin);
        // 更新数据库
        userDao.updateById(userModel);

        // 重置置顶时间
        pkInfoModel.setPinExpireTime(0);
        pkInfoModel.setPinCreateTime(0);
        int i = pkInfoDao.updateById(pkInfoModel);
        if (i == 1) {
            // 添加积分更变相关记录
            CoinRecords coinRecords = new CoinRecords("取消置顶返还积分",pkInfoModel.getSenderId(),totalCoin, (int) VVTools.currentTimeStamp(),1);
            coinRecordsDao.insert(coinRecords);
            return ResponseData.success(String.format("操作成功，返还%d积分",totalCoin));
        }else {
            return ResponseData.error(ResponseInfo.ERROR.getCode(),null);
        }

    }


    // 获取积分明细
    @PostMapping("pointsDetail")
    public ResponseData<Object> pointsDetail(@RequestBody Map<String,Integer> map) {
        Integer userId = map.get("userId");
        Integer page = map.get("page");
        Integer size = map.get("size");
        List<CoinRecords> coinRecords = coinRecordsDao.fetchMyPointsData(userId, page * size, size);
        return ResponseData.success(coinRecords);
    }

////    邮件登录接口
//    @PostMapping("/loginWithMail")
//    public  ResponseData<Object> loginWithMail(@RequestBody UserModelDTO model) {
//        return ResponseData.success(userService.loginWithMail(model));
//    }
//
////邮件注册接口
//    @PostMapping("/registerWithMail")
//    public ResponseData<Object> mailRegister(@RequestBody UserModelDTO model){
//        return ResponseData.success(userService.addUserWithMail(model));
//    }
//
////    用户邮件激活
//    @GetMapping("/activate")
//    public ResponseData<Object> activateAccount(@RequestParam("token") String token){
//        return ResponseData.success(userService.activateAccount(token));
//    }
//
////    重发邮件接口
//    @PostMapping("/resendMail")
//    public ResponseData<Object> resendMail(@RequestBody MailModel mailModel){
//        return ResponseData.success(mailService.resendMail(mailModel));
//    }
//
////    验证邮箱链接
//    @GetMapping("/verificationMail")
//    public ResponseData<Object> verificationMail(@RequestParam("token") String token){
//        return ResponseData.success(userService.verificationMail(token));
//    }
//
////    发送忘记密码邮件
//    @PostMapping("/forgetMail")
//    public ResponseData<Object> sendForgetPassWordMail(@RequestBody MailModel mailModel){
//        return ResponseData.success(userService.sendForgetPassWordMail(mailModel));
//    }
//
////    生成二维码登录接口
//    @GetMapping("/qrcode")
//    public ResponseData<Object> generatedQrcode(){
//        return ResponseData.success(userService.generatedQrcode());
//    }
//
////    检查二维码状态接口
//    @GetMapping("/check/{uuid}")
//    public ResponseData<Object> checkQrcode(@PathVariable String uuid){
//        return ResponseData.success(userService.checkQrcode(uuid));
//    }
//
////  二维码扫描状态
//    @PostMapping("/scan")
//    public ResponseData<?> scanQrCode(@RequestBody ScanInfoDTO scanInfoDTO) {
//        return ResponseData.success( userService.scanQrcode(scanInfoDTO));
//    }
//
////二维码扫描确认
//    @PostMapping("/confirm")
//    public ResponseData<?> confirm(@RequestBody ScanInfoDTO scanInfoDTO) {
//        userService.confirm(scanInfoDTO);
//        return ResponseData.success("");
//    }
//
////    注销接口
//    @PostMapping("/logout")
//    public ResponseData<Object> logOut(@RequestBody UserModelDTO userModelDTO){
//        userService.logOut(userModelDTO.getId());
//        return ResponseData.success("");
//    }
//
////    设置密码接口
//    @PostMapping("/setPassword")
//    public ResponseData<Object>setPassWord(@RequestBody UserModelDTO userModelDTO){
//        return ResponseData.success(userService.setPassWord(userModelDTO));
//    }
//
////    用户通过邮件验证链接重设密码接口
//    @PostMapping("/resetPassword")
//    public ResponseData<Object>resetPassWord(@RequestBody UserModelDTO userModelDTO){
//        return ResponseData.success(userService.resetPassWord(userModelDTO));
//    }
//
////    设置新邮箱接口
//    @PostMapping("/updateUserMail")
//    public ResponseData<Object>updateUserMail(@RequestBody MailModel mailModel){
//        return ResponseData.success(userService.updateUserMail(mailModel));
//    }
//
////    发送更新邮箱验证邮件接口
//    @PostMapping("/sendUpdateMailConfirmMail")
//    public ResponseData<Object>sendUpdateMailConfirmMail(@RequestBody MailModel mailModel){
//        return ResponseData.success(mailService.sendUpdateConfirmMail(mailModel));
//    }
//
////    检查重复用户名接口
//    @PostMapping("/checkUserName")
//    public ResponseData<Boolean>checkUserName(@RequestBody UserModelDTO userModelDTO){
//        return ResponseData.success(userService.checkUserName(userModelDTO));
//    }
}