package com.driver.igotrip.netUtls;


import static com.driver.igotrip.netUtls.NetKitKt.getToken;

import android.util.Log;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

import com.driver.igotrip.BuildConfig;
import com.driver.igotrip.R;
import com.driver.igotrip.base.Const;
import com.driver.igotrip.base.MyApplication;
import com.driver.igotrip.utils.LogUtils;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

import org.json.JSONObject;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Type;
import java.security.KeyStore;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;

import cn.sinata.xldutils.utils.SPUtils;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.schedulers.Schedulers;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.RequestBody;
import okhttp3.ResponseBody;
import okio.Buffer;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
import retrofit2.converter.gson.GsonConverterFactory;


/**
 * 网络请求管理类
 * Created by Administrator on 2018/1/25.
 */

public class HttpManager {
    //只信任指定证书的服务 安全级别高
    private final ApiServics service = initBaseData(true, false).create(ApiServics.class);
    //信任所有证书的服务 安全级别低
    private final ApiServics allTrustService = initBaseData(false, true).create(ApiServics.class);
    private Gson gson;
    private final Map<String, String> headerParams = new HashMap<>();

    private static final class HttpManagerHolder {
        private static final HttpManager httpManager = new HttpManager();
    }

    public static synchronized HttpManager getInstance() {
        return HttpManagerHolder.httpManager;
    }

    private static String bodyToString(final RequestBody request) {
        try {
            final RequestBody copy = request;
            final Buffer buffer = new Buffer();
            if (copy != null) {
                copy.writeTo(buffer);
            } else {
                return "";
            }
            return buffer.readUtf8();
        } catch (final IOException e) {
            return "did not work";
        }
    }

    @Nullable
    private SSLSocketFactory getSSLSocketFactory(X509TrustManager trustManager) {
        try {
            SSLContext tls = SSLContext.getInstance("TLS");
            tls.init(null, new TrustManager[]{trustManager}, null);
            return tls.getSocketFactory();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 创建特定证书信任管理器
     */
    @Nullable
    private X509TrustManager createTrustManager(int certificateResId) {
        try {
            CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
            try (
                    // 读取证书文件
                    InputStream inputStream = MyApplication.Companion.getAppContext().getResources().openRawResource(certificateResId)
            ) {
                X509Certificate certificate = (X509Certificate) certificateFactory.generateCertificate(inputStream);

                // 创建包含该证书的KeyStore
                KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
                keyStore.load(null, null);
                keyStore.setCertificateEntry("server", certificate);

                // 创建TrustManager
                TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
                trustManagerFactory.init(keyStore);
                return (X509TrustManager) trustManagerFactory.getTrustManagers()[0];
            } catch (Exception e) {
                e.printStackTrace();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 创建所有证书信任管理器
     */
    @NonNull
    private X509TrustManager createAllTrustManager() {
        return 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];
            }
        };
    }

    /**
     * 初始化数据
     *
     */
    private Retrofit initBaseData(boolean isUseCert, boolean isTrustAll) {
        // 监听请求条件
        OkHttpClient.Builder builder = new OkHttpClient.Builder();
        builder.connectTimeout(3, TimeUnit.MINUTES);
        builder.readTimeout(3, TimeUnit.MINUTES);
        builder.writeTimeout(3, TimeUnit.MINUTES);
        if (isUseCert) {
            X509TrustManager trustManager = createTrustManager(R.raw.star_gopost_ci);
            if (trustManager != null) {
                SSLSocketFactory sslSocketFactory = getSSLSocketFactory(trustManager);
                if (sslSocketFactory != null) {
                    builder.sslSocketFactory(sslSocketFactory, trustManager);
                }
            }
        } else {
            if (isTrustAll) {
                X509TrustManager trustManager = createAllTrustManager();
                SSLSocketFactory sslSocketFactory = getSSLSocketFactory(trustManager);
                if (sslSocketFactory != null) {
                    builder.sslSocketFactory(sslSocketFactory, trustManager);
                }
            }
        }
//        builder.addInterceptor(new Interceptor() {
//            @Override
//            public Response intercept(Chain chain) throws IOException {
//                Request request = chain.request();
//                Request.Builder requestBuilder = request.newBuilder();
//                request = requestBuilder.post(RequestBody.create(MediaType.parse("application/x-www-form-urlencoded;charset=GBK"),
//                        URLDecoder.decode(bodyToString(request.body()), "UTF-8")))
//                        .build();
//                return chain.proceed(request);
//            }
//        });

        if (BuildConfig.DEBUG) {
            builder.addInterceptor(new LoggingInterceptor());
        }

        Retrofit.Builder builder1 = new Retrofit.Builder()
                .client(builder.build())                                    // 配置监听请求
                .addConverterFactory(GsonConverterFactory.create())         // 请求结果转换（当前为GSON）
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create()); // 请求接受工具（当前为RxJava2）
//        builder1.baseUrl(BASE_URL + action.substring(0, action.lastIndexOf("/") + 1));
        builder1.baseUrl(Api.BASE_URL);

        return builder1.build();
    }

    /**
     * Get请求
     *
     * @param action   请求接口的尾址
     * @param params   请求参数
     * @param observer observer
     */
    //                                         public <T extends BaseBean> void get(final String action,
    public void get(final String action, Map<String, String> params, Observer<ResponseBody> observer) {
        if (params == null) {
            params = new HashMap<>();
        }
        int type = getTypeByLanguage();
        params.put(Const.language, type + ""); // 1 中文 2 英文 3 法文
        if (gson == null) {
            gson = new Gson();
        }

        Log.i("zzz", "request====" + new JSONObject(params));
        headerParams.put("Authorization", "Bearer " + getToken());
//        getService.getResult(action.substring(action.lastIndexOf("/") + 1), headerParams, params)
        service.getResult(action, headerParams, params)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(observer);
    }


    public static int getTypeByLanguage() {
        String lang = SPUtils.getString(Const.language, Const.Language.DEFAULT_LANGUAGE);
        int type = 0;
        if (lang == null || lang.isEmpty() || lang.equals(Const.Language.FRENCH)) {
            type = 3;
        } else if (lang.equals(Const.Language.CHINESE) || lang.equals("zh")) {
            type = 1;
        } else if (lang.equals(Const.Language.ENGLISH)) {
            type = 2;
        }
        return type;
    }

    /**
     * Post请求
     *
     * @param action 请求接口的尾址
     * @param params 请求参数
     */
//    public <T extends BaseBean> void post(final String action, Map<String, Object> params,
    public void post(final String action, Map<String, Object> params,
                     Observer<ResponseBody> observer) {
        post(false, action, params, observer);
    }

    /**
     * Post请求
     *
     * @param isUseAllTrustService 是否使用信任所有证书服务
     * @param action               请求接口的尾址
     * @param params               请求参数
     */
//    public <T extends BaseBean> void post(final String action, Map<String, Object> params,
    public void post(boolean isUseAllTrustService, final String action, Map<String, Object> params,
                     Observer<ResponseBody> observer) {
        post(isUseAllTrustService, action, params)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(observer);
    }

    /**
     * Post请求
     *
     * @param action 请求接口的尾址
     * @param params 请求参数
     */
    public Observable<ResponseBody> post(final String action, Map<String, Object> params) {
        return post(false, action, params);
    }

    /**
     * Post请求
     *
     * @param action 请求接口的尾址
     * @param params 请求参数
     */
    public Observable<ResponseBody> post(boolean isUseAllTrustService, final String action, Map<String, Object> params) {
        if (params == null) {
            params = new HashMap<>();
        }
        int type = getTypeByLanguage();
        params.put(Const.language, type); // 1 中文 2 英文 3 法文
        LogUtils.d("post", params.toString());
        headerParams.put("Authorization", "Bearer " + getToken());
        return (isUseAllTrustService ? allTrustService : service).postResult(action, headerParams, params);
    }

    /**
     * 将map数据转换为 普通的 json RequestBody
     *
     * @param map 以前的请求参数
     * @return
     */
    public static RequestBody convertMapToBody(Map<?, ?> map) {
        return RequestBody.create(MediaType.parse("application/json; charset=utf-8"), new JSONObject(map).toString());
    }


    /**
     * Post请求
     *
     * @param action   请求接口的尾址
     * @param fileName 文件名
     */
    public void post(final String action, File fileName, Observer<ResponseBody> observer) {
        post(action, fileName)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(observer);
    }

    /**
     * Post请求
     *
     * @param action 请求接口的尾址
     * @param file   文件
     */
    public Observable<ResponseBody> post(final String action, File file) {

        // https://github.com/iPaulPro/aFileChooser/blob/master/aFileChooser/src/com/ipaulpro/afilechooser/utils/FileUtils.java
        // use the FileUtils to get the actual file by uri

        // create RequestBody instance from file
        RequestBody requestFile = RequestBody.create(MediaType.parse("multipart/form-data"), file);

        // MultipartBody.Part is used to send also the actual file name
        MultipartBody.Part body = MultipartBody.Part.createFormData("file", file.getName(), requestFile);
        return service.upload(action, body);
    }


    /**
     * 将json数据转换为map集合
     *
     * @param gsonStr
     * @return
     */
    public Map<String, Object> gsonToMap(String gsonStr) {
        Gson gson = new Gson();
        Type type = new TypeToken<Map<String, Object>>() {
        }.getType();
        Map<String, Object> map = gson.fromJson(gsonStr, type);
        return map;
    }


    /**
     * 将map集合转为json
     *
     * @param map
     * @return
     */
    public String mapToJson(Map<String, Object> map) {
        String tab_str = "";
        String json = tab_str + "{";
        int i = 0;
        for (String key : map.keySet()) {
            if (i >= map.size())
                break;
            String content = "";
            try {
                List<Map<String, Object>> list = (List<Map<String, Object>>) map.get(key);
                content += "[";
                int j = 0;
                for (Map<String, Object> map2 : list) {
                    if (j == list.size())
                        break;
                    content += mapToJson(map2) + (j++ == list.size() - 1 ? "" : ",");
                }
                content += tab_str + "]"/* + (i == (map.size() - 1) ? "" : ",")*/;
            } catch (Exception e) {
                content = "\"" + map.get(key).toString() + "\"";
            }
            json += tab_str + "\"" + key + "\":" + content + (i++ == map.size() - 1 ? "" : ",");
        }
        json += tab_str + "}";
        return json;
    }

}