package com.poteviohealth.ym.ipos.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.google.common.collect.Lists;
import com.poteviohealth.cgp.common.filter.TokenContext;
import com.poteviohealth.cgp.common.integrated.LongParams;
import com.poteviohealth.cgp.common.integrated.order.OrderFeignClient;
import com.poteviohealth.cgp.common.model.VaultsResponse;
import com.poteviohealth.cgp.common.utils.CgpTool;
import com.poteviohealth.ym.ipos.common.Basic;
import com.poteviohealth.ym.ipos.model.BasicConfiguration;
import com.poteviohealth.ym.ipos.model.back.BaseBack;
import com.poteviohealth.ym.ipos.model.payment.PayRefundQuery;
import com.poteviohealth.ym.ipos.model.split.*;
import com.poteviohealth.ym.ipos.model.split.back.*;
import com.poteviohealth.ym.ipos.model.split.detail.*;
import com.poteviohealth.ym.ipos.model.split.dto.WithdrawDto;
import com.poteviohealth.ym.ipos.service.ISplitRecordsDetailService;
import com.poteviohealth.ym.ipos.service.ISplitRecordsService;
import com.poteviohealth.ym.ipos.service.ISplitService;
import com.poteviohealth.ym.ipos.service.ISplitWithdrawService;
import com.poteviohealth.ym.ipos.utils.YmUtil;
import lombok.extern.log4j.Log4j2;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

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

/**
 * 分账
 * @author Qin
 */
@Service
@Log4j2
public class SplitServiceImpl implements ISplitService {

    @Value("${pay.field.url}")
    private String url;
    @Resource
    private ISplitRecordsService splitRecordsService;
    @Resource
    private ISplitRecordsDetailService splitRecordsDetailService;
    @Resource
    private ISplitWithdrawService splitWithdrawService;
    @Resource
    private OrderFeignClient orderFeignClient;

    @Override
    public VaultsResponse delayConfirm(SplitRecords records, List<SplitRecordsDetail> details) {
        BasicConfiguration basicConfig = Basic.getSystemParameter(records.getOperatorId());
        PayConfirm payConfirm = new PayConfirm();
        payConfirm.setPos_id(basicConfig.getCode());
        payConfirm.setSystem_id(basicConfig.getSystemId());
        payConfirm.setIsspid(basicConfig.getPid());
        payConfirm.setPos_seq(records.getSplitId().toString());
        payConfirm.setStore_id(records.getOperatorId().toString());
        PayConfirmDetail detail = new PayConfirmDetail();
        detail.setOrg_pos_seq(records.getPayId().toString());
        detail.setNotify_url(url+"/delayConfirmNotify");
        ExtendParamsConfirm extendParamsConfirm = new ExtendParamsConfirm();
        SplitInfoConfirm splitInfoConfirm = new SplitInfoConfirm();
        List<SplitListConfirm> list = Lists.newArrayList();
        String amt = "";
        for (SplitRecordsDetail recordsDetail : details) {
            if(recordsDetail.getSourceId().equals(0)){
                amt = recordsDetail.getDivAmt();
                continue;
            }
            SplitListConfirm slc = new SplitListConfirm();
            slc.setMerchant_id(recordsDetail.getMerchantId());
            slc.setDiv_amt(recordsDetail.getDivAmt());
            if(!slc.getDiv_amt().equals("0")){
                list.add(slc);
            }
        }

        splitInfoConfirm.setKeep_amt(amt);
        splitInfoConfirm.setSplit_list(list);
        extendParamsConfirm.setSplit_info(splitInfoConfirm);
        detail.setExtend_params(extendParamsConfirm);
        payConfirm.setDelay_confirm_request(detail);

        PayConfirmBack back = null;
        try {
            back = (PayConfirmBack) YmUtil.resultBack(payConfirm,new PayConfirmBack());
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            return VaultsResponse.failed(e.getMessage());
        }

        if(YmUtil.SUCCESS.equals(back.getResult().getId()) || YmUtil.FAIL.equals(back.getResult().getId())){
            return VaultsResponse.success(back.getResult().getId());
        }

        return VaultsResponse.failed(back.getResult().getComment());
    }

    @Override
    public VaultsResponse delayConfirmQuery(String splitId,String operatorId) {
        BasicConfiguration basicConfig = Basic.getSystemParameter(Integer.parseInt(operatorId));
        PayConfirmQuery paymentQuery =  new PayConfirmQuery();
        paymentQuery.setPos_id(basicConfig.getCode());
        paymentQuery.setSystem_id(basicConfig.getSystemId());
        paymentQuery.setIsspid(basicConfig.getPid());
        paymentQuery.setStore_id(operatorId);
        DelayConfirmQueryRequest detail = new DelayConfirmQueryRequest();
        detail.setOrg_pos_seq(splitId);
        paymentQuery.setDelay_confirmquery_request(detail);
        PayConfirmQueryBack back = null;
        try {
            back = (PayConfirmQueryBack) YmUtil.resultBack(paymentQuery,new PayConfirmQueryBack());
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            return VaultsResponse.failed(e.getMessage());
        }

        if(YmUtil.FAIL.equals(back.getResult().getId()) || YmUtil.SUCCESS.equals(back.getResult().getId())){
            return VaultsResponse.success(back.getRefund_status());
        }

        return VaultsResponse.failed(back.getResult().getComment());
    }

    @Override
    public VaultsResponse delayConfirmRefund(Long splitId) {

        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("split_id",splitId);
        SplitRecords splitRecords = splitRecordsService.getOne(queryWrapper);
        BasicConfiguration basicConfig = Basic.getSystemParameter(splitRecords.getOperatorId());
        List<SplitRecordsDetail> list = splitRecordsDetailService.list(queryWrapper);
        PayConfirmRefund payConfirmRefund =  new PayConfirmRefund();
        payConfirmRefund.setPos_id(basicConfig.getCode());
        payConfirmRefund.setSystem_id(basicConfig.getSystemId());
        payConfirmRefund.setIsspid(basicConfig.getPid());
        payConfirmRefund.setStore_id(splitRecords.getOperatorId().toString());
        PayConfirmDetail detail = new PayConfirmDetail();
        detail.setOrg_pos_seq(splitId.toString());
        detail.setNotify_url(url+"/delayConfirmNotify");
        ExtendParamsConfirm extendParamsConfirm = new ExtendParamsConfirm();
        SplitInfoConfirm splitInfoConfirm = new SplitInfoConfirm();
        List<SplitListConfirm> split_list = Lists.newArrayList();
        for (SplitRecordsDetail recordsDetail : list) {
            if(recordsDetail.getSourceId().equals(0)){
                splitInfoConfirm.setKeep_amt(recordsDetail.getDivAmt());
            }else{
                SplitListConfirm listConfirm = new SplitListConfirm();
                listConfirm.setMerchant_id(recordsDetail.getMerchantId());
                listConfirm.setDiv_amt(recordsDetail.getDivAmt());
                split_list.add(listConfirm);
            }

        }
        splitInfoConfirm.setSplit_list(split_list);
        extendParamsConfirm.setSplit_info(splitInfoConfirm);
        detail.setExtend_params(extendParamsConfirm);
        payConfirmRefund.setDelay_confirmrefund_request(detail);
        BaseBack back = null;
        try {
            back = (BaseBack) YmUtil.resultBack(payConfirmRefund,new BaseBack());
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            return VaultsResponse.failed(e.getMessage());
        }

        if(YmUtil.FAIL.equals(back.getResult().getId()) || YmUtil.SUCCESS.equals(back.getResult().getId())){
            return VaultsResponse.success();
        }

        return VaultsResponse.failed(back.getResult().getComment());
    }

    @Override
    public BaseBack delayRefundQuery(PayRefundQuery payRefundQuery) {
        return null;
    }

    @Override
    public VaultsResponse<SettlementQueryBack> merchantSettlementQuery(SettlementQueryDetail detail) {
        SettlementQuery settlementQuery =  new SettlementQuery();
        BasicConfiguration basicConfig = Basic.getSystemParameter(TokenContext.cureOperatorId());
        settlementQuery.setSystem_id(basicConfig.getSystemId());
        settlementQuery.setIsspid(basicConfig.getPid());
        settlementQuery.setMerchant_settlementquery_request(detail);
        SettlementQueryBack back = null;

        try {
            String val = (String) YmUtil.resultBack(settlementQuery,new SettlementQueryBack());
            JSONObject jsonObject = new JSONObject(JSON.parseObject(val));
            if(val.contains("list")){
                List<SettlementQueryList> list = jsonObject.getJSONArray("list").stream().map(item -> JSON.parseObject(item.toString(), new TypeReference<SettlementQueryList>() {})).collect(Collectors.toList());
                jsonObject.put("list",list);
            }
            back = JSONObject.toJavaObject(jsonObject, SettlementQueryBack.class);

        } catch (IllegalAccessException e) {
            e.printStackTrace();
            return VaultsResponse.failed(e.getMessage());
        }

        if(YmUtil.FAIL.equals(back.getResult().getId()) || YmUtil.SUCCESS.equals(back.getResult().getId())){
            return VaultsResponse.success(back);
        }

        return VaultsResponse.failed(back.getResult().getComment());
    }

    @Override
    public VaultsResponse<AccountBalanceBack> accountBalanceQuery(String merchantId) {
        BasicConfiguration basicConfig = Basic.getSystemParameter(TokenContext.cureOperatorId());
        AccountBalance accountBalance =  new AccountBalance();
        accountBalance.setMerchant_id(merchantId);
        accountBalance.setSystem_id(basicConfig.getSystemId());
        accountBalance.setIsspid(basicConfig.getPid());
        AccountBalanceBack back = null;
        try {
            String val = (String) YmUtil.resultBack(accountBalance,new AccountBalanceBack());
            JSONObject jsonObject = new JSONObject(JSON.parseObject(val));
            if(val.contains("list")){
                List<AccountBalanceList> list = jsonObject.getJSONArray("list").stream().map(item -> JSON.parseObject(item.toString(), new TypeReference<AccountBalanceList>() {})).collect(Collectors.toList());
                jsonObject.put("list",list);
            }
            back = JSONObject.toJavaObject(jsonObject, AccountBalanceBack.class);

        } catch (IllegalAccessException e) {
            e.printStackTrace();
            return VaultsResponse.failed(e.getMessage());
        }

        if(YmUtil.FAIL.equals(back.getResult().getId()) || YmUtil.SUCCESS.equals(back.getResult().getId())){
            return VaultsResponse.success(back);
        }

        return VaultsResponse.failed(back.getResult().getComment());
    }

    @Override
    public VaultsResponse<WithdrawBack> withdraw(WithdrawDto dto) {
        Long withdrawId = CgpTool.generateKey();
        BasicConfiguration basicConfig = Basic.getSystemParameter(TokenContext.cureOperatorId());
        Withdraw withdraw =  new Withdraw();
        withdraw.setSystem_id(basicConfig.getSystemId());
        withdraw.setIsspid(basicConfig.getPid());
        withdraw.setPos_seq(withdrawId.toString());
        WithdrawDetail detail = new WithdrawDetail();
        detail.setMerchant_id(dto.getMerchantId());
        detail.setAmount(dto.getAmount());
        withdraw.setMerchant_withdraw_request(detail);
        WithdrawBack back = null;
        try {
            back = (WithdrawBack) YmUtil.resultBack(withdraw,new WithdrawBack());
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            return VaultsResponse.failed(e.getMessage());
        }


        SplitWithdraw splitWithdraw = new SplitWithdraw();
        splitWithdraw.setOperatorId(TokenContext.cureOperatorId());
        splitWithdraw.setWithdrawId(withdrawId);
        splitWithdraw.setWithdrawSeq(back.getWithdraw_seq());
        splitWithdraw.setMerchantId(dto.getMerchantId());
        splitWithdraw.setAmount(dto.getAmount());
        splitWithdraw.setTransDate(new Date());
        splitWithdraw.setTransStatus(back.getTrans_status());
        splitWithdraw.setAcctStatus(StringUtils.isEmpty(back.getAcct_status())?back.getTrans_status():back.getAcct_status());
        splitWithdraw.setErrorMsg(back.getError_msg());
        splitWithdrawService.save(splitWithdraw);

        if(YmUtil.FAIL.equals(back.getResult().getId()) || YmUtil.SUCCESS.equals(back.getResult().getId())){
            return VaultsResponse.success(back);
        }

        return VaultsResponse.failed(back.getResult().getComment());

    }

    @Override
    public VaultsResponse<WithdrawBack> withdrawQuery(String withdrawSeq) {
        BasicConfiguration basicConfig = Basic.getSystemParameter(TokenContext.cureOperatorId());
        WithdrawQuery withdraw =  new WithdrawQuery();
        withdraw.setSystem_id(basicConfig.getSystemId());
        withdraw.setIsspid(basicConfig.getPid());
        WithdrawQueryDetail detail = new WithdrawQueryDetail();
        detail.setWithdraw_seq(withdrawSeq);
        withdraw.setMerchant_withdrawquery_request(detail);
        WithdrawBack back = null;
        try {
            back = (WithdrawBack) YmUtil.resultBack(withdraw,new WithdrawBack());
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            return VaultsResponse.failed(e.getMessage());
        }

        QueryWrapper<SplitWithdraw> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("withdraw_seq",withdrawSeq);
        SplitWithdraw splitWithdraw = new SplitWithdraw();
        splitWithdraw.setTransStatus(back.getTrans_status());
        splitWithdraw.setAcctStatus(back.getAcct_status());
        splitWithdrawService.update(splitWithdraw,queryWrapper);

        if(YmUtil.FAIL.equals(back.getResult().getId()) || YmUtil.SUCCESS.equals(back.getResult().getId())){
            return VaultsResponse.success(back);
        }

        return VaultsResponse.failed(back.getResult().getComment());
    }

    @Override
    public String delayConfirmNotify(DelayConfirmNotification delayConfirmNotification) {
        try{
            QueryWrapper<SplitRecords> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("split_id",delayConfirmNotification.getSplit_seq());
            List<SplitRecords> list = splitRecordsService.list(queryWrapper);
            for (SplitRecords splitRecords : list) {
                splitRecords.setType(delayConfirmNotification.getType());
                splitRecords.setErrorDesc(delayConfirmNotification.getError_desc());
                splitRecords.setTradeState(delayConfirmNotification.getTrade_state());
                if(splitRecords.getTradeState().equals("s")){
                    splitRecords.setStatus(1);
                }
                QueryWrapper<SplitRecordsDetail> queryWrapper2 = new QueryWrapper<>();
                queryWrapper2.eq("split_id",splitRecords.getSplitId());
                List<SplitRecordsDetail> list2 = splitRecordsDetailService.list(queryWrapper2);
                for (SplitRecordsDetail detail : list2) {
                    for (SplitConfirmDetail confirmDetail : delayConfirmNotification.getSplit_detail()) {
                        if(detail.getMerchantId().equals(confirmDetail.getMerchant_id())){
                            detail.setAmount(confirmDetail.getAmount());
                            detail.setSellerAccount(confirmDetail.getSeller_account());
                            detail.setTradeState(confirmDetail.getTrade_state());
                            detail.setType(confirmDetail.getType());
                            detail.setMchType(confirmDetail.getMch_type());
                        }
                    }
                }
                splitRecordsDetailService.updateBatchById(list2);

                if(splitRecords.getStatus().equals(1)){
                    LongParams params = new LongParams();
                    params.setOperatorId(splitRecords.getOperatorId());
                    params.setId(splitRecords.getSplitId());
                    orderFeignClient.changeOrderDelayConfirm(params);
                }
            }
            splitRecordsService.updateBatchById(list);

        }catch (Exception e){
            e.printStackTrace();
            return "fail";
        }

        return "success";
    }
}