package com.ruoyi.web.controller.system;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.framework.web.service.TokenService;
import com.ruoyi.system.dto.SaveUserBankDto;
import com.ruoyi.system.dto.UserWithdrawalDto;
import com.ruoyi.system.model.*;
import com.ruoyi.system.query.UserAccountDetailQuery;
import com.ruoyi.system.service.*;
import com.ruoyi.system.vo.GetWithdrawalDetailVo;
import com.ruoyi.system.vo.RegionVo;
import com.ruoyi.system.vo.UserAccountVo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.parameters.P;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.math.BigDecimal;
import java.util.List;

@Slf4j
@RestController
@RequestMapping("/user-account")
@Api(tags = "用户钱包模块")
public class UserAccountController {
    @Autowired
    private TbUserService userService;

    @Autowired
    private TokenService tokenService;

    @Autowired
    private TbBankService bankService;

    @Autowired
    private TbAccountDetailService accountDetailService;

    @Autowired
    private TbWithdrawalService withdrawalService;



    @ApiOperation(value = "获取用户钱包信息",tags = {"用户钱包模块"})
    @GetMapping("/getUserAccount")
    public R<UserAccountVo> getUserAccount() {
        UserAccountVo userAccountVo = new UserAccountVo();
        LoginUser loginUser = tokenService.getLoginUser();
        TbUser user = userService.getById(loginUser.getUserId());
        userAccountVo.setBalance(user.getBalance());

        List<TbAccountDetail> list = accountDetailService.list(new LambdaQueryWrapper<TbAccountDetail>().eq(TbAccountDetail::getCategory, 1).eq(TbAccountDetail::getUserId, user.getId()));
        BigDecimal reduce = list.stream().filter(e->e.getStatus()==2).map(TbAccountDetail::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add);
        userAccountVo.setWithdrawalBalance(reduce);

        BigDecimal reduce1 = list.stream().filter(e->e.getStatus()==1).map(TbAccountDetail::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add);
        userAccountVo.setAuditBalance(reduce1);
        List<TbAccountDetail> list1 = accountDetailService.list(new LambdaQueryWrapper<TbAccountDetail>().eq(TbAccountDetail::getCategory, 2).eq(TbAccountDetail::getStatus, 1).eq(TbAccountDetail::getUserId, user.getId()));
        BigDecimal reduce2 = list1.stream().map(TbAccountDetail::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add);
        userAccountVo.setEntryBalance(reduce2);

        return R.ok(userAccountVo);
    }





    @ApiOperation(value = "获取用户钱包信息-收支明细",tags = {"用户钱包模块"})
    @GetMapping("/getUserAccountDetail")
    public R<Page<TbAccountDetail>> getUserAccountDetail(UserAccountDetailQuery query) {
        LoginUser loginUser = tokenService.getLoginUser();
        LambdaQueryWrapper<TbAccountDetail> wrapper = new LambdaQueryWrapper<>();
        if(StringUtils.isNotEmpty(query.getTime())){
            wrapper.likeRight(TbAccountDetail::getCreateTime,query.getTime());
        }
        wrapper.eq(TbAccountDetail::getUserId,loginUser.getUserId());
        wrapper.orderByDesc(TbAccountDetail::getCreateTime);
        Page<TbAccountDetail> page = accountDetailService.page(new Page<>(query.getPageNum(),query.getPageSize()),wrapper);
        return R.ok(page);
    }


    @ApiOperation(value = "申请提现",tags = {"用户钱包模块"})
    @PostMapping("/withdrawal")
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public R<?> withdrawal(@RequestBody @Valid UserWithdrawalDto dto) {
        if(dto.getAmount()<=0){
            return R.fail("提现金额不能小于0");
        }
        LoginUser loginUser = tokenService.getLoginUser();
        TbUser user = userService.getById(loginUser.getUserId());
        // 判断是否有卡
        List<TbBank> list = bankService.list(new LambdaQueryWrapper<TbBank>().eq(TbBank::getUserId, loginUser.getUserId()).eq(TbBank::getIsDelete, 0));
        if(list.isEmpty()){
            return R.fail("请先绑定银行卡");
        }
        if(user.getBalance().doubleValue()<dto.getAmount()){
            return R.fail("余额不足");
        }
        TbBank tbBank = list.get(0);
        TbWithdrawal withdrawal = new TbWithdrawal();
        withdrawal.setUserId(loginUser.getUserId().toString());
        withdrawal.setMoney(new BigDecimal(dto.getAmount()));
        withdrawal.setCardNo(tbBank.getCardNo());
        withdrawal.setUsername(tbBank.getUsername());
        withdrawal.setStatus(0);
        user.setBalance(user.getBalance().subtract(new BigDecimal(dto.getAmount())));
        userService.updateById(user);
        withdrawalService.save(withdrawal);

        // 存储记录
        TbAccountDetail accountDetail = new TbAccountDetail();
        accountDetail.setUserId(loginUser.getUserId().toString());
        accountDetail.setType(2);
        accountDetail.setCategory(1);
        accountDetail.setStatus(1);
        accountDetail.setMoney(new BigDecimal(dto.getAmount()));
        accountDetail.setSourceId(withdrawal.getId());
        accountDetailService.save(accountDetail);
        return R.ok();
    }



    @ApiOperation(value = "获取用户绑定的卡",tags = {"用户钱包模块"})
    @GetMapping("/getUserBank")
    public R<TbBank> getUserBank() {
        LoginUser loginUser = tokenService.getLoginUser();
        TbBank tbBank = bankService.getOne(new LambdaQueryWrapper<TbBank>().eq(TbBank::getUserId, loginUser.getUserId()).eq(TbBank::getIsDelete, 0));
        return R.ok(tbBank);
    }


    @ApiOperation(value = "保存银行卡",tags = {"用户钱包模块"})
    @PostMapping("/saveUserBank")
    public R<?> getUserBank(@Valid @RequestBody SaveUserBankDto dto) {
        LoginUser loginUser = tokenService.getLoginUser();
        TbBank tbBank = bankService.getOne(new LambdaQueryWrapper<TbBank>().eq(TbBank::getUserId, loginUser.getUserId()).eq(TbBank::getIsDelete, 0));
        if(tbBank==null){
            tbBank = new TbBank();
            tbBank.setUserId(loginUser.getUserId().toString());
            tbBank.setCardNo(dto.getCardNo());
            tbBank.setUsername(dto.getUsername());
            tbBank.setIsDelete(0);
            bankService.save(tbBank);
        }else {
            tbBank.setCardNo(dto.getCardNo());
            tbBank.setUsername(dto.getUsername());
            bankService.updateById(tbBank);
        }
        return R.ok();
    }


    @ApiOperation(value = "提现说明需求",tags = {"用户钱包模块"})
    @GetMapping("/getWithdrawalDetail")
    public R<GetWithdrawalDetailVo> getWithdrawalDetail(@RequestParam String sourceId) {
        TbWithdrawal withdrawal =  withdrawalService.getById(sourceId);
        GetWithdrawalDetailVo vo = new GetWithdrawalDetailVo();
        vo.setImg(withdrawal.getImg());
        vo.setRemark(withdrawal.getRemark());
        return R.ok(vo);
    }






}