package com.zteits.ipay.biz;

import org.apache.commons.collections4.CollectionUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.clouds.common.utils.ListCopyUtil;
import com.zteits.clouds.api.apibase.bean.BizResult;
import com.zteits.clouds.api.apibase.constants.ErrorType;
import com.zteits.clouds.api.apibase.constants.PayOrderTypeEnum;
import com.zteits.clouds.api.apibase.constants.PayTypeEnum;
import com.zteits.clouds.api.apibase.constants.TerminalSourceEnum;
import com.zteits.clouds.api.apibase.exception.BizException;
import com.zteits.clouds.api.dto.clouds.param.PayOrderSuccessMsgRequest;
import com.zteits.clouds.api.dto.order.etc.dto.OrderEtcDTO;
import com.zteits.clouds.api.dto.order.etc.param.EtcNotifyReq;
import com.zteits.clouds.api.dto.order.etc.param.EtcQueryReq;
import com.zteits.clouds.api.dto.order.payorder.dto.PayOrderDTO;
import com.zteits.clouds.api.dto.pay.AliWxinPayNotifyDTO;
import com.zteits.clouds.api.dto.pay.param.AliPayNotifyRequest;
import com.zteits.clouds.api.dto.pay.param.AliWeixinPayOrderCreateRequest;
import com.zteits.clouds.api.dto.pay.param.EtcUpdatePayOrderRequest;
import com.zteits.clouds.api.dto.pda.param.ArrearageRecordInfo;
import com.zteits.clouds.api.dto.rocketmq.order.payorder.PayOrderSuccess;
import com.zteits.clouds.api.service.order.pay.EtcPayService;
import com.zteits.ipay.service.apppubpay.aliwxinpay.base.AliWxinPayInnerRouteService;
import com.zteits.ipay.service.apppubpay.busigroup.PubBusiPayInnerService;
import com.zteits.ipay.service.apppubpay.busigroup.base.BusiPayServiceBeanName;
import com.zteits.ipay.service.apppubpay.busigroup.base.PubBusiInnerRouteService;
import com.zteits.order.dao.backorder.BackDetailOrderDao;
import com.zteits.order.dao.orderetc.OrderEtcDao;
import com.zteits.order.dao.parkorder.OrderParkDao;
import com.zteits.order.dao.payorder.PayOrderDao;
import com.zteits.order.domain.OrderBackDetail;
import com.zteits.order.domain.OrderEtc;
import com.zteits.order.domain.OrderPark;
import com.zteits.order.domain.PayOrder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * <p>
 * Copyright: Copyright (c) 2018 zteits
 * ETC 支付相关服务
 *
 * @ClassName: EtcPayServiceImpl
 * @Description:
 * @version: v1.0.0
 * @author: zengqc
 * @date: 2020-06-03 11:11
 */
@Service("com.zteits.ipay.biz.EtcPayServiceImpl")
public class EtcPayServiceImpl implements EtcPayService {

    private static final Logger logger = LoggerFactory.getLogger(EtcPayServiceImpl.class);

    @Autowired
    private PubBusiInnerRouteService busiInnerRouteService;

    @Autowired
    private PushPaySuccessMsgService pushPaySuccessMsgService;

    @Autowired
    private AliWxinPayInnerRouteService aliWxinPayInnerRouteService;
    @Autowired
    private PayOrderDao payOrderDao;

    @Autowired
    private OrderEtcDao orderEtcDao;

    @Autowired
    private BackDetailOrderDao backDetailOrderDao;

    @Autowired
    private OrderParkDao orderParkDao;

    @Resource(name = BusiPayServiceBeanName.BackArrearageOrderPayInnerService)
    private PubBusiPayInnerService backArrearageOrderPayInnerService;

    /**
     * 支付异步回调
     *
     * @return
     * @throws Exception
     */
    @Override
    public BizResult<Boolean> payNotify(AliPayNotifyRequest request) throws Exception {

        /**验证参数，获取相关支付信息*/
        AliWxinPayNotifyDTO aliWxinPayNotifyDTO = aliWxinPayInnerRouteService.getRealService(request.getPayType()).getPayInfoByPayNotify(request);

        if (aliWxinPayNotifyDTO.getIsRepetData() != null && aliWxinPayNotifyDTO.getIsRepetData()) {
            /**重复数据，已经处理成功了*/
            return new BizResult<Boolean>(true);
        }
        /**支付成功，处理相关的业务逻辑*/
        PayOrderDTO payOrder = busiInnerRouteService.getRealServiceByPassBackParams(aliWxinPayNotifyDTO.getPassback_params()).payNotifyDeal(aliWxinPayNotifyDTO);
        pushPaySuccessMsgService.sendPaySuccessMsg(Collections.singletonList(payOrder));
        return new BizResult<Boolean>(true);
    }

    /**
     * 根据 支付订单ID，更新ETC的运营方编号到appId
     *
     * @param request
     * @return
     */
    @Override
    public BizResult<Boolean> updateEtcPayOrderAppId(EtcUpdatePayOrderRequest request) {
        PayOrder payOrder = new PayOrder();
        payOrder.setAppId(request.getEtcAppId());
        payOrder.setPayOrderId(request.getPayOrderId());
        int count = payOrderDao.updatePayOrderAppIdByPayOrderId(payOrder);
        return new BizResult<>(count == 1);
    }

    /**
     * 向ETC平台撤销追缴订单，因为车主已经通过其他方式补缴成功，所以要撤销这笔ETC追缴订单
     *
     * @param payOrderSuccessMsg
     * @return
     */
    @Override
    public BizResult<Boolean> undoEtcOrder(PayOrderSuccessMsgRequest payOrderSuccessMsg) {

        for (PayOrderSuccess order : payOrderSuccessMsg.getPayOrderSuccessList()) {
            // 欠费补交订单通过非ETC方式补交成功后，从德亚ETC平台撤销订单
            if (PayOrderTypeEnum.PARKBACK_PAY.value().equals(order.getPayOrderType())) {
                // 1、通过 RltOrderId 对应 欠费订单表 order_back 的orderID
                // 2、通过 orderID 找到 欠费补交明细 order_back_detail 的 rlt_order_id（批量补交对应多个）
                List<OrderBackDetail> backDetails = backDetailOrderDao.queryByOrderId(order.getRltOrderId());
                for (OrderBackDetail orderBackDetail : backDetails) {
                    // 3、查询该订单号之前有没有提交德亚追缴平台
                    List<OrderEtc> orderEtcs = orderEtcDao.getOrderEtcList(orderBackDetail.getRltOrderId(), 1);
                    if (orderEtcs.size() == 0) {
                        continue;
                    }
                    OrderEtcDTO orderEtcDTO = new OrderEtcDTO();
                    orderEtcDTO.setParkSerNo(orderBackDetail.getRltOrderId());
                    orderEtcDTO.setVehplateNo(orderBackDetail.getCarNumber());
                    orderEtcDTO.setEntryTime(orderBackDetail.getParkInTime());
                    orderEtcDTO.setOutTime(orderBackDetail.getParkOutTime());
                    orderEtcDTO.setBillAmount(orderBackDetail.getBackActFee());
                    orderEtcDTO.setParkingTime(orderBackDetail.getParkingDuration());
                    orderEtcDTO.setBatchUndo(1);
                    // 4、通过 rlt_order_id 撤销 ETC追缴订单
                    logger.info("撤销通行宝ETC订单: {}", JSONObject.toJSONString(orderEtcs));
                    OrderEtc orderEtc = new OrderEtc();
                    BeanUtils.copyProperties(orderEtcDTO, orderEtc);
                    orderEtc.setUndoRemarks("该订单已经支付,撤销订单信息");
                    // 5、撤销ETC追缴
                    orderEtcDao.updateEtcOrderStatus(orderBackDetail.getRltOrderId(), orderEtc);
                }
            }
        }
        return new BizResult<>(true);
    }

    /**
     * ETC欠费补交扣款成功通知
     *
     * @return
     */
    @Override
    public BizResult<Boolean> arrearsPayNotify(EtcNotifyReq req) {
        try {
            String orderId = req.getParkSerNo();
            OrderPark orderPark = orderParkDao.queryOrderParkByOrderId(orderId);
            if (orderPark == null) {
                logger.info("ETC追缴订单在order_park表中不存在, orderId: {}", orderId);
                throw new BizException(ErrorType.BIZ_ERROR, "订单有问题");
            }
            AliWeixinPayOrderCreateRequest request = new AliWeixinPayOrderCreateRequest();
            request.setPaySrcType(String.valueOf(PayOrderTypeEnum.PARKBACK_PAY.value()));
            request.setCarNumber(orderPark.getCarNumber());
            request.setCustId("");
            request.setsOpName(null);
            request.setsOpId(null);
            request.setBackType(2);
            request.setTerminalSource(String.valueOf(TerminalSourceEnum.ETC.value()));
            request.setPayType(String.valueOf(PayTypeEnum.ETC_PAY.getValue()));
            request.setBackDeveloperCode("");
            request.setBackDeveloperName("");
            ArrearageRecordInfo arrearageRecordInfo = new ArrearageRecordInfo();
            arrearageRecordInfo.setOrderId(orderId);
            arrearageRecordInfo.setOrderNotPayFee(orderPark.getArrearageFee());
            arrearageRecordInfo.setParkId(orderPark.getPlNo());
            List<ArrearageRecordInfo> list = Collections.singletonList(arrearageRecordInfo);
            String recordInfo = JSON.toJSONString(list);
            request.setRecordArreaInfos(recordInfo);
            logger.info("ETC扣费成功，{}", JSONObject.toJSONString(req));
            PayOrder payOrder = backArrearageOrderPayInnerService.createBackOrderAndPayOrderForETCArrears(request, orderPark);
            // 追缴成功记录状态
            OrderEtc orderEtc = new OrderEtc();
            orderEtc.setStatus(5);
            orderEtcDao.updateEtcOrderStatus(orderId, orderEtc);
            return new BizResult<Boolean>(true);
        } catch (Exception e) {
            logger.error(e.getMessage());
            throw new BizException(ErrorType.BIZ_ERROR, e.getMessage());
        }

    }


    /**
     * 查询具备ETC追缴条件，但还没有追缴成功的订单
     *
     * @param req
     * @return
     */
    @Override
    public BizResult<List<OrderEtcDTO>> getSubmitSuccessEtcOrder(EtcQueryReq req) {
        List<OrderEtc> list = orderEtcDao.getSubmitSuccessEtcOrder(req);
        List<OrderEtcDTO> dtoList = new ArrayList<>();
        if(!CollectionUtils.isEmpty(list)) {
            ListCopyUtil.listCopyProperties(list, dtoList, OrderEtcDTO.class);
        }
        return new BizResult<List<OrderEtcDTO>>(dtoList);
    }

}