package com.poteviohealth.ym.ipos.controller.feign;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.google.common.collect.Lists;
import com.poteviohealth.cgp.common.controller.BaseFeignController;
import com.poteviohealth.cgp.common.integrated.ipos.model.*;
import com.poteviohealth.cgp.common.integrated.order.model.PayBefor;
import com.poteviohealth.cgp.common.integrated.order.model.PayInfoAppOutDTO;
import com.poteviohealth.cgp.common.integrated.order.model.RefundReceive;
import com.poteviohealth.cgp.common.model.VaultsResponse;
import com.poteviohealth.cgp.common.utils.CgpTool;
import com.poteviohealth.cgp.common.utils.DateUtils;
import com.poteviohealth.ym.ipos.model.payment.PaymentRecords;
import com.poteviohealth.ym.ipos.model.split.SplitRecords;
import com.poteviohealth.ym.ipos.model.split.SplitRecordsDetail;
import com.poteviohealth.ym.ipos.service.*;
import com.poteviohealth.ym.ipos.utils.YmUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import jodd.util.StringUtil;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

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

/**
 * 第三方支付
 * @author Qin
 */
@Controller
@RequestMapping("/ipos/feign")
@Api(tags = {"第三方-支付相关接口"})
public class IposFeignController extends BaseFeignController {

    @Resource
    private IPaymentRecordsService paymentRecordsService;
    @Resource
    private IPaymentService paymentService;
    @Resource
    private ISplitRecordsService splitRecordsService;
    @Resource
    private ISplitRecordsDetailService splitRecordsDetailService;
    @Resource
    private ISplitService splitService;

    @Value("${pay.field.split}")
    private String split;

    @ApiOperation(value = "第三方支付信息")
    @RequestMapping(value = "/returnPay", method = RequestMethod.POST)
    @ResponseBody
    public VaultsResponse<PayInfoAppOutDTO> returnPay(@RequestBody PayBefor payBefor){
        PaymentRecords pr = new PaymentRecords();
        pr.setPayId(CgpTool.generateKey());
        pr.setPaySn(payBefor.getPaySn());
        pr.setTxAmt(payBefor.getPrice());
        pr.setOpenid(payBefor.getOpenid());
        pr.setAppId(payBefor.getAppId());
        pr.setOperatorId(payBefor.getOperatorId());
        pr.setPlanSplitDate(DateFormatUtils.format(DateUtils.caculDays(new Date(),17),"yyyyMMdd"));
        paymentRecordsService.save(pr);

        return paymentService.unifiedOrder(pr);
    }

    @ApiOperation(value = "退款信息")
    @RequestMapping(value = "/barcodeReverse", method = RequestMethod.POST)
    @ResponseBody
    public VaultsResponse barcodeReverse(@RequestBody RefundReceive refundReceive){
         return paymentService.barcodeReverse(refundReceive);
    }

    @ApiOperation(value = "退款信息查询")
    @RequestMapping(value = "/refundQuery", method = RequestMethod.POST)
    @ResponseBody
    public VaultsResponse<List<String>> refundQuery(@RequestBody List<RefundQuery> list){
        List<String> returnList = Lists.newArrayList();
        for (RefundQuery refundQuery : list) {
           VaultsResponse vaultsResponse =  paymentService.barcodeRefundQuery(refundQuery.getTransactionId(),refundQuery.getOperatorId().toString());
           if(vaultsResponse.validate()){
               if(YmUtil.SUCCESS.equals(vaultsResponse.getData().toString())){
                   returnList.add(refundQuery.getSn());
               }
           }
        }
        return VaultsResponse.success(returnList);
    }

    @ApiOperation(value = "分账信息")
    @RequestMapping(value = "/splitOrder", method = RequestMethod.POST)
    @ResponseBody
    public VaultsResponse<List<SplitPay>> splitOrder(@RequestBody List<SplitInfo> list) {

        List<SplitPay> returnList = Lists.newArrayList();
        for (SplitInfo splitInfo : list) {
            //List<SplitRecords> splitRecordsList = Lists.newArrayList();
           PaymentRecords pr = paymentRecordsService.getPaymentRecords(splitInfo.getPayId());
           if(pr == null){
               continue;
           }
            List<SplitRecordsDetail> details = Lists.newArrayList();
            SplitRecords records = new SplitRecords();
            records.setOperatorId(splitInfo.getOperatorId());
            records.setSplitId(CgpTool.generateKey());
            records.setPayId(splitInfo.getPayId());
            records.setPaySn(splitInfo.getPaySn());
            records.setSumPrice(splitInfo.getSumPrice());
            //平台分成
            SplitRecordsDetail pt = new SplitRecordsDetail();
            pt.setSplitId(records.getSplitId());
            pt.setSourceId(0);
            BigDecimal chargeAmount = new BigDecimal(pr.getChargeAmount());
            BigDecimal ptAmount = BigDecimal.ZERO;
            BigDecimal tzAmount = BigDecimal.ZERO;
            BigDecimal ptyysAmount = BigDecimal.ZERO;
            BigDecimal supplierOneAmount = BigDecimal.ZERO;
            BigDecimal supplierTwoAmount = BigDecimal.ZERO;
            BigDecimal supplierAmount = BigDecimal.ZERO;
            //团长分成
            SplitRecordsDetail tz = new SplitRecordsDetail();
            tz.setSplitId(records.getSplitId());
            tz.setSourceId(3);

            for (SplitDetail detail : splitInfo.getDetails()) {
                SplitPay sp = new SplitPay();
                sp.setOrderId(detail.getOrderId());
                sp.setSplitId(records.getSplitId());
                //运算价格
                BigDecimal price = new BigDecimal(detail.getPrice()).subtract(chargeAmount);

                //平台金额
                BigDecimal ptDecimal = new BigDecimal(split).multiply(price).setScale(0,BigDecimal.ROUND_DOWN);
                BigDecimal valDecimal = new BigDecimal("1");
                if(ptDecimal.longValue() > 0){
                    valDecimal = new BigDecimal(ptDecimal.longValue());
                }
                price = price.subtract(valDecimal);
                ptAmount = ptAmount.add(valDecimal);
                detail.setPrice(price.longValue());
                returnList.add(sp);
            }
            pt.setDivAmt(String.valueOf(ptAmount.longValue()));
            details.add(pt);


            //一级供应商
            Map<String, List<SplitDetail>> oneMaps = splitInfo.getDetails().stream().filter(s -> StringUtils.isNotEmpty(s.getSupplierOneMerchantId()) && s.getBelong().equals(1)).collect(Collectors.groupingBy(SplitDetail::getSupplierOneMerchantId));

            for (String s : oneMaps.keySet()) {
                SplitRecordsDetail supplierOne = new SplitRecordsDetail();
                supplierOne.setSplitId(records.getSplitId());
                supplierOne.setSourceId(2);
                supplierOne.setMerchantId(s);
                for (SplitDetail detail : oneMaps.get(s)) {
                    supplierOneAmount = supplierOneAmount.add(new BigDecimal(detail.getConsignmentPrice()));
                    detail.setPrice(new BigDecimal(detail.getPrice()).subtract(new BigDecimal(detail.getConsignmentPrice())).longValue());
                }

                if (supplierOneAmount.compareTo(BigDecimal.ZERO) == 1) {
                    supplierOne.setDivAmt(String.valueOf(supplierOneAmount.longValue()));
                    details.add(supplierOne);
                }
            }

            //二级供应商
            Map<String, List<SplitDetail>> twoMaps = splitInfo.getDetails().stream().filter(s -> StringUtils.isNotEmpty(s.getServiceStationMerchantId()) && s.getBelong().equals(2)).collect(Collectors.groupingBy(SplitDetail::getServiceStationMerchantId));

            for (String s : twoMaps.keySet()) {
                SplitRecordsDetail supplierTwo = new SplitRecordsDetail();
                supplierTwo.setSplitId(records.getSplitId());
                supplierTwo.setSourceId(2);
                supplierTwo.setMerchantId(s);
                for (SplitDetail detail : twoMaps.get(s)) {
                    supplierTwoAmount = supplierTwoAmount.add(new BigDecimal(detail.getConsignmentPrice()));
                    detail.setPrice(detail.getPrice() - detail.getConsignmentPrice());
                }

                if (supplierTwoAmount.compareTo(BigDecimal.ZERO) == 1) {
                    supplierTwo.setDivAmt(String.valueOf(supplierTwoAmount.longValue()));
                    details.add(supplierTwo);
                }
            }

            //供应商
            Map<String, List<SplitDetail>> maps = splitInfo.getDetails().stream().filter(s -> StringUtils.isNotEmpty(s.getSupplierMerchantId()) && s.getBelong().equals(0)).collect(Collectors.groupingBy(SplitDetail::getSupplierMerchantId));

            for (String s : maps.keySet()) {
                SplitRecordsDetail supplier = new SplitRecordsDetail();
                supplier.setSplitId(records.getSplitId());
                supplier.setSourceId(2);
                supplier.setMerchantId(s);
                for (SplitDetail detail : maps.get(s)) {
                    supplierAmount = supplierAmount.add(new BigDecimal(detail.getSettlementPrice()));
                    detail.setPrice(new BigDecimal(detail.getPrice()).subtract(new BigDecimal(detail.getSettlementPrice())).longValue());
                   // detail.setPrice(detail.getPrice() - detail.getSettlementPrice());
                }

                if (supplierAmount.compareTo(BigDecimal.ZERO) == 1) {
                    supplier.setDivAmt(String.valueOf(supplierAmount.longValue()));
                    details.add(supplier);
                }
            }

            for (SplitDetail detail : splitInfo.getDetails()) {
                //团长金额
                if (StringUtil.isNotEmpty(detail.getGroupLeaderMerchantId())) {
                    tz.setMerchantId(detail.getGroupLeaderMerchantId());
                    BigDecimal tbd = detail.getGroupCommission().multiply(new BigDecimal(detail.getPrice()));
                    detail.setPrice(detail.getPrice()-tbd.longValue());
                    tzAmount = tzAmount.add(tbd);
                }
            }
            if (tzAmount.compareTo(BigDecimal.ZERO) == 1) {
                tz.setDivAmt(String.valueOf(tzAmount.longValue()));
                details.add(tz);
            }


            //平台运营商
            SplitRecordsDetail ptyys = new SplitRecordsDetail();
            ptyys.setSplitId(records.getSplitId());
            ptyys.setSourceId(1);
            for (SplitDetail detail : splitInfo.getDetails()) {
                ptyysAmount = ptyysAmount.add(new BigDecimal(detail.getPrice()));
            }
            ptyys.setMerchantId(splitInfo.getOperatorMerchantId());
            ptyys.setDivAmt(String.valueOf(ptyysAmount.longValue()));
            details.add(ptyys);
            VaultsResponse vaultsResponse = splitService.delayConfirm(records,details);
            if(!vaultsResponse.validate()){
                records.setComment(vaultsResponse.getMessage());
            }
            records.setStatus(2);
            //splitRecordsList.add(records);
            splitRecordsService.save(records);
            splitRecordsDetailService.saveBatch(details);
        }

        return VaultsResponse.success(returnList);
    }

    @ApiOperation(value = "延时交易确认查询")
    @RequestMapping(value = "/delayConfirmQuery", method = RequestMethod.POST)
    @ResponseBody
    public VaultsResponse<List<DelayConfirmQuery>> delayConfirmQuery(@RequestBody List<DelayConfirmQuery> list){

        for (DelayConfirmQuery dcfq : list) {
            VaultsResponse vaultsResponse =  splitService.delayConfirmQuery(dcfq.getSplitId().toString(),dcfq.getOperatorId().toString());
            if(vaultsResponse.validate()){
                dcfq.setStatus(1);
            }
            SplitRecords splitRecords = new SplitRecords();
            splitRecords.setStatus(1);
            QueryWrapper<SplitRecords> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("split_id",dcfq.getSplitId());
            splitRecordsService.update(splitRecords,queryWrapper);
        }
        return VaultsResponse.success(list);
    }
}