package com.ydtech.modules.order.components;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.ydtech.config.properties.ZmApiConfigurationProperties;
import com.ydtech.exception.SystemException;
import com.ydtech.modules.order.entity.api.zm.BaseRequest;
import com.ydtech.modules.order.entity.api.zm.BaseResponse;
import com.ydtech.modules.order.entity.api.zm.request.*;
import com.ydtech.modules.order.entity.api.zm.response.*;
import com.ydtech.modules.order.utils.AESUtilsWithDataBase;
import lombok.extern.slf4j.Slf4j;
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 ZmApiConfigurationProperties properties;

    private final RestTemplate restTemplate;

    public ZhongmeiRequestApiComponents(ZmApiConfigurationProperties 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);
        log.info("---------> 请求参数:{}", jsonString);
        // 加密
        String sessionKey = properties.getSessionKey();
        String s = AESUtilsWithDataBase.encryptECBPK5Hex(jsonString, sessionKey);
        log.info("---------> 加密后的参数:{}", 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      请求参数
//     * @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) {
//        String jsonString = JSON.toJSONString(q);
//        log.info("---------> 请求参数:{}", jsonString);
//
//        HttpHeaders httpHeaders = new HttpHeaders();
//        httpHeaders.setContentType(MediaType.APPLICATION_JSON);
//
//        HttpEntity<Q> yaQuoteInfoVoHttpEntity = new HttpEntity<>(q, httpHeaders);
//        ResponseEntity<String> response = restTemplate.postForEntity(url, yaQuoteInfoVoHttpEntity, String.class);
//        String body = response.getBody();
//        log.info("---------> 响应参数:{}", body);
//
//        S t = JSON.parseObject(body, tClass);
//        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 url = domain + 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) {
        return request(request, tClass, verify, properties.getUrl());
    }

    /**
     * @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);
    }

    /**
     * 电子保单下载 传入单号相关信息下载电子保单
     */
    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())) {
            throw new SystemException(t.getHead().getReturnMessage());
        }
    }

}