package com.github.hunter0x7c7.sync.model.server;


import com.github.hunter0x7c7.sync.model.server.net.converters.NullOnEmptyConverterFactory;
import com.github.hunter0x7c7.sync.model.server.net.interceptors.HeaderInterceptors;
import com.github.hunter0x7c7.sync.model.server.net.interceptors.RestInterceptors;
import com.google.gson.GsonBuilder;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.RequestBody;
import okhttp3.logging.HttpLoggingInterceptor;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
import retrofit2.converter.gson.GsonConverterFactory;

import javax.net.ssl.*;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.concurrent.TimeUnit;

/**
 * 服务器连接的客户端
 */
public class BaseServiceClient {

    private static BaseServiceClient sServiceClient;

    /**
     * 获取实例
     */
    public static BaseServiceClient getInstance() {
        if (sServiceClient == null) {
            synchronized (BaseServiceClient.class) {
                if (sServiceClient == null) {
                    sServiceClient = new BaseServiceClient();
                }
            }
        }
        return sServiceClient;
    }

    public String getBaseUrl() {
        return "http://www.plan.nongtt.com/";
    }

    /**
     * 供应服务器接口
     */
    public <T> T provideServiceApi(Class<T> serviceClass) {
        return provideServiceApi(serviceClass, getBaseUrl());
    }

    /**
     * 供应服务器接口
     */
    public <T> T provideServiceApi(Class<T> serviceClass, String baseUrl) {
        return provideServiceApi(serviceClass, baseUrl, provideOkHttpClient());
    }

    /**
     * 供应服务器接口
     */
    public <T> T provideServiceApi(Class<T> serviceClass, String baseUrl, OkHttpClient okHttpClient) {
        return createServiceFrom(getRetrofit(baseUrl, okHttpClient), serviceClass);
    }

    /**
     * 创建服务器
     */
    public <T> T createServiceFrom(Retrofit retrofit, Class<T> serviceClass) {
        return retrofit.create(serviceClass);
    }

    /**
     * 获取Retrofit
     */
    protected Retrofit getRetrofit(String baseUrl, OkHttpClient okHttpClient) {
        return new Retrofit.Builder()
                .addConverterFactory(new NullOnEmptyConverterFactory())//空返回转换器 必需在GsonConverterFactory之前addConverterFactory
                .addConverterFactory(GsonConverterFactory.create(new GsonBuilder().setLenient().create()))
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .baseUrl(baseUrl)
                .client(okHttpClient)
                .build();
    }

    /**
     * 供应OkHttp客户端
     */
    protected OkHttpClient provideOkHttpClient() {
        return getUnsafeOkHttpClientInstance().newBuilder()
                .addInterceptor(new HttpLoggingInterceptor().setLevel(getLevel()))
                .addNetworkInterceptor(new HeaderInterceptors())
                .addNetworkInterceptor(new RestInterceptors())
                .connectTimeout(20, TimeUnit.SECONDS)//链接超时
                .readTimeout(20, TimeUnit.SECONDS)//设置读取超时
                .build();
    }

    private OkHttpClient mOkHttpClient;

    protected OkHttpClient getUnsafeOkHttpClientInstance() {
        if (mOkHttpClient == null) {
            mOkHttpClient = getUnsafeOkHttpClient();
        }
        return mOkHttpClient;
    }

    //信任所有Https证书
    protected static OkHttpClient getUnsafeOkHttpClient() {
        try {
            // Create a trust manager that does not validate certificate chains
            X509TrustManager x509TrustManager = new X509TrustManager() {
                @Override
                public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                }

                @Override
                public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                }

                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    return new X509Certificate[0];
                }
            };
            final TrustManager[] trustAllCerts = new TrustManager[]{
                    x509TrustManager
            };

            // Install the all-trusting trust manager
            SSLContext sslContext = SSLContext.getInstance("SSL");
            sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
            // Create an ssl socket factory with our all-trusting manager
            final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();

            OkHttpClient.Builder builder = new OkHttpClient.Builder();
            builder.sslSocketFactory(sslSocketFactory, x509TrustManager);
            builder.hostnameVerifier(new HostnameVerifier() {
                @Override
                public boolean verify(String hostname, SSLSession session) {
                    return true;
                }
            });

            return builder.build();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }


    }

    /**
     * 根据Json数据创建一个RequestBody
     */
    public RequestBody getRequestBodyFromJson(String jsonRes) {
        return RequestBody.create(MediaType.parse("application/json; charset=utf-8"), jsonRes);
    }

    protected HttpLoggingInterceptor.Level getLevel() {
        return isDebugMode() ? HttpLoggingInterceptor.Level.BODY : HttpLoggingInterceptor.Level.NONE;
    }

    private static boolean isDebugMode = true;

    public static boolean isDebugMode() {
        return isDebugMode;
    }

    public static void setDebugMode(boolean isDebugMode) {
        BaseServiceClient.isDebugMode = isDebugMode;
    }
}