package com.dy.pipIrrTerminal.card;

import com.dy.pipIrrGlobal.daoPr.PrWaterPriceMapper;
import com.dy.pipIrrGlobal.daoSe.SeCardOperateMapper;
import com.dy.pipIrrGlobal.daoSe.SeClientCardMapper;
import com.dy.pipIrrGlobal.daoSe.SeClientMapper;
import com.dy.pipIrrGlobal.daoSe.SeRechargeHistoryMapper;
import com.dy.pipIrrGlobal.pojoSe.SeCardOperate;
import com.dy.pipIrrGlobal.pojoSe.SeClientCard;
import com.dy.pipIrrGlobal.pojoSe.SeRechargeHistory;
import com.dy.pipIrrGlobal.voSe.VoTermActiveCard;
import com.dy.pipIrrGlobal.voSe.VoTermRecharge;
import com.dy.pipIrrTerminal.card.dto.ActiveCard;
import com.dy.pipIrrTerminal.card.dto.CardSimple;
import com.dy.pipIrrTerminal.card.dto.DtoRecharge;
import com.dy.pipIrrTerminal.card.dto.DtoReissue;
import com.dy.pipIrrTerminal.card.enums.CardStateENUM;
import com.dy.pipIrrTerminal.card.enums.LastOperateENUM;
import com.dy.pipIrrTerminal.card.enums.OperateTypeENUM;
import com.dy.pipIrrTerminal.card.enums.RechargeTypeENUM;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;

/**
 * @author ZhuBaoMin
 * @date 2025-05-08 10:15
 * @LastEditTime 2025-05-08 10:15
 * @Description
 */

@Slf4j
@Service
public class CardSv {
    @Autowired
    private SeCardOperateMapper seCardOperateMapper;

    @Autowired
    private SeClientCardMapper seClientCardMapper;

    @Autowired
    private SeClientMapper seClientMapper;

    @Autowired
    private PrWaterPriceMapper prWaterPriceMapper;

    @Autowired
    private SeRechargeHistoryMapper seRechargeHistoryMapper;

    @Value("${project.projectNo}")
    private Integer projectNo;

    /**
     * 根据水卡地址判断该卡是否可以开卡
     * @param cardAddr
     * @return true:可以开卡
     */
    public Boolean canActiveCard(String cardAddr) {
        // 指定水卡地址的水卡数量，无效卡片排除在外
        Long cardCount = Optional.ofNullable(seClientCardMapper.getCountByCardAddr(cardAddr)).orElse(0L);
        if (cardCount == 0) {
            return true;
        }

        // 指定水卡地址且正常状态或挂失状态的水卡数量
        cardCount = Optional.ofNullable(seClientCardMapper.getCountByCardAddrAndState(cardAddr)).orElse(0L);
        if (cardCount == 0) {
            return true;
        }

        return false;
    }

    /**
     * 根据水卡编号判断该卡是否可以充值
     * @param po
     * @return true:可以充值
     */
    public Map canRecharge(DtoRecharge po) {
        Map map = new HashMap<>();
        map.put("success", false);
        map.put("content", null);

        String stateName = Optional.ofNullable(seClientCardMapper.getCardStateByCardNum(po.getCardNum())).orElse("");
        // 单独充值时卡片必须为正常
        if((po.getRechargeType() == RechargeTypeENUM.RECHARGE.getCode()) && !stateName.equals("正常")) {
            map.put("msg", stateName + ", " + "水卡状态不支持当前操作");
            return map;
        }

        map.put("success", true);
        return map;
    }

    /**
     * 根据水卡编号判断该卡是否可以补卡
     * @param po
     * @return true:可以补卡
     */
    public Map canReissue(DtoReissue po) {
        Map map = new HashMap<>();
        map.put("success", false);
        map.put("content", null);

        Long cardNum = po.getCardNum();
        Integer lostCount = seClientCardMapper.getLostCount(cardNum);
        Integer replacedCount = seClientCardMapper.getReplacedCount(cardNum);
        if(lostCount == 0 || replacedCount > 0) {
            map.put("msg", "水卡未挂失或已补卡，不能补卡");
            return map;
        }

        Float reissueAmount = po.getReissueAmount();
        if (reissueAmount != null && reissueAmount > 0) {
            Double tradeAmount = seCardOperateMapper.getTradeAmountByCardNo(cardNum);
            if (tradeAmount != null && tradeAmount > 0) {
                map.put("msg", "原卡挂失时已退款，补卡时不能补费用");
                return map;
            }
        }

        Map map_card = Optional.ofNullable(seClientCardMapper.getCardIdAndClientNum(cardNum)).orElse(new HashMap());
        if (map_card == null || map_card.size() <= 0) {
            map.put("msg", "卡号错误，该卡不存在");
            return map;
        }

        CardSimple card = new CardSimple();
        card.setCardId(Long.parseLong(map_card.get("cardId").toString()));
        card.setClientId(Long.parseLong(map_card.get("clientId").toString()));
        card.setProtocol(map_card.get("protocol").toString());

        map.put("success", true);
        map.put("content", card);
        return map;
    }

    /**
     * 根据农户编号获取5级行政区划串areaCode，补卡过程中开新卡使用
     * @param clientId
     * @return
     */
    public Long getAreaCodeById(Long clientId) {
        return seClientMapper.getAreaCodeById(clientId);
    }

    public String getCardNumOfMax(String areaCode) {
        return seClientCardMapper.getCardNumOfMax(areaCode);
    }

    public Map generateCardNum(Long clientId) {
        Map map_cardNum = new HashMap<>();
        map_cardNum.put("success", false);
        map_cardNum.put("content", null);

        // 获取5级行政区划串areaCode
        Long areaCodeL = getAreaCodeById(clientId);
        if (areaCodeL == null) {
            map_cardNum.put("msg", "该农户行政区划异常");
            return map_cardNum;
        }

        String areaCode = String.valueOf(areaCodeL);
        String cardNum = Optional.ofNullable(getCardNumOfMax(areaCode)).orElse("");
        if (cardNum != null && cardNum.trim().length() > 0) {
            Integer number = Integer.parseInt(cardNum.substring(12));
            number = number + 1;
            if (number > 65535) {
                map_cardNum.put("msg", "水卡编号已满");
                return map_cardNum;
            }
            cardNum = cardNum.substring(0, 12) + String.format("%05d", number);
        } else {
            cardNum = areaCode + "00001";
        }

        map_cardNum.put("success", true);
        map_cardNum.put("content", cardNum);
        return map_cardNum;
    }

    public String generateOrderNo() {
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyMMddHHmmss");
        LocalDateTime dateTime = LocalDateTime.now();
        Random random = new Random();
        String CHARACTERS = "0123456789";
        StringBuilder sb = new StringBuilder(4);
        for (int i = 0; i < 4; i++) {
            int index = random.nextInt(CHARACTERS.length());
            sb.append(CHARACTERS.charAt(index));
        }
        return dtf.format(dateTime) + sb.toString();
    }

    public Map addCardAndOperate(ActiveCard po, Long cardNum, String orderNo) {
        Map map = new HashMap<>();
        map.put("success", false);
        map.put("content", null);

        // amount：充值接口为输入参数，补卡接口为原卡退还金额
        SeClientCard seClientCard = new SeClientCard();
        seClientCard.setProtocol(po.getProtocol());
        seClientCard.setCardaddr(po.getCardAddr());
        seClientCard.setCardnum(String.valueOf(cardNum));
        seClientCard.setClientid(po.getClientId());
        seClientCard.setMoney(po.getAmount());
        seClientCard.setState(CardStateENUM.INVALID.getCode());
        if (po.getOriginalCardId() != null) {
            // 补卡
            seClientCard.setOriginalCardId(po.getOriginalCardId());
            seClientCard.setLastoper(LastOperateENUM.REPLACE.getCode());
            seClientCard.setReplacedt(new Date());
        } else {
            // 开新卡
            seClientCard.setLastoper(LastOperateENUM.ACTIVE.getCode());
            seClientCard.setCreatedt(new Date());
        }

        seClientCardMapper.insert(seClientCard);
        Long cardId = Optional.ofNullable(seClientCard.getId()).orElse(0L);
        if (cardId == 0) {
            map.put("msg", "开卡失败-农户卡写入异常");
            return map;
        }

        SeCardOperate seCardOperate = new SeCardOperate();
        seCardOperate.setCardId(cardId);
        seCardOperate.setClientId(po.getClientId());
        seCardOperate.setMoney(0f);
        seCardOperate.setCardCost(po.getCardCost());
        seCardOperate.setPaymentId(po.getPaymentId());
        if (po.getOriginalCardId() != null) {
            // 补卡
            seCardOperate.setOperateType(OperateTypeENUM.REISSUE.getCode());
            seCardOperate.setNoTradeAmount(po.getAmount());
        } else {
            // 开新卡
            seCardOperate.setOperateType(OperateTypeENUM.ACTIVE.getCode());
        }
        seCardOperate.setRemarks(po.getRemarks());
        seCardOperate.setOperator(po.getOperator());
        seCardOperate.setOperateDt(new Date());
        seCardOperate.setOrderNo(orderNo);
        seCardOperate.setOperateValid((byte) 1);

        seCardOperateMapper.insert(seCardOperate);
        Long rec = Optional.ofNullable(seCardOperate.getId()).orElse(0L);
        if (rec == 0) {
            map.put("msg", "开卡失败-开卡记录写入异常");
            return map;
        }

        map.put("success", true);
        return map;
    }

    /**
     * 开卡附加充值
     * @param po
     * @param cardNum
     * @return
     */
    public Map plusRecharge(ActiveCard po, Long cardNum) {
        Map map = new HashMap<>();
        map.put("success", false);
        map.put("content", null);

        /**
         * 添加水卡操作记录
         */
        DtoRecharge dtoRecharge = new DtoRecharge();
        dtoRecharge.setCardNum(cardNum);
        dtoRecharge.setAmount(po.getAmount());
        dtoRecharge.setPaymentId(po.getPaymentId());
        dtoRecharge.setRemarks(po.getRemarks());
        dtoRecharge.setOperator(po.getOperator());
        dtoRecharge.setMoney(0f);
        dtoRecharge.setGift(0f);
        dtoRecharge.setPrice(0f);
        Map map_plusRecharge = addRecharge(dtoRecharge);
        if (!map_plusRecharge.get("success").equals(true)) {
            map.put("msg", "开卡失败-充值异常");
            return map;
        }
        map.put("success", true);
        return map;
    }

    /**
     * 激活或补卡
     * @param po
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public Map activeOrReissueTermCard(ActiveCard po) {
        Map map = new HashMap<>();
        map.put("success", false);
        map.put("content", null);
        Float amount = po.getAmount();
        Long originalCardId = po.getOriginalCardId();

        if (!canActiveCard(po.getCardAddr())) {
            map.put("msg", "开卡失败-此卡已存在");
            return map;
        }

        Map map_cardNum = generateCardNum(po.getClientId());
        if(map_cardNum.get("success").equals(false)) {
            map.put("msg", map_cardNum.get("msg").toString());
            return map;
        }
        Long cardNum = Long.parseLong(map_cardNum.get("content").toString());

        String orderNo = generateOrderNo();
        Map map_addCardAndOperate = addCardAndOperate(po, cardNum, orderNo);
        if(map_addCardAndOperate.get("success").equals(false)) {
            map.put("msg", map_addCardAndOperate.get("msg").toString());
            return map;
        }

        if (amount != null && amount > 0 && originalCardId == null) {
            Map map_plusRecharge = plusRecharge(po, cardNum);
            if(map_plusRecharge.get("success").equals(false)) {
                map.put("msg", map_plusRecharge.get("msg").toString());
                return map;
            }
        }

        Float balance = Optional.ofNullable(seClientCardMapper.getMoneyByCardNum(cardNum)).orElse(0f);
        Double waterPrice = prWaterPriceMapper.getPrice();

        VoTermActiveCard voTermActiveCard = new VoTermActiveCard();
        voTermActiveCard.setProjectNo(projectNo);
        voTermActiveCard.setCardNum(cardNum);
        voTermActiveCard.setBalance(balance);
        voTermActiveCard.setWaterPrice(waterPrice);
        voTermActiveCard.setTime(new Date());
        voTermActiveCard.setOrderNo(orderNo);

        map.put("success", true);
        map.put("msg", "操作成功");
        map.put("content", voTermActiveCard);
        return map;
    }

    /**
     * 充值
     * @param po
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public Map addRecharge(DtoRecharge po) {
        Map map = new HashMap<>();
        map.put("success", false);
        map.put("content", null);

        Map map_canRecharge = canRecharge(po);
        if(map_canRecharge.get("success").equals(false)) {
            map.put("msg", map_canRecharge.get("msg").toString());
            return map;
        }

        /**
         * 依据水卡编号获取水卡表主键及农户编号
         */
        Map map_cardAndClient = seClientCardMapper.getCardIdAndClientNum(po.getCardNum());
        if (map_cardAndClient == null || map_cardAndClient.size() <= 0) {
            map.put("msg", "卡号错误，该卡不存在");
            return map;
        }
        Long cardId = Long.parseLong(map_cardAndClient.get("cardId").toString());
        Long clientId = Long.parseLong(map_cardAndClient.get("clientId").toString());
        String orderNo = generateOrderNo();

        /**
         * 添加水卡充值操作记录
         */
        SeCardOperate seCardOperate = new SeCardOperate();
        seCardOperate.setCardId(cardId);
        seCardOperate.setClientId(clientId);
        seCardOperate.setMoney(po.getMoney());
        seCardOperate.setTradeAmount(po.getAmount());
        seCardOperate.setGift(po.getGift());
        seCardOperate.setOperateType(OperateTypeENUM.RECHARGE.getCode());
        seCardOperate.setPaymentId(po.getPaymentId());
        seCardOperate.setPrice(po.getPrice());
        seCardOperate.setRemarks(po.getRemarks());
        seCardOperate.setOperator(po.getOperator());
        seCardOperate.setOperateDt(new Date());
        seCardOperate.setOrderNo(orderNo);
        seCardOperate.setOperateValid((byte) 1);
        seCardOperateMapper.insert(seCardOperate);
        Long rec = Optional.ofNullable(seCardOperate.getId()).orElse(0L);
        if (rec == 0) {
            map.put("msg", "充值失败-充值记录写入异常");
            return map;
        }

        /**
         * 添加充值历史记录
         */
        SeRechargeHistory seRechargeHistory = new SeRechargeHistory();
        seRechargeHistory.setCardid(cardId);
        seRechargeHistory.setClientid(clientId);
        seRechargeHistory.setMoney(po.getMoney());
        seRechargeHistory.setAmount(po.getAmount());
        seRechargeHistory.setGift(po.getGift());
        Float afterRecharge = po.getMoney() + po.getAmount() + po.getGift();
        seRechargeHistory.setAfterrecharge(afterRecharge);
        seRechargeHistory.setPaymentid(po.getPaymentId());
        seRechargeHistory.setPrice(po.getPrice());
        seRechargeHistory.setRemarks(po.getRemarks());
        seRechargeHistory.setOperator(po.getOperator());
        seRechargeHistory.setOperatedt(new Date());
        seRechargeHistory.setOperateValid((byte) 1);
        seRechargeHistoryMapper.insert(seRechargeHistory);
        Long rec_seRechargeHistory = Optional.ofNullable(seRechargeHistory.getId()).orElse(0L);
        if (rec_seRechargeHistory == 0) {
            map.put("msg", "充值失败-充值历史记录写入异常");
            return map;
        }

        VoTermRecharge voTermRecharge = new VoTermRecharge();
        voTermRecharge.setProjectNo(projectNo);
        voTermRecharge.setCardNum(po.getCardNum());
        voTermRecharge.setOrderNo(orderNo);

        map.put("success", true);
        map.put("msg", "操作成功");
        map.put("content", voTermRecharge);
        return map;
    }

    /**
     * 补卡
     * @param po
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public Map reissue(DtoReissue po) {
        Map map = new HashMap<>();
        map.put("success", false);
        map.put("content", null);

        Map map_canReissue = canReissue(po);
        if(map_canReissue.get("success").equals(false)) {
            map.put("msg", map_canReissue.get("msg").toString());
            return map;
        }
        CardSimple card = (CardSimple) map_canReissue.get("content");
        Long cardId = card.getCardId();
        Long clientId = card.getClientId();
        String protocol = card.getProtocol();

        /**
         * 添加开卡记录，退还金额冲到新卡中
         */
        ActiveCard activeCard = new ActiveCard();
        activeCard.setProtocol(protocol);
        activeCard.setCardAddr(po.getCardAddr());
        activeCard.setClientId(clientId);
        activeCard.setOriginalCardId(cardId);
        activeCard.setCardCost(po.getCardCost());
        activeCard.setAmount(po.getReissueAmount());
        activeCard.setPaymentId(po.getPaymentId());
        activeCard.setRemarks(po.getRemarks());
        activeCard.setOperator(po.getOperator());

        Map map_newCard = activeOrReissueTermCard(activeCard);
        VoTermActiveCard voTermActiveCard = (VoTermActiveCard) map_newCard.get("content");

        map.put("success", true);
        map.put("msg", "操作成功");
        map.put("content", voTermActiveCard);
        return map;
    }
}