package com.ydtech.modules.order.components;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.ydtech.config.properties.ZhongmeiApiConfigurationProperties;
import com.ydtech.constants.InsuranceEnum;
import com.ydtech.exception.SystemException;
import com.ydtech.modules.order.entity.api.zhongmei.BaseRequest;
import com.ydtech.modules.order.entity.api.zhongmei.BaseResponse;
import com.ydtech.modules.order.entity.api.zhongmei.constants.TransCode;
import com.ydtech.modules.order.entity.api.zhongmei.request.*;
import com.ydtech.modules.order.entity.api.zhongmei.response.*;
import com.ydtech.modules.order.utils.AESUtilsWithDataBase;
import com.ydtech.modules.order.utils.InsuranceLog;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import org.springframework.web.client.RestTemplate;

import java.util.List;


/**
 * @author wenks
 * @version 0.0.2
 * @description 中煤 APi 请求
 * @date 2023/4/21 9:08
 */
@Slf4j
@Component
public class ZhongmeiRequestApiComponents {


    private final ZhongmeiApiConfigurationProperties properties;

    private final RestTemplate restTemplate;

    public ZhongmeiRequestApiComponents(ZhongmeiApiConfigurationProperties zmApiConfigurationProperties, RestTemplate restTemplate) {
        this.properties = zmApiConfigurationProperties;
        this.restTemplate = restTemplate;
    }


    /**
     * 加密请求
     *
     * @param q      请求参数
     * @param url    请求url
     * @param tClass 响应类型
     * @param <Q>    Request 请求体
     * @param <S>    Response 响应体
     * @return <S>
     */
    private <Q extends BaseRequest, S extends BaseResponse> S post(Q q, String url, Class<S> tClass) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setContentType(MediaType.APPLICATION_JSON);

        String jsonString = JSON.toJSONString(q, SerializerFeature.WriteMapNullValue, SerializerFeature.WriteNullStringAsEmpty);
        InsuranceLog.infoLog(InsuranceEnum.ZMBX.getPinyin(), "\n\t---------> URl: {} \n---------> 请求参数:{}", url, jsonString);
        // 加密
        String sessionKey = properties.getSessionKey();
        String s = AESUtilsWithDataBase.encryptECBPK5Hex(jsonString, sessionKey);
        InsuranceLog.infoLog(InsuranceEnum.ZMBX.getPinyin(), "\n\t---------> 加密后的参数:{}", s);
        HttpEntity<String> httpEntity = new HttpEntity<>(s, httpHeaders);
        ResponseEntity<String> response = restTemplate.postForEntity(url, httpEntity, String.class);
        String body = response.getBody();

        S t = AESUtilsWithDataBase.decryptMessage(body, tClass, "响应参数", sessionKey);
        if (ObjectUtils.isEmpty(t)) {
            throw new SystemException("请求失败");
        }
        return t;
    }

    /**
     * @param <Q>     Request 请求体
     * @param <S>     Response 响应体
     * @param request 请求内容
     * @param tClass  响应类型
     * @param verify  结果是否需要验证
     * @return 响应内容
     */
    private <Q extends BaseRequest, S extends BaseResponse> S request(Q request, Class<S> tClass, boolean verify, String domain, String urlInterface) {
        String url = domain;
        if (StringUtils.isNotEmpty(urlInterface)) {
            url = url + urlInterface + ".do";
        } else {
            url = url + request.getHead().getTransCode() + ".do";
        }
        S response = post(request, url, tClass);
        if (verify) {
            validationResults(response);
        }
        return response;
    }

    /**
     * @param <Q> Request 请求体
     * @param <S> Response 响应体
     *            常规
     */
    private <Q extends BaseRequest, S extends BaseResponse> S routineRequest(Q request, Class<S> tClass, boolean verify, String urlInterface) {
        return request(request, tClass, verify, properties.getUrl(), urlInterface);
    }

    /**
     * @param <Q> Request 请求体
     * @param <S> Response 响应体
     *            影像
     */
    private <Q extends BaseRequest, S extends BaseResponse> void imageRequest(Q request, Class<S> tClass, boolean verify) {
        request(request, tClass, verify, properties.getUrl(), "");
    }

    /**
     * @param <Q> Request 请求体
     * @param <S> Response 响应体
     *            短信
     */
    private <Q extends BaseRequest, S extends BaseResponse> S smsRequest(Q request, Class<S> tClass, boolean verify) {
        return request(request, tClass, verify, properties.getSmsUrl(), "");
    }


    /**
     * 车型查询 传入必要车辆信息，返回车型列表给用户选择
     */
    public List<ModelsQueryResponse.SimpleStadarCarDTO> modelQuery(ModelsQueryRequest request, Class<ModelsQueryResponse> tClass) {
        return routineRequest(request, tClass, true, "").getSimpleStadarCar();
    }

    /**
     * 报价 传入必要投保方案信息，返回投保单保费及车船税
     */
    public QuotedPriceResponse quotedPrice(QuotedPriceRequest request, Class<QuotedPriceResponse> tClass) {
        return routineRequest(request, tClass, true, "");
    }

    /**
     * 提交核保 传入投保单必要信息，对投保单进行审核
     */
    public SubmitResponse submit(SubmitRequest request, Class<SubmitResponse> tClass) {
        request.setCallbackUrl(properties.getCallbackDomain() + properties.getCallbackUrl());
        request.setPageUrl(properties.getPageUrl());
        request.setPassMsgUrl(properties.getCallbackDomain() + properties.getPassMsgUrl());
        return routineRequest(request, tClass, false, "");
    }

    /**
     * 上传影像 传入订单信息，查询是否生成保单成功
     */
    public void uploadImage(UploadImageRequest request, Class<UploadImageResponse> tClass) {
        imageRequest(request, tClass, true);
    }

    /**
     * 缴费查询
     */
    public OrderStatusResponse orderStatus(OrderStatusRequest request, Class<OrderStatusResponse> tClass) {
        return routineRequest(request, tClass, true, "");
    }

    /**
     * 核保状态查询 传入单号查询该单核保状态
     */
    public SubmitStatusQueryResponse submitStatus(SubmitStatusQueryRequest request, Class<SubmitStatusQueryResponse> tClass) {
        return routineRequest(request, tClass, true, TransCode.SUBMIT_STATUS);
    }

    /**
     * 非车可投保产品查询
     * @param request
     * @param tClass
     * @return
     */
    public RideAccidentQueryResponse rideAccidentQuery(RideAccidentQueryRequest request, Class<RideAccidentQueryResponse> tClass) {
        return routineRequest(request, tClass, true, TransCode.Ride_Accident_Query);
    }

    /**
     * 电子保单下载 传入单号相关信息下载电子保单
     */
    public InsurancePolicyPrintResponse insurancePolicyPrint(InsurancePolicyPrintRequest request, Class<InsurancePolicyPrintResponse> tClass) {
        return routineRequest(request, tClass, true, "");
    }

    /**
     * 校验发短信接口 校验此单是否需要发送短信
     */
    public CheckSMScodeResponse checkSMScode(CheckSMScodeRequest request, Class<CheckSMScodeResponse> tClass) {
        return smsRequest(request, tClass, true);
    }

    /**
     * 验证校验码正确 录入校验码校验是否正确
     */
    public ValidSMScodeResponse checkSMScode(ValidSMScodeRequest request, Class<ValidSMScodeResponse> tClass) {
        return smsRequest(request, tClass, true);
    }


    public <T extends BaseResponse> void validationResults(T t) {
        if ("-1".equals(t.getHead().getReturnCode())) {
            if(StringUtils.isNotEmpty(t.getHead().getReturnMessage())&& t.getHead().getReturnMessage().contains("平台返回") && t.getHead().getReturnMessage().contains("重复投保")){

            }else{
                throw new SystemException(t.getHead().getReturnMessage());
            }

        }
    }

}