package com.hx.phip.tool.user;

import com.hx.common.service.CommonService;
import com.hx.exception.TipsException;
import com.hx.mybatisTool.SqlSentence;
import com.hx.phiappt.model.cardItem.CardEquity;
import com.hx.phiappt.model.cardItem.CardItemInfo;
import com.hx.phiappt.model.consume.ConsumePayItem;
import com.hx.phiappt.model.order.OrderItem;
import com.hx.phiappt.model.order.OrdersTotal;
import com.hx.phiappt.model.user.UserCard;
import com.hx.phiappt.model.user.UserCardUsed;
import com.hx.phip.dao.mapper.OrderItemMapper;
import com.hx.phip.dao.mapper.OrdersTotalMapper;
import com.hx.phip.dao.mapper.UserCardUsedMapper;
import com.hx.phip.tool.order.OrderTool;
import com.hx.phip.vo.user.UserCardItemInfoVo;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.stream.Collectors;

/**
 *用户卡包处理工具
 * @author CJH
 */
public class UserCardTool {

    /**计算使用次数
     * @param buyNumber 购买数量
     * @param cardItemInfo 卡项条目
     * @param cardEquity 卡项权益
     * @return 计算得出抵扣次数
     */
    public static int countUsedNumber(int buyNumber, CardItemInfo cardItemInfo,CardEquity cardEquity){
        int userdNum ;
        if(CardEquity.EQUITY_TYPE_TIME_CARD.equals(cardEquity.getEquityType())){
            //次卡，权益有总次数，所有条目使用的总次数不能大于权益的总次数
            userdNum = buyNumber*cardItemInfo.getEveryDrawNum();
        }else if(CardEquity.EQUITY_TYPE_N_M.equals(cardEquity.getEquityType())){
            //N选M
            userdNum = buyNumber;
        }else{
            //固定或者其他
            userdNum = buyNumber;
        }
        return userdNum;
    }


    /**获取卡包-卡项条目剩余次数
     * @param userCard 用户卡包
     * @param cardItemInfo 卡项条目
     * @param cardEquity 卡项权益
     * @param commonService 映射
     * @return 数据结构
     */
    public static UserCardItemInfoVo getSurplusNumber(UserCard userCard, CardItemInfo cardItemInfo,CardEquity cardEquity, CommonService commonService){

        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> values = new HashMap<>();

        //获取使用记录，注意：是根据权益，不是卡项条目查询
        values.put("cardEquityId",cardEquity.getId());
        values.put("userCardId",userCard.getId());
        values.put("isDel",UserCardUsed.NO);
        sqlSentence.sqlSentence("SELECT * FROM user_card_used WHERE cardEquityId = #{m.cardEquityId} AND userCardId = #{m.userCardId} AND isDel = #{m.isDel}",values);
        //根据cardItemIfo标识查询用户使用记录
        List<UserCardUsed> userCardUsedList = commonService.selectList(UserCardUsedMapper.class, sqlSentence);

        //已使用的条目标识集合
        Set<String> cardItemInfoIds = new HashSet<>();
        //每个条目使用总次数Map
        Map<String,Integer> cardItemInfoUseMap = new HashMap<>();
        //计算所有条目已使用总次数
        Integer usedGeneral = 0;

        Integer num;
        for(UserCardUsed userCardUsed:userCardUsedList){
            //计算所有条目已使用总次数
            usedGeneral = usedGeneral+userCardUsed.getUsedNum();
            //已使用的条目标识集合
            cardItemInfoIds.add(userCardUsed.getCardItemInfoId());
            //每个条目使用总参数Map
            num = cardItemInfoUseMap.computeIfAbsent(userCardUsed.getCardItemInfoId(),k->0);
            num = num + userCardUsed.getUsedNum();
            cardItemInfoUseMap.put(userCardUsed.getCardItemInfoId(),num);
        }

        //返回结构
        UserCardItemInfoVo userCardItemInfoVo = new UserCardItemInfoVo();

        if(CardEquity.EQUITY_TYPE_TIME_CARD.equals(cardEquity.getEquityType())){
            //次卡，权益有总次数，所有条目使用的总次数不能大于权益的总次数
            if(usedGeneral < cardEquity.getValue()){
                //是否设置了最大的抵扣次数
                int surplusNum = cardEquity.getValue() - usedGeneral;
                if(cardItemInfo.getMaxNum() != null && cardItemInfo.getMaxNum() != 0){
                    userCardItemInfoVo.setSurplusNum(cardItemInfo.getMaxNum() - cardItemInfoUseMap.computeIfAbsent(cardItemInfo.getId(),k->0));
                    if(userCardItemInfoVo.getSurplusNum() > surplusNum){
                        userCardItemInfoVo.setSurplusNum(surplusNum);
                    }
                }else{
                    userCardItemInfoVo.setSurplusNum(surplusNum);
                }
            }else{
                userCardItemInfoVo.setSurplusNum(0);
            }
        }else if(CardEquity.EQUITY_TYPE_N_M.equals(cardEquity.getEquityType())){
            //N选M，每个条目都有自己的可抵扣总次数
            if(cardItemInfoIds.contains(cardItemInfo.getId())){
                //已经使用条目集合包含当前条目
                userCardItemInfoVo.setSurplusNum(cardItemInfo.getMaxNum() - cardItemInfoUseMap.get(cardItemInfo.getId()));
            }else{
                //已经使用条目集合没有包含当前条目
                if(cardItemInfoIds.size() >= cardEquity.getValue()){
                    //已经选择满条目数量了
                    userCardItemInfoVo.setSurplusNum(0);
                    //不符合
                    userCardItemInfoVo.setNumByNum(false);
                }else{
                    //没有选择满条目数量
                    userCardItemInfoVo.setSurplusNum(cardItemInfo.getMaxNum());
                }
            }
        }else{
            //固定或者其他
            userCardItemInfoVo.setSurplusNum(cardItemInfo.getMaxNum() - cardItemInfoUseMap.computeIfAbsent(cardItemInfo.getId(),k->0));
        }
        //使用次数
        userCardItemInfoVo.setUsedNum(cardItemInfoUseMap.computeIfAbsent(cardItemInfo.getId(),k->0));

        return userCardItemInfoVo;
    }

    /**卡包- 创建用户卡包使用记录
     * @param usedNum 当前需要抵扣的次数
     * @param orderId 订单标识
     * @param sourceType 来源类型
     * @param sourceId 来源标识
     * @param userCard 用户卡包
     * @param cardItemInfo 卡项条目
     * @param cardEquity 卡项权益
     * @param commonService 映射
     * @return 用户卡包使用记录
     */
    public static UserCardUsed insertUserCardUsed(Integer usedNum,String orderId,Integer sourceType,String sourceId, UserCard userCard
            , CardItemInfo cardItemInfo, CardEquity cardEquity,CommonService commonService) {
        UserCardUsed userCardUsed=new UserCardUsed();

        userCardUsed.setEquityType(cardEquity.getEquityType());
        userCardUsed.setGroupName(cardEquity.getGroupName());
        userCardUsed.setCommonId(cardItemInfo.getCommonId());
        userCardUsed.setCommonName(cardItemInfo.getCommonName());
        userCardUsed.setCommonType(cardItemInfo.getCommonType());
        userCardUsed.setPrice(cardItemInfo.getPrice());
        userCardUsed.setUsedGeneral(usedNum);
        userCardUsed.setUsedNum(usedNum);
        userCardUsed.setCancelNum(0);
        userCardUsed.setEmResultsNum(cardItemInfo.getEmResultsNum());
        userCardUsed.setShareMoney(cardItemInfo.getShareMoney());
        userCardUsed.setEveryDrawNum(cardItemInfo.getEveryDrawNum());
        userCardUsed.setEveryShareMoney(cardItemInfo.getEveryShareMoney());
        userCardUsed.setUserCardCode(userCard.getCode());
        userCardUsed.setUserCardId(userCard.getId());
        userCardUsed.setSourceType(sourceType);
        userCardUsed.setSourceId(sourceId);
        userCardUsed.setOrderId(orderId);
        userCardUsed.setCardEquityId(cardEquity.getId());
        userCardUsed.setCardItemInfoId(cardItemInfo.getId());
        commonService.insert(UserCardUsedMapper.class,userCardUsed);
        return userCardUsed;
    }

    /**计算用户卡包购买时候的金额分摊方式-订单*/
    public static void userCardPay(UserCard userCard,CommonService commonService){
        //不是订单购买的卡包，跳出循环
        if(UserCard.SOURCE_TYPE_ORDER_ONE != userCard.getSourceType()){
            return;
        }

        //通过购买这个卡项的订单来算单卡的钱是多少
        //查询已经退了多少钱，避免退超了支付方式金额

        OrderItem orderItem = commonService.selectOneByKey(OrderItemMapper.class,userCard.getSourceId());
        if(orderItem == null){
            throw new TipsException("获取订单子信息失败[895]");
        }
        if(orderItem.getBuyNum().compareTo(0) < 1){
            throw new TipsException("获取订单子信息购买数量错误！");
        }

        //求单个金额
        BigDecimal total = orderItem.getActualTotal().divide(new BigDecimal(orderItem.getBuyNum()),2, RoundingMode.UP);
        //金额不是0元以上，不处理
        if(total.compareTo(BigDecimal.ZERO) <= 0){
            return;
        }

        /**获取订单支付方式*/
        List<ConsumePayItem> consumePayItemList = OrderTool.getOrderOnePay(userCard.getSourceId(),commonService);


        consumePayItemList = consumePayItemList.stream().sorted(Comparator.comparing(ConsumePayItem::getpTotal))
                .collect(Collectors.toList());

        //求比率
        BigDecimal proportion = total.divide(orderItem.getActualTotal(),20,RoundingMode.HALF_UP);
        for(ConsumePayItem consumePayItem:consumePayItemList){

        }

    }

}