package com.fzzy.igds.timer;

import com.fzzy.igds.constant.Constant;
import com.fzzy.igds.data.BaseResp;
import com.fzzy.igds.data.IgdsBaseParam;
import com.fzzy.igds.data.PledgeReminders;
import com.fzzy.igds.domain.Depot;
import com.fzzy.igds.domain.FoodPrice;
import com.fzzy.igds.domain.PledgeContract;
import com.fzzy.igds.domain.PledgeContractDepot;
import com.fzzy.igds.service.DepotService;
import com.fzzy.igds.service.FoodPriceService;
import com.fzzy.igds.service.PledgeContractDepotService;
import com.fzzy.igds.service.PledgeContractService;
import com.fzzy.work.data.WorkBizType;
import com.fzzy.work.domain.WorkOrderConf;
import com.fzzy.work.service.BizWorkService;
import com.ruoyi.common.utils.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;

/**
 * @Description 警告信息定时统计：还款提醒
 * @Author CZT
 * @Date 2026/1/23 9:14
 */
@Slf4j
@Service
public class JobWarnService {

    @Resource
    private PledgeContractService contractService;

    @Resource
    private PledgeContractDepotService pledgeContractDepotService;

    @Resource
    private DepotService depotService;
    @Resource
    private FoodPriceService foodPriceService;
    @Resource
    private BizWorkService workService;


    /**
     * 每天两点执行：还款提醒
     */
    @Scheduled(cron = "0 0 2 * * ?")
    public void timer() {
        doExe(null);
    }

    /**
     * 开始质押合同核算
     */
    public void doExe(String bankId) {
        List<PledgeContract> contractList = contractService.getContractByPledge(new Date(), bankId);
        if (null == contractList || contractList.isEmpty()) {
            log.error("-----当前没有有效期的质押合同，不执行提醒核算-----");
            return;
        }
        Depot depot;
        FoodPrice foodPrice;
        WorkOrderConf conf = null;

        double sumMoney = 0.0;
        double per = 0.0;
        double backMoney = 0.0;
        for (PledgeContract pledgeContract : contractList) {
            log.info("-----开始处理质押合同：{}-----", pledgeContract.getName());
//            List<PledgeReminders> remindersList = new ArrayList<>();

            Map<String, PledgeReminders> remindersMap = new HashMap<>();

            //获取质押仓库信息
            IgdsBaseParam igdsBaseParam = new IgdsBaseParam();
            igdsBaseParam.setParentId(pledgeContract.getId());
            List<PledgeContractDepot> pledgeContractDepots = pledgeContractDepotService.listAll(igdsBaseParam);

            //计算待还款金额
            backMoney = pledgeContract.getContractAmount() - pledgeContract.getRepaidAmount();
            if (backMoney <= 0.0) {
                //若待还金额为0，则不统计此合同
                log.error("-----当前合同={}没有待还金额为{}，不执行提醒核算-----", pledgeContract.getName(), backMoney);
                continue;
            }

            if (StringUtils.isBlank(pledgeContract.getPledgeBank())) {
                //若质押银行未空，则跳过当前合同
                log.error("-----当前合同={}没有设置质押银行，不执行提醒核算-----", pledgeContract.getName());
                continue;
            }

            if (pledgeContractDepots.isEmpty()) {
                //若质押仓库为空，则跳过当前合同
                log.error("-----当前合同={}没有设置质押仓库，不执行提醒核算-----", pledgeContract.getName());
                continue;
            }

            sumMoney = 0.0;
            //获取质押库区
            List<String> deptIds = new ArrayList<>();
            for (PledgeContractDepot pledgeContractDepot : pledgeContractDepots) {
                String depotId = pledgeContractDepot.getPledgeDepot();
                deptIds.add(pledgeContractDepot.getPledgeDept());
                //查询仓库信息
                depot = depotService.getCacheDepot(pledgeContract.getCompanyId(), depotId);
                if (null == depot) {
                    log.error("-----当前合同={}下仓库={}不存在，不统计此仓库-----", pledgeContract.getName(), depotId);
                    continue;
                }
                if (null == depot.getStorageReal()) {
                    depot.setStorageReal(0.0);
                }

                foodPrice = foodPriceService.getDataByBankAndFood(pledgeContract.getPledgeBank(), depot.getFoodVariety());
                if (null == foodPrice || null == foodPrice.getPrice()) {
                    log.error("-----当前合同={}下仓库={}对应的品种={}未配置价格，不统计此仓库-----", pledgeContract.getName(), depot.getName(), depot.getFoodVariety());
                    continue;
                }

                sumMoney += depot.getStorageReal() * foodPrice.getPrice();
                //按品种+单价生成key，来作为唯一标识，统计粮食品种的库存量以及粮食品种信息
                String key = depot.getFoodVariety() + foodPrice.getPrice();
                PledgeReminders pledgeReminders = remindersMap.get(key);
                if (null == pledgeReminders) {
                    pledgeReminders = new PledgeReminders();
                    pledgeReminders.setFoodVariety(depot.getFoodVariety());
                    pledgeReminders.setFoodVarietyName(depot.getFoodVarietyName());
                    pledgeReminders.setFoodPrice(foodPrice.getPrice());
                    pledgeReminders.setStorageReal(pledgeReminders.getStorageReal() + depot.getStorageReal());

                } else {
                    pledgeReminders.setStorageReal(pledgeReminders.getStorageReal() + depot.getStorageReal());
                }
                remindersMap.put(key, pledgeReminders);
                log.info("-----当前合同={}下仓库={}：对应的实际储量={}，对应粮食单价={}-----", pledgeContract.getName(), depot.getName(), depot.getStorageReal(), foodPrice.getPrice());
            }

            per = sumMoney / backMoney;

            if (per > 1.1) {
                //货可以抵贷款
                log.error("-----当前合同={}下质押仓库={}库存未到待还款的110%，sumMoney={}，backMoney={}，不生成还款提醒工单-----", pledgeContract.getName(), pledgeContract.getDepotNames(), sumMoney, backMoney);
                continue;
            }
            //货不足以抵贷款 ,提醒企业补钱

            //根据质押仓库的库区，找到其中一个库区配置的提醒工单流程
            for (String deptId : deptIds){
                WorkOrderConf confByDeptId = workService.getConfByDeptId(deptId, WorkBizType.TYPE_50);
                if(null!=confByDeptId && Constant.YN_Y.equals(confByDeptId.getValTag())){
                    conf=confByDeptId;
                    break;
                }
            }
            //流程不启用
            if (null == conf || Constant.YN_N.equals(conf.getValTag())) {
                log.error("-----当前合同={}质押库区={}未配置还款提醒审批流程，无法生成工单提醒-----", pledgeContract.getName(), pledgeContract.getPledgeDept());
                continue;
            }

            BaseResp resp = workService.startByBackMoney(pledgeContract, conf, remindersMap);
            log.info("---------当前合同={}启动还款提醒工单流程------{}", pledgeContract.getName(), resp);
        }
    }

}