package com.xiaopeng.account.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.xiaopeng.account.mapper.XpPayFrontMapper;
import com.xiaopeng.account.model.dto.CollectAddrDTO;
import com.xiaopeng.account.service.IXpAppUserService;
import com.xiaopeng.api.dto.payFront.CreditPaySignDto;
import com.xiaopeng.api.dto.payFront.CreditPaySignQueryDto;
import com.xiaopeng.api.dto.payFront.UnsignCreditPayDto;
import com.xiaopeng.api.dto.statistics.StatisticsQueryDTO;
import com.xiaopeng.api.dto.statistics.UserStatisticsDTO;
import com.xiaopeng.api.feignClient.payFront.XpPayFrontClient;
import com.xiaopeng.api.model.account.XpAppUser;
import com.xiaopeng.api.model.account.XpPayFront;
import com.xiaopeng.api.vo.payFront.CreditPaySignQueryVo;
import com.xiaopeng.api.vo.payFront.CreditPaySignVo;
import com.xiaopeng.common.core.domain.R;
import com.xiaopeng.common.core.utils.OrderCodeUtil;
import com.xiaopeng.common.core.web.domain.BaseModel;
import com.xiaopeng.unifiedverification.interceptor.XpClientCheck;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 * 小程序用户 前端控制器
 * </p>
 *
 * @author mitao
 * @since 2026-02-03
 */
@Slf4j
@RestController
@Api(tags = "小程序用户")
public class XpAppUserController {

    @Resource
    private IXpAppUserService xpAppUserService;

    @Resource
    private XpPayFrontClient xpPayFrontClient;


    @Resource
    private XpPayFrontMapper xpPayFrontMapper;

    /**
     * 获取用户统计数据（内部接口）
     *
     * @param query 查询参数
     * @return 用户统计数据
     */
    @ApiOperation(value = "获取用户统计数据", tags = {"内部接口"})
    @PostMapping("/logan/inner/appUser/statistics")
    public R<UserStatisticsDTO> getUserStatistics(@RequestBody StatisticsQueryDTO query) {
        return R.ok(xpAppUserService.getUserStatistics(query));
    }

    /**
     * 根据ID列表批量查询用户信息（内部接口）
     *
     * @param ids 用户ID列表
     * @return 用户列表
     */
    @ApiOperation(value = "批量查询用户信息", tags = {"内部接口"})
    @PostMapping("/logan/inner/appUser/listByIds")
    public R<List<XpAppUser>> listByIds(@RequestBody List<Long> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return R.ok(new ArrayList<>());
        }
        return R.ok(xpAppUserService.listByIds(ids));
    }

    /**
     * 根据ID查询用户信息
     *
     * @param id 用户ID
     * @return 用户信息
     */
    @GetMapping("/logan/inner/appUser/queryOperationsUserById")
    public R<XpAppUser> queryOperationsUserById(@RequestParam Long id){
        XpAppUser xpAppUser = xpAppUserService.getById(id);
        return R.ok(xpAppUser);
    }

//-----------------------------------------------app接口------------------------------------------
    /**
     * 获取免密结果
     */
    @PostMapping("/api/v1/mini-program/appUser/getPayPwd")
    @ApiOperation(value = "个人中心-获取免密结果", tags = {"小程序-获取免密结果"})
    @XpClientCheck(checkToken = false, checkOtpToken = true)
    public R<Boolean> appUserGetPayPwd(HttpServletRequest request) {
        // uid已通过拦截器otp校验，可以直接使用
        String uid = request.getHeader("XP-Uid");
        //调用其他接口获取 免密结果
        Boolean signed = false;

        // 获取用户开通情况
        List<XpPayFront> xpPayFronts = xpPayFrontMapper.selectList(new LambdaQueryWrapper<XpPayFront>().eq(XpPayFront::getUserId, uid).orderByDesc(BaseModel::getCreateTime));
        if (xpPayFronts.isEmpty()) {
            return R.ok(signed);
        }

        CreditPaySignQueryDto creditPaySignQueryDto = new CreditPaySignQueryDto();
        creditPaySignQueryDto.setUid(Long.valueOf(uid));
        creditPaySignQueryDto.setBusinessId("xp-robotaxi");
        creditPaySignQueryDto.setCategory("009001");
        creditPaySignQueryDto.setBusinessOrderId(OrderCodeUtil.getOrderCode("MMZF"));
        R<CreditPaySignQueryVo> creditPaySignQueryVoR = xpPayFrontClient.queryCreditPaySign(creditPaySignQueryDto);
        if (creditPaySignQueryVoR.getCode()==200) {
            CreditPaySignQueryVo data = creditPaySignQueryVoR.getData();
            // 查看是否有签约的
            long count = data.getSignList().stream().filter(e -> e.getStatus().equals("VALID")).count();
            if (count > 0){
                signed = true;
            }
        }

        return R.ok(signed);
    }

    /**
     * 设置免密结果
     */
    @PostMapping("/api/v1/mini-program/appUser/setPayPwd")
    @ApiOperation(value = "个人中心-设置免密结果", tags = {"小程序-设置免密结果"})
    @XpClientCheck(checkToken = false, checkOtpToken = true)
    public R<?> appUserSetPayPwd(@RequestParam Integer status,HttpServletRequest request) {
        // uid已通过拦截器otp校验，可以直接使用
        String uid = request.getHeader("XP-Uid");
        //调用其他接口设置免密结果
        if(status==1){
            CreditPaySignDto creditPaySignDto = new CreditPaySignDto();
            creditPaySignDto.setUid(Long.valueOf(uid));
            creditPaySignDto.setBusinessId("xp-robotaxi");
            creditPaySignDto.setCategory("009001");
            creditPaySignDto.setBusinessOrderId(OrderCodeUtil.getOrderCode("MMZF"));
            creditPaySignDto.setPayType("13");
            R<CreditPaySignVo> creditPaySignVoR = xpPayFrontClient.creditPaySign(creditPaySignDto);
            if(creditPaySignVoR.getCode()==200){
                CreditPaySignVo data = creditPaySignVoR.getData();
                XpPayFront xpPayFront = new XpPayFront();
                xpPayFront.setUserId(Long.valueOf(uid));
                xpPayFront.setBusinessOrderId(creditPaySignDto.getBusinessOrderId());
                xpPayFrontMapper.insert(xpPayFront);
                return R.ok(data);
            }

        }else {
            UnsignCreditPayDto unsignCreditPayDto = new UnsignCreditPayDto();
            unsignCreditPayDto.setUid(Long.valueOf(uid));
            unsignCreditPayDto.setBusinessId("xp-robotaxi");
            unsignCreditPayDto.setCategory("009001");


            String businessOrderId= null;
            // 查询用户开通的id
            List<XpPayFront> xpPayFronts = xpPayFrontMapper.selectList(new LambdaQueryWrapper<XpPayFront>().eq(XpPayFront::getUserId, Long.valueOf(uid)).orderByDesc(BaseModel::getCreateTime));
            if(xpPayFronts.size()>0){
                businessOrderId = xpPayFronts.get(0).getBusinessOrderId();
            }
            if(businessOrderId==null){
                return R.ok();
            }
            unsignCreditPayDto.setBusinessOrderId(businessOrderId);
            unsignCreditPayDto.setPayType("13");
            R<?> unsignCreditPayVoR = xpPayFrontClient.unsign(unsignCreditPayDto);
            if(unsignCreditPayVoR.getCode()==200){
                // 移除信息
                xpPayFrontMapper.delete(new LambdaQueryWrapper<XpPayFront>().eq(XpPayFront::getUserId, Long.valueOf(uid)));
                return R.ok();
            }
        }

        return R.ok();
    }






//-----------------------------------------------app接口------------------------------------------

}