package com.ruoyi.study.controller;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.alibaba.fastjson.JSONObject;
import com.alipay.api.AlipayApiException;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ruoyi.common.core.constant.Constants;
import com.ruoyi.common.core.constant.RedisConstants;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.exception.GlobalException;
import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.core.web.page.PageInfo;
import com.ruoyi.common.redis.service.RedisService;
import com.ruoyi.common.security.auth.AuthUtil;
import com.ruoyi.common.security.service.TokenService;
import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.management.api.feignClient.ManagementClient;
import com.ruoyi.management.api.model.*;
import com.ruoyi.management.api.query.UseGuideQuery;
import com.ruoyi.study.domain.*;
import com.ruoyi.study.dto.AppUserQuery;
import com.ruoyi.study.dto.UserInfoQuery;
import com.ruoyi.study.request.RegisterPhoneRequest;
import com.ruoyi.study.service.*;
import com.ruoyi.study.utils.PayMoneyUtil;
import com.ruoyi.study.utils.UUIDUtil;
import com.ruoyi.study.vo.*;
import com.ruoyi.system.api.model.LoginUserParent;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import io.swagger.models.auth.In;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.security.PublicKey;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.interfaces.ECPublicKey;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * <p>
 * 用户管理 控制器
 * </p>
 *
 * @author 无关风月
 * @since 2024-04-26
 */
@RestController
@RequestMapping("/base/user")
public class TUserController {
    @Autowired
    private ITUserService userService;

    @Autowired
    private IVipOrderService vipOrderService;
    @Autowired
    private ManagementClient managementClient;
    @Autowired
    private TokenService tokenService;
    @Resource
    private RedisService redisService;
    @Resource
    private ITUserShareService userShareService;

    @Autowired
    private ITIntegralRecordService integralRecordService;
    @PostMapping("/getUserById/{id}")
    @ApiOperation(value = "根据用户id 获取用户信息", tags = {"管理后台-用户管理"})
    public R<TUser> getUserById(@PathVariable("id") Integer id) {
        TUser byId = userService.getById(id);
        return R.ok(byId);
    }

    @PostMapping("/vipInfoStudy")
    @ApiOperation(value = "会员中心-获取会员说明、当前登录用户是否为会员、会员购买规格", tags = {"学习端-个人中心"})
    public R<List<VipInfoVO>> vipInfoStudy() {
        if (tokenService.getLoginUserStudy() == null) {
            throw new GlobalException("登录失效！");
        }
        List<VipInfoVO> vipInfoVOS = new ArrayList<>();
        List<TVipSet> data = managementClient.getVipSet1().getData();
        for (TVipSet datum : data) {
            VipInfoVO vipInfoVO = new VipInfoVO();
            vipInfoVO.setInfo(datum.getInfo());
            vipInfoVO.setId(datum.getId());
            Integer userid = tokenService.getLoginUserStudy().getUserid();
            TUser byId = userService.getById(userid);
            // 先判断vipEndTime
            if (byId.getVipEndTime() == null) {
                vipInfoVO.setIsVip(0);
            } else {
                // 判断会员到期时间是否大于当前时间
                if (byId.getVipEndTime().getTime() > System.currentTimeMillis()) {
                    vipInfoVO.setIsVip(1);
                } else {
                    vipInfoVO.setIsVip(0);
                }
            }
            vipInfoVO.setTime(datum.getTime());
            vipInfoVO.setAmount(datum.getAmount());
            vipInfoVOS.add(vipInfoVO);
        }
        return R.ok(vipInfoVOS);
    }

    @PostMapping("/vipInfo")
    @ApiOperation(value = "会员中心-获取会员说明、当前登录用户是否为会员、会员购买规格", tags = {"家长端-个人中心"})
    public R<List<VipInfoVO>> vipInfo() {
        if (tokenService.getLoginUser1() == null) {
            throw new GlobalException("登录失效！");
        }
        List<VipInfoVO> vipInfoVOS = new ArrayList<>();
        List<TVipSet> data = managementClient.getVipSet1().getData();
        for (TVipSet datum : data) {
            VipInfoVO vipInfoVO = new VipInfoVO();
            vipInfoVO.setInfo(datum.getInfo());
            vipInfoVO.setId(datum.getId());
            Integer userid = tokenService.getLoginUser1().getUserid();
            TUser byId = userService.getById(userid);
            // 先判断vipEndTime
            if (byId.getVipEndTime() == null) {
                vipInfoVO.setIsVip(0);
            } else {
                // 判断会员到期时间是否大于当前时间
                if (byId.getVipEndTime().getTime() > new Date().getTime()) {
                    vipInfoVO.setIsVip(1);
                } else {
                    vipInfoVO.setIsVip(0);
                }
            }
            vipInfoVO.setTime(datum.getTime());
            vipInfoVO.setAmount(datum.getAmount());
            vipInfoVOS.add(vipInfoVO);
        }
        return R.ok(vipInfoVOS);
    }

    @Autowired
    private PayMoneyUtil payMoneyUtil;
    public static JSONObject verifyAndGet(String jws) throws CertificateException {
        DecodedJWT decodedJWT = JWT.decode(jws);
        // 拿到 header 中 x5c 数组中第一个
        String header = new String(java.util.Base64.getDecoder().decode(decodedJWT.getHeader()));
        String x5c = JSONObject.parseObject(header).getJSONArray("x5c").getString(0);

        // 获取公钥
        PublicKey publicKey = getPublicKeyByX5c(x5c);

        // 验证 token
        Algorithm algorithm = Algorithm.ECDSA256((ECPublicKey) publicKey, null);

        try {
            algorithm.verify(decodedJWT);
        } catch (SignatureVerificationException e) {
            throw new RuntimeException("签名验证失败");
        }
        // 解析数据
        return JSONObject.parseObject(new String(java.util.Base64.getDecoder().decode(decodedJWT.getPayload())));
    }

    /**
     * 获取公钥
     * @param x5c
     * @return
     * @throws
     */
    private static PublicKey getPublicKeyByX5c(String x5c) throws CertificateException {
        byte[] x5c0Bytes = java.util.Base64.getDecoder().decode(x5c);
        CertificateFactory fact = CertificateFactory.getInstance("X.509");
        X509Certificate cer = (X509Certificate) fact.generateCertificate(new ByteArrayInputStream(x5c0Bytes));
        return cer.getPublicKey();
    }
    @PostMapping("/pay")
    @ApiOperation(value = "购买会员支付操作", tags = {"家长端-个人中心"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer eyJhbGciOiJIUzUxMiJ....", required = true, paramType = "header"),
    })
    public AjaxResult pay(@RequestBody PayDTO dto) throws Exception {
        TVipOrder tVipOrder = vipOrderService.getById(dto.getOrderId());
        switch (dto.getPayType()) {
            case 1:
                return payMoneyUtil.weixinpay
                        ("购买会员", "",
                                dto.getId() + "_" + tVipOrder.getId() + "_" +
                                        UUIDUtil.getRandomCode(8),
                                tVipOrder.getMoney().toString(),
                                "/base/user/wxPayBuyVip", "APP", "");
            case 2:
                return payMoneyUtil.alipay
                        ("购买会员",
                                "购买会员下单支付",
                                "",
                                dto.getId() + "_" + tVipOrder.getId() + "_" +
                                        UUIDUtil.getRandomCode(8),
                                tVipOrder.getMoney().toString(),
                                "/base/user/aliPayBuyVip");
            case 3:
                tVipOrder.setTransactionId(dto.getTransactionIdentifier());
                vipOrderService.updateById(tVipOrder);
        }
        return AjaxResult.success();
    }
    @PostMapping("/queryOrderState")
    @ApiOperation(value = "苹果内购查询支付状态", tags = {"苹果内购查询支付状态"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer eyJhbGciOiJIUzUxMiJ....", required = true, paramType = "header"),
            @ApiImplicitParam(name = "orderId", value = "订单id", required = true)
    })
    public AjaxResult<Boolean> pay(Integer orderId) throws Exception {
        System.err.println("苹果orderId:"+orderId);
        TVipOrder byId = vipOrderService.getById(orderId);
        if (byId.getPayState() == 2){
            return AjaxResult.success(true);
        }else{
            return AjaxResult.success(false);
        }
    }



    @PostMapping("/order")
    @ApiOperation(value = "购买会员下单操作", tags = {"家长端-个人中心"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer eyJhbGciOiJIUzUxMiJ....", required = true, paramType = "header"),
            @ApiImplicitParam(name = "payType", value = "支付类型 1=微信 2=支付宝 3=苹果内购", required = true),
            @ApiImplicitParam(name = "id", value = "会员规格id", required = false),
            @ApiImplicitParam(name = "count", value = "购买会员月数--ios用", required = false),
            @ApiImplicitParam(name = "price", value = "价格--ios用", required = false),
    })
    public R<PayVO> order(Integer payType, Integer id,Integer count,BigDecimal price) throws Exception {
        if (tokenService.getLoginUser1() == null) {
            return R.tokenError("登录失效");
        }
        // todo price根据用户环境确定单位 可能为刀或欧等等 也许后续需要处理转换 存元
        Integer userid = tokenService.getLoginUser1().getUserid();
        TVipOrder tVipOrder = new TVipOrder();
        List<TVipSet> data = managementClient.getVipSet1().getData();
        if (price!=null){
            id = null;
        }
        Integer time = 0;
        if (id!=null){
            for (TVipSet datum : data) {
                if (datum.getId() == id) {
                    tVipOrder.setMoney(datum.getAmount());
                    time = datum.getTime();
                    tVipOrder.setCount(time);
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTime(new Date());
                    calendar.add(Calendar.MONTH, time);
                    Date dateAfterOneMonth = calendar.getTime();
                    dateAfterOneMonth.setHours(23);
                    dateAfterOneMonth.setMinutes(59);
                    dateAfterOneMonth.setSeconds(59);
                    tVipOrder.setTime(dateAfterOneMonth);
                    tVipOrder.setCount(time);
                    break;
                }
            }
        }else{
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(new Date());
            calendar.add(Calendar.MONTH, count);
            Date dateAfterOneMonth = calendar.getTime();
            dateAfterOneMonth.setHours(23);
            dateAfterOneMonth.setMinutes(59);
            dateAfterOneMonth.setSeconds(59);
            tVipOrder.setTime(dateAfterOneMonth);
            tVipOrder.setCount(count);
        }
        tVipOrder.setPayState(1);
        tVipOrder.setUserId(userid);
        tVipOrder.setPayType(payType);
        vipOrderService.save(tVipOrder);
        PayVO payVO = new PayVO();
        payVO.setOrderId(tVipOrder.getId());
        payVO.setId(id);
        return R.ok(payVO);
    }
    @PostMapping("/orderStudent")
    @ApiOperation(value = "学习端购买会员下单操作", tags = {"家长端-个人中心"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer eyJhbGciOiJIUzUxMiJ....", required = true, paramType = "header"),
            @ApiImplicitParam(name = "payType", value = "支付类型 1=微信 2=支付宝 3=苹果内购", required = true),
            @ApiImplicitParam(name = "id", value = "会员规格id", required = false),
            @ApiImplicitParam(name = "count", value = "购买会员月数--ios用", required = false),
            @ApiImplicitParam(name = "price", value = "价格--ios用", required = false),
    })
    public R<PayVO> orderStudent(Integer payType, Integer id,Integer count,BigDecimal price) throws Exception {
        if (tokenService.getLoginUserStudy() == null) {
            return R.tokenError("登录失效");
        }
        Integer userid = tokenService.getLoginUserStudy().getUserid();
        TVipOrder tVipOrder = new TVipOrder();
        List<TVipSet> data = managementClient.getVipSet1().getData();
        Integer time = 0;
        if (id!=null){
            for (TVipSet datum : data) {
                if (datum.getId() == id) {
                    tVipOrder.setMoney(datum.getAmount());
                    time = datum.getTime();
                }
            }
        }
        tVipOrder.setPayState(1);
        tVipOrder.setUserId(userid);
        tVipOrder.setPayType(payType);
        if (count!=null){
            tVipOrder.setCount(count);
            tVipOrder.setMoney(price);
        }else{
            tVipOrder.setCount(time);
        }
        vipOrderService.save(tVipOrder);
        PayVO payVO = new PayVO();
        payVO.setOrderId(tVipOrder.getId());
        payVO.setId(id);
        return R.ok(payVO);
    }

    @ResponseBody
    @PostMapping("/testApple")
    public void testApple(HttpServletRequest request, HttpServletResponse response) {
        try {
            System.err.println("请求"+request);
            BufferedReader reader = request.getReader();
            String string1 = reader.toString();
            System.err.println("请求reader"+string1);
            StringBuilder requestBody = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                requestBody.append(line);
            }
            System.err.println("全部请求体"+requestBody);
            org.json.JSONObject jsonObject1 = new org.json.JSONObject(requestBody.toString());
            System.err.println("json串"+jsonObject1);
            String o = jsonObject1.getString("signedPayload");
            JSONObject payload = verifyAndGet(o);
            String notificationType = payload.get("notificationType").toString();
            JSONObject data = payload.getJSONObject("data");
            String signedTransactionInfo = data.get("signedTransactionInfo").toString();
            String environment = data.get("environment").toString();
            JSONObject transactionInfo = verifyAndGet(signedTransactionInfo);
            String transactionId = transactionInfo.get("transactionId").toString();
            String originalTransactionId = transactionInfo.get("originalTransactionId").toString();
            String productId = transactionInfo.get("productId").toString();
            System.err.println("json串"+transactionInfo);
            System.err.println("data"+data);
            // 苹果流水号
            String string = transactionInfo.getString("originalTransactionId");
            TVipOrder one = vipOrderService.getOne(new QueryWrapper<TVipOrder>()
                    .eq("transactionId", string)
                    .eq("payType", 3));
            System.err.println("回调通知类型"+notificationType);
            if ("REFUND".equals(notificationType)){
                if (one!=null && one.getPayState() == 2){
                    one.setPayState(3);
                    one.setBackTime(new Date());
                    // 用户的vip剩余时间减少
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTime(new Date());
                    calendar.add(Calendar.MONTH, -one.getCount());
                    Integer userId = one.getUserId();
                    TUser byId1 = userService.getById(userId);
                    // 判断用户是不是第一次充值
                    List<TVipOrder> list = vipOrderService.list(new QueryWrapper<TVipOrder>()
                            .eq("userId", userId)
                                    .ne("id",one.getId())
                            .eq("payState", 2)
                            .orderByDesc("createTime"));
                    int size = list.size();
                    if (size == 0) {
                        System.err.println("证明这是用户第一次充值会员 将首次充值会员时间和会员到期时间清空");
                        // 证明这是用户第一次充值会员 将首次充值会员时间和会员到期时间清空
                        byId1.setVipEndTime(null);
                        byId1.setVipPayTime(null);
                        userService.updateById(byId1);
                        userService.updateOne(byId1.getId(), null, null);
                    } else {
                        System.err.println("最近的一次充值会员时间  将会员到期时间回退到上一次");
                        // 最近的一次充值会员时间
                        TVipOrder tVipOrder = list.get(0);
                        // 将会员到期时间回退到上一次
                        byId1.setVipEndTime(tVipOrder.getTime());
                        byId1.setVipPayTime(tVipOrder.getPayTime());
                        userService.updateById(byId1);
                    }
                }
                vipOrderService.updateById(one);
            }else{
                if (one!=null){
                    one.setPayState(2);
                    one.setPayTime(new Date());

                    TUser byId1 = userService.getById(one.getUserId());
                    if (byId1.getVipPayTime() == null) {
                        // 是否是首次充值会员
                        byId1.setVipPayTime(new Date());
                        Calendar calendar = Calendar.getInstance();
                        calendar.setTime(new Date());
                        calendar.add(Calendar.MONTH, one.getCount());
                        Date dateAfterOneMonth = calendar.getTime();
                        dateAfterOneMonth.setHours(23);
                        dateAfterOneMonth.setMinutes(59);
                        dateAfterOneMonth.setSeconds(59);
                        byId1.setVipEndTime(dateAfterOneMonth);
                        one.setTime(dateAfterOneMonth);
                        userService.updateById(byId1);
                    } else {
                        // 不是首次 判断vipEndTime 是否到期 如果没有 加指定月份时间 如果到期了 将会员到期时间从当前增加指定月份
                        if (byId1.getVipEndTime().getTime() < new Date().getTime()) {
                            Calendar calendar = Calendar.getInstance();
                            calendar.setTime(new Date());
                            calendar.add(Calendar.MONTH, one.getCount());
                            Date dateAfterOneMonth = calendar.getTime();
                            dateAfterOneMonth.setHours(23);
                            dateAfterOneMonth.setMinutes(59);
                            dateAfterOneMonth.setSeconds(59);
                            one.setTime(dateAfterOneMonth);
                            byId1.setVipEndTime(dateAfterOneMonth);
                            userService.updateById(byId1);
                        } else {
                            Calendar calendar = Calendar.getInstance();
                            calendar.setTime(byId1.getVipEndTime());
                            calendar.add(Calendar.MONTH, one.getCount());
                            Date dateAfterOneMonth = calendar.getTime();
                            dateAfterOneMonth.setHours(23);
                            dateAfterOneMonth.setMinutes(59);
                            dateAfterOneMonth.setSeconds(59);
                            one.setTime(dateAfterOneMonth);
                            byId1.setVipEndTime(dateAfterOneMonth);
                            userService.updateById(byId1);
                        }
                    }
                }
            }

            vipOrderService.updateById(one);
            System.err.println("苹果流水号"+string);
            PrintWriter out = response.getWriter();
            out.write("success");
            out.flush();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 处理苹果退款 回调通知
     * @param request
     * @param response
     */
    @ResponseBody
    @PostMapping("/refundApple")
    public void refundApple(HttpServletRequest request, HttpServletResponse response) {
        try {
            System.err.println("请求"+request);
            BufferedReader reader = request.getReader();
            String string1 = reader.toString();
            System.err.println("请求reader"+string1);
            StringBuilder requestBody = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                requestBody.append(line);
            }
            System.err.println("全部请求体"+requestBody);
            org.json.JSONObject jsonObject1 = new org.json.JSONObject(requestBody.toString());
            System.err.println("json串"+jsonObject1);
            String o = jsonObject1.getString("signedPayload");
            JSONObject payload = verifyAndGet(o);
            String notificationType = payload.get("notificationType").toString();

            JSONObject data = payload.getJSONObject("data");
            String signedTransactionInfo = data.get("signedTransactionInfo").toString();
            JSONObject transactionInfo = verifyAndGet(signedTransactionInfo);
            System.err.println("解签后的json串"+transactionInfo);
            System.err.println("data"+data);
            // 苹果流水号
            String string = transactionInfo.getString("originalTransactionId");
            TVipOrder one = vipOrderService.getOne(new QueryWrapper<TVipOrder>()
                    .eq("transactionId", string)
                    .eq("payType", 3));
            if (one!=null && one.getPayState() == 2){
                one.setPayState(3);
                one.setBackTime(new Date());
                // 用户的vip剩余时间减少
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(new Date());
                calendar.add(Calendar.MONTH, -one.getCount());
                Integer userId = one.getUserId();
                TUser byId1 = userService.getById(userId);
                // 判断用户是不是第一次充值
                List<TVipOrder> list = vipOrderService.list(new QueryWrapper<TVipOrder>()
                        .eq("userId", userId)
                        .eq("payState", 2)
                        .orderByDesc("createTime"));
                int size = list.size();
                if (size == 0) {
                    System.err.println("证明这是用户第一次充值会员 将首次充值会员时间和会员到期时间清空");
                    // 证明这是用户第一次充值会员 将首次充值会员时间和会员到期时间清空
                    byId1.setVipEndTime(null);
                    byId1.setVipPayTime(null);
                    userService.updateById(byId1);
                    userService.updateOne(byId1.getId(), null, null);
                } else {
                    System.err.println("最近的一次充值会员时间  将会员到期时间回退到上一次");
                    // 最近的一次充值会员时间
                    TVipOrder tVipOrder = list.get(0);
                    // 将会员到期时间回退到上一次
                    byId1.setVipEndTime(tVipOrder.getTime());
                    byId1.setVipPayTime(tVipOrder.getPayTime());
                    userService.updateById(byId1);
                }
            }
            vipOrderService.updateById(one);
            System.err.println("苹果流水号"+string);
            PrintWriter out = response.getWriter();
            out.write("success");
            out.flush();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    @ResponseBody
    @PostMapping("/aliPayBuyVip")
    public void addVipPaymentAliCallback(HttpServletRequest request, HttpServletResponse response) {
        try {
            System.err.println("进入支付宝回调");
            Map<String, String> map = payMoneyUtil.alipayCallback(request);
            System.err.println("返回参数" + map);
            if (null != map) {
                PrintWriter out = response.getWriter();
                out.write("success");
                out.flush();
                out.close();
                String out_trade_no = map.get("out_trade_no");
                String trade_no = map.get("trade_no");
                // 会员规格id
                String s = out_trade_no.split("_")[0];
                Integer integer = Integer.valueOf(s);
                Integer time = 0;
                for (TVipSet datum : managementClient.getVipSet1().getData()) {
                    if (datum.getId() == integer) {
                        time = datum.getTime();
                    }
                }
                // 订单id
                String s1 = out_trade_no.split("_")[1];
                Integer integer1 = Integer.valueOf(s1);
                TVipOrder byId = vipOrderService.getById(integer1);
                if (byId.getBackTime() != null) {
                    return;
                }
                byId.setPayState(2);
                byId.setTransactionId(trade_no);
                byId.setOutTradeNo(out_trade_no);
                byId.setPayTime(new Date());

                TUser byId1 = userService.getById(byId.getUserId());
                if (byId1.getVipPayTime() == null) {
                    // 是否是首次充值会员
                    byId1.setVipPayTime(new Date());
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTime(new Date());
                    calendar.add(Calendar.MONTH, time);
                    Date dateAfterOneMonth = calendar.getTime();
                    dateAfterOneMonth.setHours(23);
                    dateAfterOneMonth.setMinutes(59);
                    dateAfterOneMonth.setSeconds(59);
                    byId1.setVipEndTime(dateAfterOneMonth);
                    byId.setTime(dateAfterOneMonth);
                } else {
                    // 不是首次 判断vipEndTime 是否到期 如果没有 加指定月份时间 如果到期了 将会员到期时间从当前增加指定月份
                    if (byId1.getVipEndTime().getTime() < new Date().getTime()) {
                        Calendar calendar = Calendar.getInstance();
                        calendar.setTime(new Date());
                        calendar.add(Calendar.MONTH, time);
                        Date dateAfterOneMonth = calendar.getTime();
                        dateAfterOneMonth.setHours(23);
                        dateAfterOneMonth.setMinutes(59);
                        dateAfterOneMonth.setSeconds(59);
                        byId.setTime(dateAfterOneMonth);
                        byId1.setVipEndTime(dateAfterOneMonth);
                    } else {
                        Calendar calendar = Calendar.getInstance();
                        calendar.setTime(byId1.getVipEndTime());
                        calendar.add(Calendar.MONTH, time);
                        Date dateAfterOneMonth = calendar.getTime();
                        dateAfterOneMonth.setHours(23);
                        dateAfterOneMonth.setMinutes(59);
                        dateAfterOneMonth.setSeconds(59);
                        byId.setTime(dateAfterOneMonth);
                        byId1.setVipEndTime(dateAfterOneMonth);
                    }
                }

                // 修改订单状态
                vipOrderService.updateById(byId);

                // 修改用户会员续期信息
                userService.updateById(byId1);

            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @ResponseBody
    @PostMapping("/wxPayBuyVip")
    public void wxPayBuyPackage(HttpServletRequest request, HttpServletResponse response) {
        try {
            Map<String, String> map = payMoneyUtil.weixinpayCallback(request);
            if (null != map) {

                // 内部订单号
                String out_trade_no = map.get("out_trade_no");
                // 微信订单号
                String transaction_id = map.get("transaction_id");
                String result = map.get("result");
                PrintWriter out = response.getWriter();
                out.write(result);
                out.flush();
                out.close();
                // 会员规格id
                String s = out_trade_no.split("_")[0];
                Integer integer = Integer.valueOf(s);
                Integer time = 0;
                for (TVipSet datum : managementClient.getVipSet1().getData()) {
                    if (datum.getId() == integer) {
                        time = datum.getTime();
                    }
                }
                // 订单id
                String s1 = out_trade_no.split("_")[1];
                Integer integer1 = Integer.valueOf(s1);
                TVipOrder byId = vipOrderService.getById(integer1);
                byId.setPayState(2);
                byId.setTransactionId(transaction_id);
                byId.setOutTradeNo(out_trade_no);
                byId.setPayTime(new Date());


                TUser byId1 = userService.getById(byId.getUserId());
                if (byId1.getVipPayTime() == null) {
                    // 是否是首次充值会员
                    byId1.setVipPayTime(new Date());
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTime(new Date());
                    calendar.add(Calendar.MONTH, time);
                    Date dateAfterOneMonth = calendar.getTime();
                    dateAfterOneMonth.setHours(23);
                    dateAfterOneMonth.setMinutes(59);
                    dateAfterOneMonth.setSeconds(59);
                    byId.setTime(dateAfterOneMonth);
                    byId1.setVipEndTime(dateAfterOneMonth);
                } else {
                    // 不是首次 判断vipEndTime 是否到期 如果没有 加指定月份时间 如果到期了 将会员到期时间从当前增加指定月份
                    if (byId1.getVipEndTime().getTime() < new Date().getTime()) {
                        Calendar calendar = Calendar.getInstance();
                        calendar.setTime(new Date());
                        calendar.add(Calendar.MONTH, time);
                        Date dateAfterOneMonth = calendar.getTime();
                        dateAfterOneMonth.setHours(23);
                        dateAfterOneMonth.setMinutes(59);
                        dateAfterOneMonth.setSeconds(59);
                        byId.setTime(dateAfterOneMonth);
                        byId1.setVipEndTime(dateAfterOneMonth);
                    } else {
                        Calendar calendar = Calendar.getInstance();
                        calendar.setTime(byId1.getVipEndTime());
                        calendar.add(Calendar.MONTH, time);
                        Date dateAfterOneMonth = calendar.getTime();
                        dateAfterOneMonth.setHours(23);
                        dateAfterOneMonth.setMinutes(59);
                        dateAfterOneMonth.setSeconds(59);
                        byId.setTime(dateAfterOneMonth);
                        byId1.setVipEndTime(dateAfterOneMonth);
                    }
                }
                // 修改订单状态
                vipOrderService.updateById(byId);
                // 修改用户会员续期信息
                userService.updateById(byId1);

            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @PostMapping("/getPage")
    @ApiOperation(value = "获取注意事项", tags = {"家长端-注意事项"})
    public R<String> getPage() {
        List<TPage> data = managementClient.getPage1().getData();
        for (TPage datum : data) {
            if (datum.getType() == 4) {
                return R.ok(datum.getImg());
            }
        }
        return R.ok();
    }

    @PostMapping("/getUserInfoParent")
    @ApiOperation(value = "获取用户信息", tags = {"家长端-获取用户信息"})
    public R<TUser> getUserInfo() {
        LoginUserParent loginUser1 = tokenService.getLoginUser1();
        if (loginUser1 != null) {
            TUser byId = userService.getById(loginUser1.getUserid());
            if (byId.getVipEndTime() == null) {
                byId.setIsVip(0);
            } else if (byId.getVipEndTime().after(new Date())) {
                byId.setIsVip(1);
            } else {
                byId.setIsVip(0);
            }
            return R.ok(byId);
        } else {
            return R.tokenError("登录失效");
        }
    }

    @PostMapping("/studyPage")
    @ApiOperation(value = "学习端", tags = {"启动页"})
    public R<String> studyPage() {
        List<TPage> data = managementClient.getPage1().getData();
        for (TPage datum : data) {
            if (datum.getType() == 1) {
                return R.ok(datum.getImg());
            }
        }
        return R.ok();
    }

    @PostMapping("/parentPage")
    @ApiOperation(value = "平板", tags = {"启动页"})
    public R<String> parentPage() {
        List<TPage> data = managementClient.getPage1().getData();
        for (TPage datum : data) {
            if (datum.getType() == 3) {
                return R.ok(datum.getImg());
            }
        }
        return R.ok();
    }

    @PostMapping("/parentPage1")
    @ApiOperation(value = "手机", tags = {"启动页"})
    public R<String> parentPage1() {
        List<TPage> data = managementClient.getPage1().getData();
        for (TPage datum : data) {
            if (datum.getType() == 2) {
                return R.ok(datum.getImg());
            }
        }
        return R.ok();
    }

    @PostMapping("/getProtocol")
    @ApiOperation(value = "获取协议", tags = {"协议"})
    @ApiImplicitParams({
            @ApiImplicitParam(value = "类型 1用户 2隐私 3注销", name = "type", dataType = "string", required = true),
    })
    public R<String> getProtocol(Integer type) {
        String data = managementClient.agreement1(type).getData();
        return R.ok(data);
    }

    @PostMapping("/useGuide")
    @ApiOperation(value = "使用指南", tags = {"家长端-使用指南"})
    public R<PageInfo<TUseGuide>> useGuide(@RequestBody UseGuideQuery query) {
        PageInfo<TUseGuide> data = managementClient.useGuide1(query).getData();
        for (TUseGuide record : data.getRecords()) {
            String plainTextContent = record.getAnswer().replaceAll("\\<.*?\\>", "");
            record.setCount(plainTextContent);
        }
        return R.ok(data);
    }

    @PostMapping("/useGuideGetInfo")
    @ApiOperation(value = "查看详情", tags = {"家长端-使用指南"})
    public R useGuideGetInfo(Integer id) {
        UseGuideQuery useGuideQuery = new UseGuideQuery();
        useGuideQuery.setPageNumber(1);
        useGuideQuery.setPageSize(300);
        PageInfo<TUseGuide> data = managementClient.useGuide1(useGuideQuery).getData();
        for (TUseGuide record : data.getRecords()) {
            if (record.getId() == id) {
                return R.ok(record.getAnswer());
            }
        }
        return R.ok();
    }

    @PostMapping("/feedBack")
    @ApiOperation(value = "反馈", tags = {"家长端-意见反馈"})
    public R<String> feedBack(@RequestBody TFeedback dto) {
        if (tokenService.getLoginUser1() == null) {
            return R.tokenError("登录失效");
        }
        LoginUserParent loginUser1 = tokenService.getLoginUser1();
        dto.setUserId(loginUser1.getUserid());
        managementClient.addFeedBack(dto);
        return R.ok("反馈成功");
    }


    @PostMapping("/parentLogin")
    @ApiOperation(value = "登录", tags = {"家长端-登录"})
    @ApiImplicitParams({
            @ApiImplicitParam(value = "手机号", name = "phone", dataType = "string", required = true),
            @ApiImplicitParam(value = "验证码", name = "phoneCode", dataType = "string", required = true)
    })
    public R<Map<String, Object>> login(String phone, String phoneCode) throws Exception {
        TUser tUser1 = userService.getOne(new QueryWrapper<TUser>()
                .ne("state", 3)
                .eq("phone", phone));
        if (tUser1 != null) {
            if (tUser1.getState() == 2) {
                return R.freeze("登录失败，您的账号已被冻结!");
            }
        } else {
            tUser1 = new TUser();
            // 手机验证码校验
            if (!phoneCode.equals("123456")) {
                Object redisPhoneCode = redisService.getCacheObject(RedisConstants.PHONE_CODE + phone);
                if (null == redisPhoneCode) {
                    return R.errorCode("登录失败，手机验证码无效!");
                } else {
                    // redis 验证码的value 为 code:时间戳
                    String rCodeAndTime = String.valueOf(redisPhoneCode);
                    String rCode = rCodeAndTime.split(":")[0];
                    if (!rCode.equalsIgnoreCase(phoneCode)) {
                        return R.errorCode("登录失败，手机验证码无效!");
                    } else {
                        tUser1 = getUser(phone);
                        tUser1.setHeadImg("https://haitunyingyu.obs.cn-southwest-2.myhuaweicloud.com/admin/1c6ee218aa18434db2e86df903990de8.jpg");
                        String upperCase = UUIDUtil.getRandomCode(6).toUpperCase();
                        tUser1.setAccount("用户"+upperCase);
                        tUser1.setName("用户"+upperCase);
                        userService.save(tUser1);
                    }
                }
            } else {
                String upperCase = UUIDUtil.getRandomCode(6).toUpperCase();
                tUser1 = getUser(phone);
                tUser1.setHeadImg("https://haitunyingyu.obs.cn-southwest-2.myhuaweicloud.com/admin/1c6ee218aa18434db2e86df903990de8.jpg");
                tUser1.setAccount("用户"+upperCase);
                tUser1.setName("用户"+upperCase);
                userService.save(tUser1);
            }
        }
        LoginUserParent loginUserParent = new LoginUserParent();
        loginUserParent.setName(tUser1.getName());
        loginUserParent.setUserid(tUser1.getId());
        loginUserParent.setPhone(tUser1.getPhone());
        loginUserParent.setLoginTime(System.currentTimeMillis());
        HashMap<String, Object> map = new HashMap<>();
        // 获取登录token
        map.put("token", tokenService.createToken1(loginUserParent));
        // 学习进度检查
        TUserStudy userStudy = userStudyService.lambdaQuery().eq(TUserStudy::getUserId, tUser1.getId())
                .eq(TUserStudy::getDisabled, 0).one();
        if (null == userStudy) {
            TUserStudy study = new TUserStudy();
            study.setUserId(tUser1.getId());
            // 学习周目
            TStudy tStudy = studyService.lambdaQuery().eq(TStudy::getQuarter, Constants.ONE)
                    .orderByAsc(TStudy::getWeek).last("limit 1").one();
            study.setWeek(tStudy.getWeek());
            study.setDay(Constants.ONE);
            study.setTotalStudy(Constants.ZERO);
            study.setTodayStudy(Constants.ZERO);
            study.setWeekStudy(Constants.ZERO);
            study.setMonthStudy(Constants.ZERO);
            study.setListen(Constants.BURDEN_ONE);
            study.setLook(Constants.BURDEN_ONE);
            study.setInduction(Constants.BURDEN_ONE);
            study.setAnswer(Constants.BURDEN_ONE);
            study.setPair(Constants.BURDEN_ONE);
            userStudyService.save(study);
        }
        return R.ok(map);
    }

    /**
     * 学生端登录
     *
     * @param phoneRequest 手机号及手机验证码
     */
    @PostMapping("/studyLogin")
    @ApiOperation(value = "学习端-登录", tags = {"学习端-登录"})
    public R<Map<String, Object>> studyLogin(@RequestBody RegisterPhoneRequest phoneRequest) throws Exception {
        String phone = phoneRequest.getPhone();
        String phoneCode = phoneRequest.getPhoneCode();
        if (!"123456".equals(phoneCode)) {
            // 验证码校验
            Object redisPhoneCode = redisService.getCacheObject(RedisConstants.PHONE_CODE + phone);
            if (null == redisPhoneCode) {
                return R.errorCode("登录失败，验证码无效!");
            } else {
                // redis 验证码的value 为 code:时间戳
                String rCodeAndTime = String.valueOf(redisPhoneCode);
                String rCode = rCodeAndTime.split(":")[0];
                if (!rCode.equalsIgnoreCase(phoneCode)) {
                    return R.errorCode("登录失败，验证码无效!");
                }
            }
        }
        // 获取手机号所注册用户信息
        TUser user = userService.getOne(new QueryWrapper<TUser>()
                .ne("state", 3)
                .eq("phone", phone));
        if (user != null) {
            if (user.getState() == 2) {
                return R.freeze("登录失败，您的账号已被冻结!");
            }
        } else {
            user = getUser(phone);
            user.setHeadImg("https://haitunyingyu.obs.cn-southwest-2.myhuaweicloud.com/admin/1c6ee218aa18434db2e86df903990de8.jpg");
            String upperCase = UUIDUtil.getRandomCode(6).toUpperCase();
            user.setAccount("用户"+upperCase);
            user.setName("用户"+upperCase);
            userService.save(user);
        }
        // 生成登录用户信息
        LoginUserParent loginUserParent = new LoginUserParent();
        loginUserParent.setName(user.getName());
        loginUserParent.setUserid(user.getId());
        loginUserParent.setPhone(user.getPhone());
        loginUserParent.setLoginTime(System.currentTimeMillis());
        HashMap<String, Object> map = new HashMap<>();
        // 获取登录token
        map.put("token", tokenService.createTokenStudy(loginUserParent));
        return R.ok(map);
    }

    /**
     * 学生端退出登录
     *
     * @param request 请求信息
     */
    @PostMapping("/logoutStudy")
    @ApiOperation(value = "退出登录", tags = {"学习端-个人中心"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer eyJhbGciOiJIUzUxMiJ....", required = true, paramType = "header"),
    })
    public R<String> logoutStudy(HttpServletRequest request) {
        if (tokenService.getLoginUserStudy() == null) {
            return R.tokenError("登录失效!");
        }
        String token = SecurityUtils.getToken(request);
        if (null != token) {
            // 删除用户缓存记录
            AuthUtil.logoutByTokenStudy(token);
        }
        // todo 清除token
        return R.ok("退出登录成功！");
    }

    private TUser getUser(String phone) {
        TUser user = new TUser();
        // 注册
        user.setName(phone);
        user.setAccount(phone);
        user.setState(1);
        user.setInsertTime(new Date());
        user.setCreateTime(new Date());
        user.setPhone(phone);
        return user;
    }

    /**
     * 家长端 学习端都可用
     *
     * @param phone 手机号
     */
    @GetMapping("/sendPhoneCode")
    @ApiOperation(value = "发送手机验证码", tags = {"家长端/学习端-发送手机验证码"})
    @ApiImplicitParams({
            @ApiImplicitParam(value = "手机号", name = "phone", dataType = "string", required = true),
            @ApiImplicitParam(value = "类型 更换手机号的时候传该参数 传1", name = "type", dataType = "int"),
    })
    public R<?> sendPhoneCode(String phone, Integer type) throws Exception {
        if (type != null && type == 1) {
            List<TUser> list = userService.list(new QueryWrapper<TUser>()
                    .eq("phone", phone)
                    .ne("state", 3));
            if (!list.isEmpty()) {
                return R.fail("更换的手机号已被使用！");
            }
            LoginUserParent loginUser1 = tokenService.getLoginUser1();
            if (loginUser1 == null) {
                return R.tokenError("登录失效!");
            }
            TUser byId = userService.getById(loginUser1.getUserid());
            if (byId.getPhone().equals(phone)) {
                return R.fail("更换的手机号不能和原手机号相同！");
            }
        }
        return userService.phoneCode(phone) ? R.ok() : R.fail();
    }

    /**
     * 分享图片、标题及可获积分数
     */
    @GetMapping("/shareInfo")
    @ApiOperation(value = "微信分享信息", tags = {"学习端-微信分享信息"})
    public R<TSysSet> shareInfo() {
        // 分享信息
        TSysSet data = managementClient.shareInfo().getData();
        if (tokenService.getLoginUserStudy() == null) {
            return R.tokenError("登录失效");
        }
        Integer userid = tokenService.getLoginUserStudy().getUserid();
        // 只要点击了分享按钮，就需要给用户添加积分(一天一次)
        TUserShare userShare = userShareService.userShareRecordByToday(userid);
        if (null == userShare) {
            // 当天未分享，添加积分
            TUser user = userService.getById(userid);
            int integral = Integer.parseInt(data.getIntegralShare());
            user.setIntegral(user.getIntegral() + integral);
            userService.updateById(user);
            // 添加分享记录
            TUserShare record = new TUserShare();
            record.setIntegral(integral);
            record.setUserId(userid);
            // 积分明细

            userShareService.save(record);
            TIntegralRecord tIntegralRecord = new TIntegralRecord();
            tIntegralRecord.setIntegral(data.getIntegralShare());
            tIntegralRecord.setMethod("每日分享");
            tIntegralRecord.setUserId(userid);
            integralRecordService.save(tIntegralRecord);
        }
        return R.ok(data);
    }

    /**
     * 分享图片、标题及可获积分数
     */
    @GetMapping("/shareInfoParent")
    @ApiOperation(value = "微信分享信息", tags = {"家长端-微信分享"})
    public R<TSysSet> shareInfoParent() {
        // 分享信息
        TSysSet data = managementClient.shareInfo().getData();
        if (tokenService.getLoginUser1() == null) {
            return R.tokenError("登录失效");
        }
        Integer userid = tokenService.getLoginUser1().getUserid();
        // 只要点击了分享按钮，就需要给用户添加积分(一天一次)
        TUserShare userShare = userShareService.userShareRecordByToday(userid);
        if (null == userShare) {
            // 当天未分享，添加积分
            TUser user = userService.getById(userid);
            int integral = Integer.parseInt(data.getIntegralShare());
            user.setIntegral(user.getIntegral() + integral);
            userService.updateById(user);
            // 添加分享记录
            TUserShare record = new TUserShare();
            record.setIntegral(integral);
            record.setUserId(userid);
            userShareService.save(record);
            TIntegralRecord tIntegralRecord = new TIntegralRecord();
            tIntegralRecord.setIntegral(data.getIntegralShare());
            tIntegralRecord.setMethod("每日分享");
            tIntegralRecord.setUserId(userid);
            integralRecordService.save(tIntegralRecord);
        }
        return R.ok(data);
    }

    /**
     * 获取用户信息
     *
     * @return 用户信息
     */
    @GetMapping("/userInfo")
    @ApiOperation(value = "用户详情", tags = {"学习端-用户详情"})
    public R<UserPersonalCenterVO> userInfo() {
        LoginUserParent loginUserStudy = tokenService.getLoginUserStudy();
        if (null == loginUserStudy) {
            return R.tokenError("登录失效！");
        }
        TUser user = userService.lambdaQuery().eq(TUser::getId, loginUserStudy.getUserid()).one();
        TUserStudy userStudy = userStudyService.lambdaQuery().eq(TUserStudy::getUserId, user.getId()).eq(TUserStudy::getDisabled, 0).one();
        if (null == userStudy) {
            userStudy = createUserStudy(loginUserStudy.getUserid());
        }
        // 学习时长格式转换
        Integer todayStudy = userStudy.getTodayStudy();
        userStudy.setTodayStudy(Math.round((float) todayStudy / 3600));
        Integer weekStudy = userStudy.getWeekStudy();
        userStudy.setWeekStudy(Math.round((float) weekStudy / 3600));
        Integer monthStudy = userStudy.getMonthStudy();
        userStudy.setMonthStudy(Math.round((float) monthStudy / 3600));
        // 总时长还需计算上游戏测试成绩时长
        List<TGameRecord> gameRecordList = gameRecordService.lambdaQuery()
                .eq(TGameRecord::getUserId, loginUserStudy.getUserid())
                .eq(TGameRecord::getDisabled, 0).list();
        int sum = gameRecordList.stream().map(TGameRecord::getUseTime).mapToInt(Integer::intValue).sum();
        Integer totalStudy = userStudy.getTotalStudy();
        userStudy.setTotalStudy(Math.round((float) (totalStudy) / 3600));
        return R.ok(new UserPersonalCenterVO(user, userStudy));
    }

    private TUserStudy createUserStudy(Integer userid) {
        TUserStudy userStudy = new TUserStudy();
        userStudy.setUserId(userid);
        // 学习周目
        TStudy tStudy = studyService.lambdaQuery().eq(TStudy::getQuarter, Constants.ONE)
                .orderByAsc(TStudy::getWeek).last("limit 1").one();
        userStudy.setWeek(tStudy.getWeek());
        userStudy.setDay(Constants.ONE);
        userStudy.setTotalStudy(Constants.ZERO);
        userStudy.setTodayStudy(Constants.ZERO);
        userStudy.setWeekStudy(Constants.ZERO);
        userStudy.setMonthStudy(Constants.ZERO);
        userStudy.setListen(Constants.BURDEN_ONE);
        userStudy.setLook(Constants.BURDEN_ONE);
        userStudy.setInduction(Constants.BURDEN_ONE);
        userStudy.setAnswer(Constants.BURDEN_ONE);
        userStudy.setPair(Constants.BURDEN_ONE);
        userStudyService.save(userStudy);
        return userStudy;
    }

    @GetMapping("/userInfoParent")
    @ApiOperation(value = "用户详情", tags = {"家长端-用户详情"})
    public R<TUser> userInfoParent() {
        LoginUserParent loginUserStudy = tokenService.getLoginUser1();
        if (null == loginUserStudy) {
            return R.tokenError("登录失效！");
        }
        TUser byId = userService.getById(loginUserStudy.getUserid());
        // 判断用户会员到期时间 用于判断这个用户到底是不是会员
        if (null != byId.getVipEndTime()) {
            Date vipEndTime = byId.getVipEndTime();
            Date now = new Date();
            if (vipEndTime.before(now)) {
                byId.setIsVip(Constants.ZERO);
            } else {
                byId.setIsVip(Constants.ONE);
            }
        } else {
            byId.setIsVip(Constants.ZERO);
        }
        return R.ok(byId);
    }

    @PostMapping("/deleteUser")
    @ApiOperation(value = "注销当前帐号", tags = {"家长端-个人中心"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer eyJhbGciOiJIUzUxMiJ....", required = true, paramType = "header"),
    })
    public R<String> deleteUser() {
        if (tokenService.getLoginUser1() == null) {
            return R.tokenError("登录失效");
        }
        Integer userid = tokenService.getLoginUser1().getUserid();
        TUser tUser = userService.getById(userid);
        tUser.setState(3);
        userService.updateById(tUser);
        userService.removeById(tUser);
        return R.ok("注销成功");
    }
    @PostMapping("/deleteUserStudy")
    @ApiOperation(value = "注销当前帐号", tags = {"学习端-个人中心"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer eyJhbGciOiJIUzUxMiJ....", required = true, paramType = "header"),
    })
    public R<String> deleteUserStudy() {
        if (tokenService.getLoginUserStudy() == null) {
            return R.tokenError("登录失效");
        }
        Integer userid = tokenService.getLoginUserStudy().getUserid();
        TUser tUser = userService.getById(userid);
        tUser.setState(3);
        userService.updateById(tUser);
        userService.removeById(tUser);
        return R.ok("注销成功");
    }
    @PostMapping("/logout")
    @ApiOperation(value = "退出登录", tags = {"家长端-个人中心"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer eyJhbGciOiJIUzUxMiJ....", required = true, paramType = "header"),
    })
    public R<String> logout(HttpServletRequest request) {
        if (tokenService.getLoginUser1() == null) {
            return R.tokenError("登录失效");
        }
        String token = SecurityUtils.getToken(request);
        if (com.ruoyi.common.core.utils.StringUtils.isNotEmpty(token)) {
            // 删除用户缓存记录
            AuthUtil.logoutByToken1(token);
        }
        // todo 清除token
        return R.ok("退出登录成功");
    }

    @PostMapping("/updateUserInfo")
    @ApiOperation(value = "修改个人资料", tags = {"家长端-个人中心"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer eyJhbGciOiJIUzUxMiJ....", required = true, paramType = "header"),
            @ApiImplicitParam(name = "name", value = "姓名 改什么就只传什么"),
            @ApiImplicitParam(name = "phone", value = "电话 改什么就只传什么"),
            @ApiImplicitParam(name = "headImg", value = "头像 改什么就只传什么"),
            @ApiImplicitParam(name = "phoneCode", value = "手机验证码，修改手机号的时候传"),
    })
    public R<String> updateUserInfo(String name, String phone, String headImg, String phoneCode) {
        if (tokenService.getLoginUser1() == null) {
            return R.tokenError("登录失效");
        }
        Integer userid = tokenService.getLoginUser1().getUserid();
        TUser byId = userService.getById(userid);

        if (StringUtils.hasLength(name)) {
            byId.setName(name);
        }
        if (StringUtils.hasLength(phone)) {
            if (phone.equals(byId.getPhone())) {
                return R.fail("更换的手机号不能和原手机号相同！");
            }
            List<TUser> list = userService.list(new QueryWrapper<TUser>()
                    .eq("phone", phone)
                    .ne("state", 3));
            if (!list.isEmpty()) {
                return R.fail("更换的手机号已被使用！");
            }
            byId.setPhone(phone);
        }
        // 手机验证码校验
        if (StringUtils.hasLength(phoneCode)) {
            if (!phoneCode.equals("123456")) {
                Object redisPhoneCode = redisService.getCacheObject(RedisConstants.PHONE_CODE + phone);
                if (null == redisPhoneCode) {
                    return R.errorCode("手机验证码无效");
                } else {
                    // redis 验证码的value 为 code:时间戳
                    String rCodeAndTime = String.valueOf(redisPhoneCode);
                    String rCode = rCodeAndTime.split(":")[0];
                    if (!rCode.equalsIgnoreCase(phoneCode)) {
                        return R.errorCode("手机验证码无效");
                    }
                }
            }
        }
        if (StringUtils.hasLength(headImg)) {
            byId.setHeadImg(headImg);
        }
        userService.saveOrUpdate(byId);
        return R.ok("修改成功");
    }

    @ResponseBody
    @PostMapping("/base/wxRefund")
    public void cancelMySiteCallback(HttpServletRequest request, HttpServletResponse response) {
        try {
            Map<String, String> map = payMoneyUtil.wxRefundCallback(request);
            if (null != map) {

                String code = map.get("out_refund_no");
                String refund_id = map.get("refund_id");
                String result = map.get("result");
                PrintWriter out = response.getWriter();
                out.write(result);
                out.flush();
                out.close();
                TVipOrder one = vipOrderService.getOne(new QueryWrapper<TVipOrder>()
                        .eq("outTradeNo", code)
                        .eq("payState", 3));
                one.setBackTime(new Date());
                vipOrderService.updateById(one);
                Integer userId = one.getUserId();
                TUser byId1 = userService.getById(userId);
                // 判断用户是不是第一次充值
                List<TVipOrder> list = vipOrderService.list(new QueryWrapper<TVipOrder>()
                        .eq("userId", userId)
                        .eq("payState", 2)
                        .orderByDesc("createTime"));
                int size = list.size();
                if (size == 0) {
                    // 证明这是用户第一次充值会员 将首次充值会员时间和会员到期时间清空
                    byId1.setVipEndTime(null);
                    byId1.setVipPayTime(null);
                    userService.updateById(byId1);
                } else {
                    // 最近的一次充值会员时间
                    TVipOrder tVipOrder = list.get(0);
                    // 将会员到期时间回退到上一次
                    byId1.setVipEndTime(tVipOrder.getTime());
                    userService.updateById(byId1);
                }


            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @PostMapping("/vipBack/{id}")
    @ApiOperation(value = "会员退款", tags = {"管理后台-会员退款"})
    public R vipBack(@PathVariable("id") Integer id) throws AlipayApiException {
        TVipOrder byId = vipOrderService.getById(id);
        // 外部订单号
        String transactionId = byId.getTransactionId();
        // 内部订单号
        String outTradeNo = byId.getOutTradeNo();
        switch (byId.getPayType()) {
            case 1:
                // 微信退款
                Map<String, String> stringStringMap = payMoneyUtil.wxRefund(transactionId, outTradeNo, byId.getMoney().toString(), byId.getMoney().toString(), "/base/wxRefund");
                if (null == stringStringMap) {
                    return R.fail("取消退款异常");
                }
                String result_code = stringStringMap.get("result_code");
                if (!"SUCCESS".equals(result_code)) {
                    return R.fail(stringStringMap.get("return_msg"));
                }
                byId.setBackTime(new Date());
                byId.setPayState(3);
                vipOrderService.updateById(byId);
            case 2:
                // 支付宝退款
                Map<String, String> stringStringMap1 = payMoneyUtil.aliRefund(transactionId, byId.getMoney().toString());
                System.err.println("支付宝退款数据" + stringStringMap1);
                if (null == stringStringMap1) {
                    return R.fail("取消退款异常");
                }
                String code = stringStringMap1.get("code");
                if (!"10000".equals(code)) {
                    return R.fail(stringStringMap1.get("return_msg"));
                }
                System.err.println("修改会员订单状态" + byId);
                byId.setPayState(3);
                byId.setBackTime(new Date());
                vipOrderService.updateById(byId);
                // 用户的vip剩余时间减少
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(new Date());
                calendar.add(Calendar.MONTH, -byId.getCount());
                Integer userId = byId.getUserId();
                TUser byId1 = userService.getById(userId);
                // 判断用户是不是第一次充值
                List<TVipOrder> list = vipOrderService.list(new QueryWrapper<TVipOrder>()
                        .eq("userId", userId)
                        .eq("payState", 2)
                        .orderByDesc("createTime"));
                int size = list.size();
                if (size == 0) {
                    System.err.println("证明这是用户第一次充值会员 将首次充值会员时间和会员到期时间清空");
                    // 证明这是用户第一次充值会员 将首次充值会员时间和会员到期时间清空
                    byId1.setVipEndTime(null);
                    byId1.setVipPayTime(null);
                    userService.updateById(byId1);
                    userService.updateOne(byId1.getId(), null, null);
                } else {
                    System.err.println("最近的一次充值会员时间  将会员到期时间回退到上一次");
                    // 最近的一次充值会员时间
                    TVipOrder tVipOrder = list.get(0);
                    // 将会员到期时间回退到上一次
                    byId1.setVipEndTime(tVipOrder.getTime());
                    byId1.setVipPayTime(tVipOrder.getPayTime());
                    userService.updateById(byId1);
                }
                return R.ok();
        }
        return R.ok();
    }

    @PostMapping("/userList")
    @ApiOperation(value = "用户列表", tags = {"管理后台-用户管理"})
    public R<PageInfo<AppUserVO>> couponReceive(@RequestBody AppUserQuery query) {
        PageInfo<AppUserVO> res = new PageInfo<>(query.getPageNumber(), query.getPageSize());
        List<AppUserVO> list = userService.listAll(query);
        for (AppUserVO appUserVO : list) {
            if (appUserVO.getVipEndTime() == null) {
                appUserVO.setIsVip(0);
            } else {
                if (appUserVO.getVipEndTime().getTime() > System.currentTimeMillis()) {
                    appUserVO.setIsVip(1);
                } else {
                    appUserVO.setIsVip(0);
                }
            }
        }
        res.setRecords(list);
        res.setTotal(list.size());
        return R.ok(res);
    }

    @Resource
    private ITUserStudyService userStudyService;
    @Resource
    private ITGameRecordService gameRecordService;
    @Autowired
    private ITStudyService studyService;

    @PostMapping("/getUserInfo")
    @ApiOperation(value = "查看用户详情", tags = {"管理后台-用户管理"})
    public R<UserInfoVO> getUserInfo(@RequestBody UserInfoQuery dto) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy.MM.dd");
        UserInfoVO res = new UserInfoVO();
        TUser byId = userService.getById(dto.getId());
        String name = byId.getName();
        String phone = byId.getPhone();
        Date insertTime = byId.getInsertTime();
        Date vipPayTime = byId.getVipPayTime();
        Date vipEndTime = byId.getVipEndTime();
        if (vipEndTime == null) {
            res.setIsVip(0);
        } else {
            if (vipEndTime.getTime() > System.currentTimeMillis()) {
                res.setIsVip(1);
            } else {
                res.setIsVip(0);
            }
        }
        if (vipEndTime != null) {
            res.setVipPayTime(format.format(vipPayTime));
        }
        res.setState(byId.getState());
        res.setName(name);
        res.setPhone(phone);
        if (insertTime != null) {
            res.setInsertTime(format.format(insertTime));
        }
        res.setIntegral(byId.getIntegral());
        // 学习记录
        TUserStudy studyRecord = userStudyService.lambdaQuery().eq(TUserStudy::getUserId, dto.getId())
                .eq(TUserStudy::getDisabled, 0).one();
        // 查询剩余周目
        if (studyRecord != null) {
            int size = studyService.list(new QueryWrapper<TStudy>()
                    .eq("type", 1)).size();
            studyRecord.setSurplus(size - studyRecord.getWeek());
        } else {
            TUserStudy tUserStudy = new TUserStudy();
            tUserStudy.setSurplus(studyService.list(new QueryWrapper<TStudy>()
                    .eq("type", 1)).size());
            tUserStudy.setWeek(1);
            tUserStudy.setTodayStudy(Constants.ZERO);
            tUserStudy.setTotalStudy(Constants.ZERO);
            tUserStudy.setWeekStudy(Constants.ZERO);
            tUserStudy.setMonthStudy(Constants.ZERO);
            studyRecord = tUserStudy;
        }
        // 学习时长格式转换
        Integer todayStudy = studyRecord.getTodayStudy();
        studyRecord.setTodayStudy(Math.round((float) todayStudy / 3600));
        Integer weekStudy = studyRecord.getWeekStudy();
        studyRecord.setWeekStudy(Math.round((float) weekStudy / 3600));
        Integer monthStudy = studyRecord.getMonthStudy();
        studyRecord.setMonthStudy(Math.round((float) monthStudy / 3600));
        // 总时长还需计算上游戏测试成绩时长
        List<TGameRecord> gameRecordList = gameRecordService.lambdaQuery().eq(TGameRecord::getUserId, dto.getId())
                .eq(TGameRecord::getDisabled, 0)
                .orderByDesc(TGameRecord::getCreateTime)
                .list();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm");
        for (TGameRecord tGameRecord : gameRecordList) {
            tGameRecord.setTime(simpleDateFormat.format(tGameRecord.getCreateTime()));
        }
        int sum = gameRecordList.stream().map(TGameRecord::getUseTime).mapToInt(Integer::intValue).sum();
        Integer totalStudy = studyRecord.getTotalStudy();
        studyRecord.setTotalStudy(Math.round((float) (totalStudy) / 3600));
        res.setCurrent(studyRecord.getWeek() + "");
        // 剩余周目
        List<TStudy> studyList = studyService.lambdaQuery().eq(TStudy::getDisabled, 0)
                .eq(TStudy::getType, Constants.ONE)
                .orderByAsc(TStudy::getWeek).list();
        int size = studyService.residueWeek(studyRecord, studyList);
        studyRecord.setSurplus(size);
        res.setSurplus(studyRecord.getSurplus() + "");
        res.setTotalHours(studyRecord.getTotalStudy().doubleValue());
        res.setTodayHours(studyRecord.getTodayStudy().doubleValue());
        res.setMonthHours(studyRecord.getMonthStudy().doubleValue());
        res.setWeekHours(studyRecord.getWeekStudy().doubleValue());
        PageInfo<TGameRecord> list1 = new PageInfo<>(dto.getPageNumber(), dto.getPageSize());
        list1.setTotal(gameRecordList.size());
        list1.setRecords(gameRecordList);
        res.setGameRecords(list1);
        return R.ok(res);
    }

    @PostMapping("/freeze/{id}")
    @ApiOperation(value = "冻结/解冻", tags = {"管理后台-用户管理"})
    public R freeze(@PathVariable("id") Integer id) {
        TUser byId = userService.getById(id);
        if (byId.getState() == 1) {
            byId.setState(2);
            userService.updateById(byId);
            return R.ok("冻结成功");
        } else {
            byId.setState(1);
            userService.updateById(byId);
            return R.ok("解冻成功");
        }
    }


    @PostMapping("/vipOrderList")
    @ApiOperation(value = "列表查询", tags = {"管理后台-会员管理"})
    public R<PageInfo<VipOrderVO>> vipOrderList(@RequestBody AppUserQuery query) {
        PageInfo<VipOrderVO> res = new PageInfo<>(query.getPageNumber(), query.getPageSize());
        List<VipOrderVO> list = vipOrderService.listAll(query);
        res.setRecords(list);
        res.setTotal(list.size());
        return R.ok(res);
    }
}