package com.doumee.service.business.impl;

import com.doumee.biz.system.SystemDictDataBiz;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.DateUtil;
import com.doumee.core.utils.RedisUtil;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.*;
import com.doumee.dao.business.model.*;
import com.doumee.dao.web.dto.MultiFileDTO;
import com.doumee.dao.web.request.DealIntegralRequest;
import com.doumee.dao.web.request.WithdrawApplyRequest;
import com.doumee.service.business.IntegralService;
import com.doumee.service.business.WithdrawRecordService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.commons.lang3.StringUtils;
import org.bouncycastle.cert.dane.DANEEntry;
import org.checkerframework.checker.units.qual.A;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Objects;

/**
 * 用户提现记录Service实现
 * @author 江蹄蹄
 * @date 2026/01/16 11:50
 */
@Service
public class WithdrawRecordServiceImpl implements WithdrawRecordService {

    @Autowired
    private WithdrawRecordMapper withdrawRecordMapper;

    @Autowired
    private ShopMapper shopMapper;

    @Autowired
    private IntegralMapper integralMapper;

    @Autowired
    private MemberBankMapper memberBankMapper;

    @Autowired
    private SystemDictDataBiz systemDictDataBiz;

    @Autowired
    private MultifileMapper multifileMapper;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Override
    public Integer create(WithdrawRecord withdrawRecord) {
        withdrawRecordMapper.insert(withdrawRecord);
        return withdrawRecord.getId();
    }

    @Override
    public void deleteById(Integer id) {
        withdrawRecordMapper.deleteById(id);
    }

    @Override
    public void delete(WithdrawRecord withdrawRecord) {
        UpdateWrapper<WithdrawRecord> deleteWrapper = new UpdateWrapper<>(withdrawRecord);
        withdrawRecordMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        withdrawRecordMapper.deleteBatchIds(ids);
    }

    @Override
    public void updateById(WithdrawRecord withdrawRecord) {
        withdrawRecordMapper.updateById(withdrawRecord);
    }

    @Override
    public void updateByIdInBatch(List<WithdrawRecord> withdrawRecords) {
        if (CollectionUtils.isEmpty(withdrawRecords)) {
            return;
        }
        for (WithdrawRecord withdrawRecord: withdrawRecords) {
            this.updateById(withdrawRecord);
        }
    }

    @Override
    public WithdrawRecord findById(Integer id) {
        WithdrawRecord withdrawRecord = withdrawRecordMapper.selectById(id);
        if (Objects.isNull(withdrawRecord)) {
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        MemberBank memberBank = memberBankMapper.selectById(withdrawRecord.getBankId());
        if(Objects.nonNull(memberBank)){
            withdrawRecord.setBankName(memberBank.getBankName());
        }
        if(!Constants.equalsInteger(withdrawRecord.getStatus(), Constants.ZERO)){
            String path = systemDictDataBiz.queryByCode(Constants.OSS, Constants.RESOURCE_PATH).getCode() +
                    systemDictDataBiz.queryByCode(Constants.OSS, Constants.TRANSFER_FILE).getCode();
            Multifile queryfile = new Multifile();
            queryfile.setObjId(withdrawRecord.getId());
            queryfile.setObjType(  Constants.MultiFile.TRANSFER_FILE.getKey());
            queryfile.setIsdeleted(Constants.ZERO);
            List<Multifile> filelist = multifileMapper.selectList(new QueryWrapper<>(queryfile));
            if(filelist !=null && filelist.size()>0){
                for (Multifile multifile:filelist) {
                    multifile.setFileFullUrl(path + multifile.getFileurl());
                }
                withdrawRecord.setPayFileList(filelist);
            }
        }
        return withdrawRecord;
    }

    @Override
    public WithdrawRecord findOne(WithdrawRecord withdrawRecord) {
        QueryWrapper<WithdrawRecord> wrapper = new QueryWrapper<>(withdrawRecord);
        return withdrawRecordMapper.selectOne(wrapper);
    }

    @Override
    public List<WithdrawRecord> findList(WithdrawRecord withdrawRecord) {
        QueryWrapper<WithdrawRecord> wrapper = new QueryWrapper<>(withdrawRecord);
        return withdrawRecordMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<WithdrawRecord> findPage(PageWrap<WithdrawRecord> pageWrap) {
        IPage<WithdrawRecord> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        QueryWrapper<WithdrawRecord> queryWrapper = new QueryWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());
        if (pageWrap.getModel().getId() != null) {
            queryWrapper.lambda().eq(WithdrawRecord::getId, pageWrap.getModel().getId());
        }
        if (pageWrap.getModel().getCreator() != null) {
            queryWrapper.lambda().eq(WithdrawRecord::getCreator, pageWrap.getModel().getCreator());
        }
        if (pageWrap.getModel().getCreateDate() != null) {
            queryWrapper.lambda().ge(WithdrawRecord::getCreateDate, Utils.Date.getStart(pageWrap.getModel().getCreateDate()));
            queryWrapper.lambda().le(WithdrawRecord::getCreateDate, Utils.Date.getEnd(pageWrap.getModel().getCreateDate()));
        }
        if (pageWrap.getModel().getEditor() != null) {
            queryWrapper.lambda().eq(WithdrawRecord::getEditor, pageWrap.getModel().getEditor());
        }
        if (pageWrap.getModel().getEditDate() != null) {
            queryWrapper.lambda().ge(WithdrawRecord::getEditDate, Utils.Date.getStart(pageWrap.getModel().getEditDate()));
            queryWrapper.lambda().le(WithdrawRecord::getEditDate, Utils.Date.getEnd(pageWrap.getModel().getEditDate()));
        }
        if (pageWrap.getModel().getIsdeleted() != null) {
            queryWrapper.lambda().eq(WithdrawRecord::getIsdeleted, pageWrap.getModel().getIsdeleted());
        }
        if (pageWrap.getModel().getRemark() != null) {
            queryWrapper.lambda().eq(WithdrawRecord::getRemark, pageWrap.getModel().getRemark());
        }
        if (pageWrap.getModel().getMemberId() != null) {
            queryWrapper.lambda().eq(WithdrawRecord::getMemberId, pageWrap.getModel().getMemberId());
        }
        if (pageWrap.getModel().getCode() != null) {
            queryWrapper.lambda().eq(WithdrawRecord::getCode, pageWrap.getModel().getCode());
        }
        if (pageWrap.getModel().getBankId() != null) {
            queryWrapper.lambda().eq(WithdrawRecord::getBankId, pageWrap.getModel().getBankId());
        }
        if (pageWrap.getModel().getStatus() != null) {
            queryWrapper.lambda().eq(WithdrawRecord::getStatus, pageWrap.getModel().getStatus());
        }
        if (pageWrap.getModel().getAuditUser() != null) {
            queryWrapper.lambda().eq(WithdrawRecord::getAuditUser, pageWrap.getModel().getAuditUser());
        }
        if (pageWrap.getModel().getAuditTime() != null) {
            queryWrapper.lambda().ge(WithdrawRecord::getAuditTime, Utils.Date.getStart(pageWrap.getModel().getAuditTime()));
            queryWrapper.lambda().le(WithdrawRecord::getAuditTime, Utils.Date.getEnd(pageWrap.getModel().getAuditTime()));
        }
        if (pageWrap.getModel().getAuditRemark() != null) {
            queryWrapper.lambda().eq(WithdrawRecord::getAuditRemark, pageWrap.getModel().getAuditRemark());
        }
        if (pageWrap.getModel().getPayBank() != null) {
            queryWrapper.lambda().eq(WithdrawRecord::getPayBank, pageWrap.getModel().getPayBank());
        }
        for(PageWrap.SortData sortData: pageWrap.getSorts()) {
            if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) {
                queryWrapper.orderByDesc(sortData.getProperty());
            } else {
                queryWrapper.orderByAsc(sortData.getProperty());
            }
        }
        return PageData.from(withdrawRecordMapper.selectPage(page, queryWrapper));
    }




    @Override
    public long count(WithdrawRecord withdrawRecord) {
        QueryWrapper<WithdrawRecord> wrapper = new QueryWrapper<>(withdrawRecord);
        return withdrawRecordMapper.selectCount(wrapper);
    }



    @Override
    public void withdrawApply(WithdrawApplyRequest request, IntegralService integralService){
        if (Objects.isNull( request)
            || request.getMemberId() == null
            || request.getBankId() == null
            || request.getAmount() == null) {
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        //查询商户剩余余额
        Shop shop = shopMapper.selectById(request.getMemberId());
        if(Objects.isNull(shop)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到商户信息");
        }
        if(shop.getAmount().compareTo(request.getAmount()) < 0){
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"商户余额不足");
        }

        WithdrawRecord withdrawRecord = new WithdrawRecord();
        withdrawRecord.setCreateDate(new Date());
        withdrawRecord.setIsdeleted(Constants.ZERO);
        withdrawRecord.setEditDate(new Date());
        withdrawRecord.setBankId(request.getBankId());
        withdrawRecord.setAmount(request.getAmount());
        withdrawRecord.setMemberId(request.getMemberId());
        withdrawRecord.setCode(this.getNextInCode());
        withdrawRecord.setStatus(Constants.ZERO);
        withdrawRecordMapper.insert(withdrawRecord);

        DealIntegralRequest dealIntegralRequest = new DealIntegralRequest();
        dealIntegralRequest.setIntegralObjType(Constants.IntegralObjType.WITHDRAW_APPLY);
        dealIntegralRequest.setIntegralNum(request.getAmount());
        dealIntegralRequest.setObjId(withdrawRecord.getId());
        dealIntegralRequest.setOrderCode(withdrawRecord.getCode().toString());
        dealIntegralRequest.setMemberId(request.getMemberId());
        dealIntegralRequest.setDealType(Constants.ONE);
        integralService.dealShopAmount(dealIntegralRequest);
    }



    public synchronized  Long  getNextInCode(){
        String prefix =  DateUtil.getDate(new Date(),"yyyyMMdd") ;
        Integer countNum  = RedisUtil.getObject(redisTemplate, Constants.RedisKeys.WITHDRAW_KEY,Integer.class);
        countNum = Constants.formatIntegerNum(countNum)+1;
        //更新缓存
        RedisUtil.addObject(redisTemplate,Constants.RedisKeys.WITHDRAW_KEY,countNum);
        String nextIndex =Long.toString( countNum);
        return Long.parseLong(prefix + StringUtils.leftPad(nextIndex,4,"0"));
    }





}