package com.caimei.modules.order.service;

import com.caimei.modules.hehe.dao.HeHeNewOrderDao;
import com.caimei.modules.order.dao.*;
import com.caimei.modules.order.entity.*;
import com.caimei.modules.user.dao.CmUserBalanceRecordDao;
import com.caimei.modules.user.dao.NewCmShopDao;
import com.caimei.modules.user.entity.CmUserBalanceRecord;
import com.caimei.modules.user.entity.NewCmShop;
import com.caimei.utils.MathUtil;
import com.thinkgem.jeesite.common.persistence.Page;
import com.thinkgem.jeesite.common.service.CrudService;
import com.thinkgem.jeesite.common.utils.DateUtils;
import com.thinkgem.jeesite.common.utils.ObjectUtils;
import com.thinkgem.jeesite.common.utils.StringUtils;
import com.thinkgem.jeesite.modules.sys.entity.User;
import com.thinkgem.jeesite.modules.sys.utils.UserUtils;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * 识别款项表Service
 *
 * @author lwt
 * @version 2019-06-19
 */
@Service
@Transactional(readOnly = true)
public class CmDiscernReceiptService extends CrudService<CmDiscernReceiptDao, CmDiscernReceipt> {

    @Resource
    private CmDiscernReceiptDao cmDiscernReceiptDao;
    @Resource
    private NewOrderDao newOrderDao;
    @Resource
    private CmReceiptOrderRelationService cmReceiptOrderRelationService;
    @Resource
    private CmRebateRecordDao cmRebateRecordDao;
    @Resource
    private NewCmShopDao newCmShopDao;
    @Resource
    private NewShopOrderDao newShopOrderDao;
    @Resource
    private HeHeNewOrderDao heHeNewOrderDao;
    @Resource
    private CmRefundShopRecordDao cmRefundShopRecordDao;
    @Resource
    private CmUserBalanceRecordDao cmUserBalanceRecordDao;

    public CmDiscernReceipt get(String id) {
        return super.get(id);
    }

    public List<CmDiscernReceipt> findList(CmDiscernReceipt cmDiscernReceipt) {
        return super.findList(cmDiscernReceipt);
    }

    public Page<CmDiscernReceipt> findPage(Page<CmDiscernReceipt> page, CmDiscernReceipt cmDiscernReceipt) {
        Page<CmDiscernReceipt> result = super.findPage(page, cmDiscernReceipt);
        result.getList().forEach(bean -> {
            logger.info("-----------------:::::" + bean.getId());
            String type = "";
            String no = "";
            if ("1".equals(bean.getReceiptType()) || "3".equals(bean.getReceiptType()) || "5".equals(bean.getReceiptType())) {
                List<Map<String, Object>> orderIDs = cmDiscernReceiptDao.getOrderIDStr(bean.getId());
                for (Map<String, Object> map : orderIDs) {
                    if (!ObjectUtils.isEmpty(map)) {
                        if ("".equals(type)) {
                            // 协销订单 0 普通订单 1',
                            Integer orderType = (Integer) map.get("orderType");
                            if (null != map.get("orderType")) {
                                type += map.get("orderType").toString().equals("0") ? "协销" : "自主";
                            } else {
                                type += "自主";
                            }
                            if (2 == orderType) {
                                //呵呵商城订单
                                Integer orderId = ((Long) map.get("orderID")).intValue();
                                NewOrder order = newOrderDao.findByOrderID(orderId);
                                String name = heHeNewOrderDao.findHeUser(order.getUserID());
                                bean.setName(name);
                                bean.setReceiptOrderType("2");
                            }
                        } else {
                            type += ("<br>" + (map.get("orderType").toString().equals("0") ? "协销" : "自主"));
                        }
                        if ("".equals(no)) {
                            no += "<a href='/a/order/detail?id=" + map.get("orderID") + "'>" + map.get("orderNo") + "</a>";
                        } else {
                            no += ("<br><a href='/a/order/detail?id=" + map.get("orderID") + "'>" + map.get("orderNo")) + "</a>";
                        }
                    }
                }
            }
            if ("6".equals(bean.getReceiptType())) {
                // 超级会员款
                Integer vipRecordId = cmDiscernReceiptDao.getVipRecordId(bean.getId());
                Integer userId = cmDiscernReceiptDao.getVipUserId(vipRecordId);
                String userName = cmDiscernReceiptDao.getUserNameByUserId(userId);
                bean.setName(userName);
            }
            if ("7".equals(bean.getReceiptType())) {
                //二手商品上架费
                bean.setName("-----");
            }
            bean.setOrders(no);
            bean.setOrderType(type);
        });
        return result;
    }

    @Transactional(readOnly = false)
    public void save(CmDiscernReceipt cmDiscernReceipt) {
        super.save(cmDiscernReceipt);
    }

    @Transactional(readOnly = false)
    public void delete(CmDiscernReceipt cmDiscernReceipt) {
        super.delete(cmDiscernReceipt);
    }

    public ReceiptDetailVo detail(CmDiscernReceipt cmDiscernReceipt) {
        ReceiptDetailVo vo = cmDiscernReceiptDao.getInfos(cmDiscernReceipt.getId());
        List<CmReceiptOrderRelation> relations = cmReceiptOrderRelationService.findByReceiptID(cmDiscernReceipt.getId());
        boolean receiptOrderFlag = false;
        if (CollectionUtils.isNotEmpty(relations) && relations.size() > 1) {
            receiptOrderFlag = true;
        }
        vo.setReceiptOrderFlag(receiptOrderFlag);//设置一款多单状态
        List<ReceiptOrderInfoVo> orderInfos = new ArrayList<>(); //一个收款可能会关联了一个或多个订单
        for (CmReceiptOrderRelation relation : relations) {
            ReceiptOrderInfoVo roi = null; //这是通过订单列表上的一条收款记录对应的多个订单中的一个订单
            if ("1".equals(relation.getRelationType())) { // relation.orderID 指的是子订单id
                roi = cmDiscernReceiptDao.getOrderInfoByShopOrderID(relation.getOrderID());
                if (null != roi) {
                    roi.setRelationType("1");
                    if ("5".equals(vo.getReceiptType())) {
                        //供应商退款,已退金额
                        List<CmRefundShopRecord> records = cmRefundShopRecordDao.getRefundedRecords(roi.getShopOrderID());
                        if (records != null && records.size() > 0) {
                            Double collect = records.stream().mapToDouble(CmRefundShopRecord::getRefundAmount).sum();
                            roi.setRefundsAmount(collect);
                        } else {
                            roi.setRefundsAmount(0d);
                        }
                        //查询收款供应商退款金额
                        /*BigDecimal shopRefundAmount = cmRefundShopRecordDao.findShopRefund(Integer.valueOf(roi.getShopOrderID()));
                        BigDecimal refundsAmount = MathUtil.add(roi.getRefundsAmount(), shopRefundAmount);
                        roi.setRefundsAmount(refundsAmount.doubleValue());*/
                    }
                }
            }
            if ("2".equals(relation.getRelationType())) { // relation.orderID 指的是主订单id
                roi = cmDiscernReceiptDao.getOrderInfoByOrderID(relation.getOrderID());
                if (null != roi) {
                    roi.setRelationType("2");
                    if (0 == roi.getOnlinePayFlag()) {
                        // 可以线上支付，查询子订单信息
                        List<NewShopOrder> shopOrderInfos = cmDiscernReceiptDao.getShopOrderInfos(null, relation.getOrderID());
                        roi.setShopOrderInfos(shopOrderInfos);
                    }
                }
            }
            if (null != roi) {
                List<ReceiptRecordVo> receiptRecordByOrderID = cmDiscernReceiptDao.findReceiptRecordByOrderID(roi);
                //                暂时不启用抹平明细
                if (CollectionUtils.isNotEmpty(receiptRecordByOrderID)) {
                    for (ReceiptRecordVo v : receiptRecordByOrderID) {
                        if (StringUtils.equals("3", v.getConfirmType())) {
                            String id = v.getReceiptID();
                            double returnBalanceAmount = cmDiscernReceiptDao.getReturnBalanceAmount(id);
                            v.setReturnBalanceAmount(returnBalanceAmount);
                        }
                        //统计当前已收
                        double associateAmount = cmDiscernReceiptDao.getAssociateAmount(String.valueOf(roi.getOrderID()));
                        v.setOrderReceivedAmount(associateAmount);
                    }
                }
                //一个订单又包含了多个收款记录
                roi.setReceiptRecordVo(receiptRecordByOrderID);
                orderInfos.add(roi);
            }
        }
        if ("6".equals(vo.getReceiptType())) {
            // 3超级会员款
            ReceiptVipInfoVo receiptVipInfo = cmDiscernReceiptDao.getReceiptVipInfo(vo.getReceiptID());
            vo.setVipInfo(receiptVipInfo);
        }
        if ("7".equals(vo.getReceiptType())) {
            // 二手商品上架费

        }
        if ("8".equals(vo.getReceiptType())) {
            //优惠券购买费
            ReceipCouponInfoVo couponInfo = cmDiscernReceiptDao.getCouponInfo(vo.getReceiptID());
            vo.setCouponInfo(couponInfo);
        }
        vo.setOrderInfos(orderInfos);
        return vo;
    }

    @Transactional(readOnly = false)
    public void cancel(CmDiscernReceipt cmDiscernReceipt, String note) throws Exception {
        //receiptType 收款款项类型：1订单款，2非订单款，3返佣款
        //1订单款
        //撤销前  如果收款记录已经审核 那么要去还原这条收款记录  如果收款记录没有通过审核 那么直接修改收款记录的状态就可以
        if ("1".equals(cmDiscernReceipt.getReceiptType())) {
            // 先撤销一下收款记录就好了
            if ("3".equals(cmDiscernReceipt.getReceiptStatus())) {  //  还原订单收款状态
//				找到这个记录关联了那些订单  看看订单除了这一次收款还有没有其他的收款记录  如果有 那么订单会被还原成部分收款
//              如果没有 那么订单就是待收款  注意这里的订单都是主订单
                List<String> orderIDs = cmDiscernReceiptDao.findOrderIDs(cmDiscernReceipt.getId());
                for (String orderID : orderIDs) {
                    List<String> records = cmDiscernReceiptDao.hasReceiptRecordOrder(orderID, cmDiscernReceipt.getId()); //订单款项的收款记录
                    NewOrder order = newOrderDao.get(orderID);
                    if (CollectionUtils.isEmpty(records) && (order.getBalancePayFee() == null || order.getBalancePayFee() <= 0D)) {
                        //说明除了现在正在撤销的这一条收款记录  这个订单没有其他的收款记录  就是说 撤销以后这个订单是代付款状态
                        order.setReceiptStatus("1");
                        if (order.getStatus().length() == 2) {
                            order.setStatus("1" + order.getStatus().substring(1, 2));
                        }
                        if ("4".equals(order.getStatus()) || "5".equals(order.getStatus())) {
                            order.setStatus("13");
                        }
                    } else {
                        //反之这个订单就是部分付款状态
                        order.setReceiptStatus("2");
                        if (order.getStatus().length() == 2) {
                            order.setStatus("2" + order.getStatus().substring(1, 2));
                        }
                        if ("4".equals(order.getStatus()) || "5".equals(order.getStatus())) {
                            order.setStatus("23");
                        }
                    }
                    newOrderDao.update(order);
                    // 充值定金商品
                    Integer depositProductId = newOrderDao.getDepositOrderProductId(order.getOrderID());
                    if (6060 == depositProductId) {
                        // 定金商品撤销收款，用户余额扣除
                        newOrderDao.updateUserMoneyByUserId(order.getPayTotalFee(), order.getUserID());
                        // 添加余额收支记录
                        CmUserBalanceRecord cmUserBalanceRecord = new CmUserBalanceRecord();
                        cmUserBalanceRecord.setType("2");
                        cmUserBalanceRecord.setBalanceType("8");
                        cmUserBalanceRecord.setAddDate(new Date());
                        cmUserBalanceRecord.setDelFlag("0");
                        cmUserBalanceRecord.setAmount(order.getPayTotalFee().toString());
                        cmUserBalanceRecord.setOrderId(order.getUserID());
                        cmUserBalanceRecord.setRemark("定金商品撤销收款");
                        cmUserBalanceRecordDao.insertUserBalanceRecord(cmUserBalanceRecord);
                    }
                }
            }
        }
        //2非订单款   没有关联订单
//		if ("2".equals(cmDiscernReceipt.getReceiptType())) {
        //do nothing
//		}
        //3返佣款
        if ("3".equals(cmDiscernReceipt.getReceiptType())) {
            // 如果返佣收款记录还在审核中 那么直接修改一下订单状态就好了
            if ("2".equals(cmDiscernReceipt.getReceiptStatus())) {
                // 如果返佣收款记录还在已经确认了 那么就去看看这笔返佣收款记录关联了那些子订单  然后撤销它们的主订单的收款状态以及付款状态
                List<String> shopOrderIDs = cmDiscernReceiptDao.findShopOrderIDs(cmDiscernReceipt.getId());
                for (String shopOrderID : shopOrderIDs) {
                    //records  查询的是 shopOrderID  这个子订单它的兄弟子订单 就是他的主订单下面除了他这个子订单 其他的子订单的返佣收款记录
                    List<String> records = cmDiscernReceiptDao.hasReceiptRecordShopOrder(shopOrderID, cmDiscernReceipt.getId()); //订单款项的收款记录
                    NewOrder order = newOrderDao.getOrderByShopOrderID(shopOrderID);
                    NewShopOrder newShopOrder = newShopOrderDao.get(shopOrderID);
                    if (CollectionUtils.isEmpty(records) && (order.getBalancePayFee() == null || order.getBalancePayFee() <= 0D)) {
                        //说明除了现在正在撤销的这一条收款记录  这个订单没有其他的收款记录  就是说 撤销以后这个订单是代付款状态
                        order.setReceiptStatus("1");
                        order.setPayStatus("1");
                        if (order.getStatus().length() == 2) {
                            order.setStatus("1" + order.getStatus().substring(1, 2));
                        }
                        if ("4".equals(order.getStatus()) || "5".equals(order.getStatus())) {
                            order.setStatus("13");
                        }
                        newShopOrder.setPayStatus("1");
                    } else {
                        //反之这个订单就是部分付款状态
                        order.setReceiptStatus("2");
                        order.setPayStatus("2");
                        if (order.getStatus().length() == 2) {
                            order.setStatus("2" + order.getStatus().substring(1, 2));
                        }
                        if ("4".equals(order.getStatus()) || "5".equals(order.getStatus())) {
                            order.setStatus("23");
                        }
                        newShopOrder.setPayStatus("2");
                    }
                    newOrderDao.update(order);
                    newShopOrderDao.update(newShopOrder);
                }
                if ("10".equals(cmDiscernReceipt.getPayType())) {
                    //是口头返佣  需要扣除供应商返佣的余额  删除返佣欠款记录
                    CmRebateRecord crr = cmRebateRecordDao.findByReceiptID(cmDiscernReceipt.getId());
                    NewCmShop newCmShop = newCmShopDao.get(crr.getShopId());
                    newCmShop.setAbleRebateAmount(newCmShop.getAbleRebateAmount() - crr.getRebateAmount());
                    newCmShop.setRebateAmount(newCmShop.getRebateAmount() - crr.getRebateAmount());
                    newCmShopDao.updateAbleRebateAmount(newCmShop);
                    cmRebateRecordDao.deleteByReceiptID(cmDiscernReceipt.getId());
                    cmDiscernReceipt.setDelFlag("1");
                }
            }
        }
        cmDiscernReceipt.setReceiptStatus("5");
        cmDiscernReceipt.setCancelReason(note);
        cmDiscernReceipt.setCancelDate(DateUtils.formatDateTime(new Date()));
        User currentUser = UserUtils.getUser();
        if (StringUtils.isNotBlank(currentUser.getId()))
            cmDiscernReceipt.setCancelUserPermissionID(Long.valueOf(currentUser.getId()));
        cmDiscernReceiptDao.update(cmDiscernReceipt);
    }

    public List<CmDiscernReceipt> export(Page<CmDiscernReceipt> page, CmDiscernReceipt cmDiscernReceipt) {
        Page<CmDiscernReceipt> result = super.findPage(page, cmDiscernReceipt);
        List<CmDiscernReceipt> list = result.getList();
        for (CmDiscernReceipt bean : list) {
            if ("1".equals(bean.getReceiptType()) || "3".equals(bean.getReceiptType())) {
                List<ReceiptExportVo> exportVo = cmDiscernReceiptDao.getExportInfo(bean.getId(), bean.getReceiptType());
                bean.setReceiptExportVo(exportVo);
            }

        }
        return list;
    }

    public List<Integer> getReceiptRecords(Integer shopOrderID) {
        return cmDiscernReceiptDao.getReceiptRecords(shopOrderID);
    }

    public List<CmMainReceiptExport> exportTest(CmDiscernReceipt cmDiscernReceipt) {
        List<CmMainReceiptExport> data = cmDiscernReceiptDao.exportTest(cmDiscernReceipt);
        return data;
    }

    public List<CmMainReceiptExport> exportRebate(CmDiscernReceipt cmDiscernReceipt) {
        List<CmMainReceiptExport> data = cmDiscernReceiptDao.exportRebate(cmDiscernReceipt);
        return data;
    }

    public List<CmReceiptExport> findShopOrder(String orderID) {
        List<CmReceiptExport> data = cmDiscernReceiptDao.findShopOrder(orderID);
        return data;
    }

    public List<CmMainReceiptExport> exportOnlyBalancePay(CmDiscernReceipt cmDiscernReceipt) {
        List<CmMainReceiptExport> data = cmDiscernReceiptDao.exportOnlyBalancePay(cmDiscernReceipt);
        return data;
    }

    public List<CmMainReceiptExport> exportReceiptPay(CmDiscernReceipt cmDiscernReceipt) {
        List<CmMainReceiptExport> data = cmDiscernReceiptDao.exportReceiptPay(cmDiscernReceipt);
        return data;
    }

    public List<CmMainReceiptExport> exportPay(CmDiscernReceipt cmDiscernReceipt) {
        List<CmMainReceiptExport> data = cmDiscernReceiptDao.exportPay(cmDiscernReceipt);
        return data;
    }

    public List<CmMainReceiptExport> exportPayData(CmDiscernReceipt cmDiscernReceipt) {
        List<CmMainReceiptExport> data = cmDiscernReceiptDao.exportPayData(cmDiscernReceipt);
        return data;
    }

    public List<CmMainReceiptExport> exportOrderDate(CmDiscernReceipt cmDiscernReceipt) {
        List<CmMainReceiptExport> data = cmDiscernReceiptDao.exportOrderDate(cmDiscernReceipt);
        return data;
    }

    public List<CmMainReceiptExport> getListOrder(CmDiscernReceipt cmDiscernReceipt) {
        List<CmMainReceiptExport> data = cmDiscernReceiptDao.getListOrder(cmDiscernReceipt);
        return data;
    }

    public List<CmMainReceiptExport> exportPayment(CmDiscernReceipt cmDiscernReceipt) {
        List<CmMainReceiptExport> data = cmDiscernReceiptDao.exportPayment(cmDiscernReceipt);
        return data;
    }

    public Double findOrderReceipt(Integer orderID) {
        Double receiptAmount = cmDiscernReceiptDao.findOrderReceipt(orderID);
        return receiptAmount;
    }

    public List<CmMainReceiptExport> gathering(Integer orderID) {
        List<CmMainReceiptExport> gathering = cmDiscernReceiptDao.gathering(orderID);
        return gathering;
    }

    public List<CmReturnedPurchase> exportRefund(CmDiscernReceipt cmDiscernReceipt) {
        List<CmReturnedPurchase> purchases = cmDiscernReceiptDao.exportRefund(cmDiscernReceipt);
        return purchases;
    }

    public List<CmMainReceiptExport> theOrder(CmDiscernReceipt cmDiscernReceipt) {
        List<CmMainReceiptExport> list = cmDiscernReceiptDao.theOrder(cmDiscernReceipt);
        return list;
    }

    public List<CmMainReceiptExport> svipReceipt(CmDiscernReceipt cmDiscernReceipt) {
        List<CmMainReceiptExport> list = cmDiscernReceiptDao.svipReceipt(cmDiscernReceipt);
        return list;
    }

    public List<CmMainReceiptExport> secondReceipt(CmDiscernReceipt cmDiscernReceipt) {
        List<CmMainReceiptExport> list = cmDiscernReceiptDao.secondReceipt(cmDiscernReceipt);
        return list;
    }
}