package com.zteits.ipay.biz;

import java.util.Date;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;
import com.alibaba.fastjson.JSONObject;

import com.clouds.common.utils.DateUtil;
import com.clouds.common.utils.ResultUtils;
import com.clouds.common.utils.SequenceUtil;
import com.xiaoleilu.hutool.util.BeanUtil;
import com.xiaoleilu.hutool.util.CollectionUtil;
import com.zteits.clouds.api.apibase.bean.BizResult;
import com.zteits.clouds.api.apibase.constants.AccountTypeEnum;
import com.zteits.clouds.api.apibase.constants.AuditorStatusEnum;
import com.zteits.clouds.api.apibase.constants.BasicEnum;
import com.zteits.clouds.api.apibase.constants.DataStatusEnum;
import com.zteits.clouds.api.apibase.constants.ErrorType;
import com.zteits.clouds.api.apibase.constants.OrderBigTypeEnum;
import com.zteits.clouds.api.apibase.constants.OrderStateEnum;
import com.zteits.clouds.api.apibase.constants.PayOrderTypeEnum;
import com.zteits.clouds.api.apibase.constants.PayTypeEnum;
import com.zteits.clouds.api.apibase.constants.SequenceTypeEnum;
import com.zteits.clouds.api.apibase.exception.BizException;
import com.zteits.clouds.api.dto.order.refundorder.dto.OrderRefundDTO;
import com.zteits.clouds.api.dto.order.refundorder.dto.OrderRefundReturnFeeDTO;
import com.zteits.clouds.api.dto.order.refundorder.param.OrderRefundRqeuest;
import com.zteits.clouds.api.dto.order.refundorder.param.RefundRqeuest;
import com.zteits.clouds.api.dto.order.refundorder.param.SaveOrUpdateOrderRefundReq;
import com.zteits.clouds.api.dto.pay.AcctSourceDTO;
import com.zteits.clouds.api.dto.pay.param.AcctPersonRequest;
import com.zteits.clouds.api.dto.pay.param.AcctSourceRequest;
import com.zteits.clouds.api.service.order.refundorder.oper.RefundService;
import com.zteits.clouds.api.service.pay.TdCAcctPayoutService;
import com.zteits.clouds.api.service.pay.TdCAcctPersonService;
import com.zteits.clouds.api.service.pay.TdCAcctSourceService;
import com.zteits.order.biz.refundorder.inner.OrderRefundReturnFeeService;
import com.zteits.order.dao.backorder.BackDetailOrderDao;
import com.zteits.order.dao.parkorder.OrderParkDao;
import com.zteits.order.dao.payorder.PayOrderDao;
import com.zteits.order.dao.refundorder.OrderRefundDao;
import com.zteits.order.domain.OrderRefund;
import com.zteits.order.domain.PayOrder;
import com.zteits.order.util.OrderRefundRouteUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service("com.zteits.ipay.biz.RefundServiceIpml")
public class RefundServiceIpml implements RefundService {

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

    @Autowired
    private OrderParkDao orderParkDao;
    @Autowired
    private TdCAcctSourceService tdCAcctSourceService;

    @Autowired
    private TdCAcctPersonService tdCAcctPersonService;

    @Autowired
    private TdCAcctPayoutService tdCAcctPayoutService;

    @Autowired
    private OrderRefundDao orderRefundDao;

    @Autowired
    private PayOrderDao payOrderDao;

    @Autowired
    private BackDetailOrderDao backDetailOrderDao;
    @Autowired
    private Map<String, OrderRefundReturnFeeService> orderRefundReturnFeeMapService;

    @Value("${wx.cert.name}")
    private String WX_CERT_NAME;
    @Value("${wx.cert.pass}")
    private String WX_CERT_PASS;

    /**
     * 支付宝返回成功标志.
     */
    public static final String ALI_RESPONSE_MSG = "Success";

    @Override
    public BizResult<OrderRefundDTO> saveRefund(RefundRqeuest data) {

        OrderRefundDTO orderRefundDTO = new OrderRefundDTO();
        /**押金充值退款**/
        if (data.getPayOrderType().equals(PayOrderTypeEnum.DEPOSIT_PAY.value())) {
            this.accRefund(data, orderRefundDTO);
        }
        return new BizResult<OrderRefundDTO>(orderRefundDTO);
    }

    private void accRefund(RefundRqeuest data, OrderRefundDTO orderRefundDTO) {
        AcctSourceRequest acctSourceRequest = new AcctSourceRequest();
        acctSourceRequest.setCustId(data.getCustId());
        acctSourceRequest.setAcctType(AccountTypeEnum.ACCT_DEPOSIT.value());
        acctSourceRequest.setSysCode(BasicEnum.SYS_CODE.getValue());
        BizResult<List<AcctSourceDTO>> acctSourceDOList = tdCAcctSourceService.queryAcctSource(acctSourceRequest);
        //更改押金账户的状态
        AcctPersonRequest request = new AcctPersonRequest();
        request.setDataState(2);
        request.setCustId(data.getCustId());
        request.setAcctType(AccountTypeEnum.ACCT_DEPOSIT.value());
        request.setOrgId(orderRefundDTO.getOrgId());
        request.setSysCode(BasicEnum.SYS_CODE.getValue());
        tdCAcctPersonService.updateAcctPerson(request);
        if (acctSourceDOList.isSuccess() && CollectionUtil.isNotEmpty(acctSourceDOList.getData())) {
            AcctSourceDTO acctSource = acctSourceDOList.getData().get(0);
            PayOrder payOrder = payOrderDao.queryPayOrderByPayOrderId(acctSource.getRltPayorderId());

            OrderRefund orderRefund = new OrderRefund();
            orderRefund.setOrderId(SequenceUtil.getNextId(SequenceTypeEnum.ORDER_ACC_DEPOSIT));
            orderRefund.setOrderBigType(data.getOrderBigType());
            orderRefund.setPayOrderType(data.getPayOrderType());
            orderRefund.setRltOrderId(payOrder.getRltOrderId());
            orderRefund.setRltPayOrderId(payOrder.getPayOrderId());
            orderRefund.setOrderState(OrderStateEnum.WAIT_REFUND.value());
            orderRefund.setRefundTotalFee(acctSource.getRechargeFee().longValue());
            orderRefund.setTerminalSource(data.getTerminalSource());
            orderRefund.setPayType(payOrder.getPayType());
            orderRefund.setOrderDicountFee(payOrder.getOrderDicountFee());
            orderRefund.setOrderActFee(payOrder.getOrderActFee());
            orderRefund.setOrderTotalFee(payOrder.getOrderTotalFee());
            orderRefund.setPayFinishTime(payOrder.getPayFinishTime());
            orderRefund.setPlNo(payOrder.getPlNo());
            orderRefund.setRefundReason(data.getRefundReason());
            orderRefund.setAppId(payOrder.getAppId());
            orderRefund.setAuditState(AuditorStatusEnum.AUDITOR_STATUS_AUDIT_PASS.value());
            orderRefund.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
            orderRefund.setCustId(data.getCustId());
            orderRefund.setCreateEmpId(data.getCustId());
            orderRefund.setCreateDate(DateUtil.getSysDate());
            orderRefund.setModfiyDate(DateUtil.getSysDate());
            orderRefundDao.saveOrderRefund(orderRefund);
            BeanUtil.copyProperties(orderRefund, orderRefundDTO);
        }
    }

    @Override
    //@Transactional(rollbackFor = Exception.class)
    public BizResult<OrderRefundReturnFeeDTO> refund(OrderRefundRqeuest orderRefundRqeuest) {
        BizResult<OrderRefundReturnFeeDTO> result = new BizResult<OrderRefundReturnFeeDTO>();
        OrderRefundReturnFeeService orderRefundReturnFeeService = null;
        if (orderRefundRqeuest == null) {
            throw new BizException(ErrorType.PARAMM_NULL, "根据入参未获取到支付单单!");
        }
        /**微信退款**/
        if (orderRefundRqeuest.getPayType() == PayTypeEnum.WX.getValue()
            || orderRefundRqeuest.getPayType() == PayTypeEnum.WXPUBLIC.getValue()
            || orderRefundRqeuest.getPayType() == PayTypeEnum.WXAPPLETS.getValue()) {
            orderRefundReturnFeeService = orderRefundReturnFeeMapService.get(
                OrderRefundRouteUtils.wxOrderRefundReturnFeeServiceImpl);
            /**支付宝退款**/
        } else if (orderRefundRqeuest.getPayType() == PayTypeEnum.ZFB.getValue()) {
            orderRefundReturnFeeService = orderRefundReturnFeeMapService.get(
                OrderRefundRouteUtils.aliOrderRefundReturnFeeServiceImpl);
            /**现金退款**/
        } else if (orderRefundRqeuest.getPayType() == PayTypeEnum.XIANJIN.getValue()) {
            orderRefundReturnFeeService = orderRefundReturnFeeMapService.get(
                OrderRefundRouteUtils.balanceAndCashRefundServiceImpl);
            /**个人账户退款 **/
        } else if (orderRefundRqeuest.getPayType() == PayTypeEnum.ZH.getValue()) {
            orderRefundReturnFeeService = orderRefundReturnFeeMapService.get(
                OrderRefundRouteUtils.balanceAndCashRefundServiceImpl);
            /**充电卡账户退款 **/
        } else if (orderRefundRqeuest.getPayType() == PayTypeEnum.CDKZF_PAY.getValue()) {
            orderRefundReturnFeeService = orderRefundReturnFeeMapService.get(
                OrderRefundRouteUtils.balanceAndCashRefundServiceImpl);
            /**农行支付退款 **/
        } else if (orderRefundRqeuest.getPayType() == PayTypeEnum.ABC_BANK_PAY.getValue()) {
            orderRefundReturnFeeService = orderRefundReturnFeeMapService.get(
                OrderRefundRouteUtils.abcOrderRefundReturnFeeServiceImpl);

        }
        OrderRefund orderRefund = new OrderRefund();
        orderRefund.setOrderId(orderRefundRqeuest.getOrderId());
        orderRefund.setErrorCode(ErrorType.BIZ_SUCCESS.getCode());
        orderRefund.setErrorMsg("退款成功!");
        orderRefund.setOrderState(OrderStateEnum.REFUND_SUCCESS.value());
        if (null != orderRefundReturnFeeService) {
            try {
                /**发起调用*/
                result = orderRefundReturnFeeService.orderRefunReturnFee(orderRefundRqeuest);
                OrderRefundReturnFeeDTO dto = ResultUtils.getBizResultData(result);
                orderRefund.setRefundActFee(dto.getRefundActFee());
            } catch (BizException bizE) {
                logger.error("发起退款发生异常!", bizE);
                orderRefund.setErrorCode(bizE.getErrCode().getCode());
                orderRefund.setErrorMsg(bizE.getErrMsg());
                orderRefund.setOrderState(OrderStateEnum.ALL_REFUND_FAIL.value());

            } catch (Exception e) {
                logger.error("发起退款发生异常!", e);
                orderRefund.setErrorCode(ErrorType.APP_ERROR.getCode());
                orderRefund.setErrorMsg("发生应用异常");
                orderRefund.setOrderState(OrderStateEnum.ALL_REFUND_FAIL.value());
            }
        }

        if (PayTypeEnum.ZH.getValue().equals(orderRefundRqeuest.getPayType())
                || PayTypeEnum.XIANJIN.getValue().equals(orderRefundRqeuest.getPayType())
                || PayTypeEnum.CDKZF_PAY.getValue().equals(orderRefundRqeuest.getPayType())) {
            /** 更新退款单的退款状态信息*/
            orderRefund.setRefundFinishTime(new Date());
            orderRefundDao.updateOrderRefundByOrderId(orderRefund);
        }
        return result;
    }

    /**
     * 保存、修改 Order_Refund表.<br/>
     */
    @Override
    public BizResult<Boolean> saveOrUpdateOrderRefund(SaveOrUpdateOrderRefundReq request) {
        logger.info("---begin保存、更新退款订单管理,入参={}", JSONObject.toJSON(request));
        if (StringUtils.isEmpty(request.getRltOrderId())) {
            throw new BizException(ErrorType.PARAMM_NULL, "订单Id不能为空");
        }
        if (StringUtils.isEmpty(request.getRltPayOrderId())) {
            throw new BizException(ErrorType.PARAMM_NULL, "支付单Id不能为空");
        }
        PayOrder payOrder = payOrderDao.queryPayOrderByPayOrderId(request.getRltPayOrderId());
        int count = 0;
        OrderRefund record = new OrderRefund();
        BeanUtil.copyProperties(request, record);
        //保存
        if (null != request && request.getSaveOrUpdateFlg().equals(1)) {
            //封装退款对象
            if (payOrder != null) {
                record.setAppId(payOrder.getAppId());
                record.setOrderActFee(payOrder.getOrderActFee());
                record.setTerminalSource(payOrder.getTerminalSource());
                record.setOrderTotalFee(payOrder.getOrderTotalFee());
                record.setOrderDicountFee(payOrder.getOrderDicountFee());
                record.setOrgId(payOrder.getOrgId());
                record.setOrgName(payOrder.getOrgName());
                record.setPlNo(payOrder.getPlNo());
                record.setPayFinishTime(payOrder.getPayFinishTime());
                record.setPayType(payOrder.getPayType());
                record.setOrderBigType(payOrder.getOrderBigType());
                record.setPayOrderType(payOrder.getPayOrderType());
            }
            record.setOrderId(SequenceUtil.getNextId(SequenceTypeEnum.ORDER_REFUND));
            if (null == record.getOrderBigType()) {
                record.setOrderBigType(OrderBigTypeEnum.PARK_ORDER.value());
            }
            record.setOrderState(OrderStateEnum.WAIT_REFUND.value());
            record.setRefundActFee(0L);
            record.setTryNum(0);
            record.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
            record.setRefundReason(request.getRefundReason());
            record.setAuditState(AuditorStatusEnum.AUDITOR_STATUS_AUDIT_PASS.value());
            record.setCreateDate(new Date());
            record.setCreateEmpId(request.getsOpId() + "");
            record.setCreateEmpName(request.getsOpName());
            //平台费
            record.setPlatformServiceFee(0L);
            count = orderRefundDao.saveOrderRefund(record);
        } else {//修改
            record.setModfiyDate(new Date());
            record.setModfiyEmpId(request.getsOpId() + "");
            record.setModfiyEmpName(request.getsOpName());
            count = orderRefundDao.updateOrderRefundByPayOrderId(record);
        }
        logger.info("---end保存、更新退款订单管理,成功保存【{}】条。", count);
        return new BizResult<Boolean>(count > 0);
    }

}