package com.hh.arome.http;

import android.content.Context;

import com.common.lib_base.common.local.AppLocalConfigHandler;
import com.common.lib_base.utils.LogUtils;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import com.hh.arome.common.IAppLocalConfig;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.io.IOException;

import okhttp3.Interceptor;
import okhttp3.MediaType;
import okhttp3.Protocol;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.ResponseBody;

/**
 * Date: 2022/7/25 0025 14:22
 * Description:
 */
public class CommonAddAndHandleInterceptor implements Interceptor {

    // 当前类名
    public String mTag = getClass().getSimpleName() + "--";

    private Gson mGson;
    private Context mContext;
    //    IAppLocalConfig localConfig;
    String token;
    public static final int ERROR_TOKEN = 100003;

    public CommonAddAndHandleInterceptor() {

    }

    public CommonAddAndHandleInterceptor(Context context) {
        this.mContext = context;
    }

    public CommonAddAndHandleInterceptor(Context context, Gson gson) {
        this.mContext = context;
        this.mGson = gson;
    }

    // 根据服务端定义，有的是data，有的是result
    String serverResult = "data";
    // 根据服务端定义，有的是message，有的是msg
    String message = "msg";

    @Override
    public Response intercept(Chain chain) throws IOException {

        Response response;

        Request newRequest = null;

        try {
//            token = localConfig.getToken("");
//            LogUtils.i(mTag + "Token:" + token);

            //请求头添加token
            newRequest = chain.request().newBuilder()
//                        .addHeader("Content-Type", "application/x-www-form-urlencoded; charset=utf-8")
                    .addHeader("Content-Type", "text/html; charset=utf-8")
//                        .addHeader("gray-version","develop-k4.77")
//                        .addHeader("Content-Type", "text/html")
//                        .addHeader("charset","UTF-8")
//                    .addHeader("token", token)
                    .addHeader("loginType", "app")
                    .build();
            // 需要对结果处理，故注释
//            return chain.proceed(newRequest);
        } catch (Exception e) {
            e.printStackTrace();
            LogUtils.i(mTag + "intercept:" + e.getMessage());
        }


        //调用拦截器处理获取结果
        /**
         * 使用OkHttpClient会出现重复请求问题
         * 最终排查到日志拦截器里重复使用chain.proceed(request)导致
         */
        Response originalResponse = chain.proceed(newRequest);
        LogUtils.i(mTag + "调用拦截器处理获取结果originalResponse" + originalResponse);

        // 返回体
        ResponseBody responseBody = originalResponse.body();

        Response newResponse = null;

        try {
            JSONObject jsonObject = new JSONObject(responseBody.string());

            Object result = null;
            try {
                result = jsonObject.get(serverResult);
            } catch (JSONException e) {
                e.printStackTrace();
                // 处理服务端没有返回data/result的情况
                LogUtils.i(mTag + "需要处理，原始返回的Json没有result字段");
                JSONObject newJsonObject = new JSONObject();
                JSONObject obj = new JSONObject();
                // 返回的结果bean
                newJsonObject.put(serverResult, obj); // data/result: {}

                newResponse = getNewJsonAndResponse(newRequest, responseBody, jsonObject, newJsonObject);

                //拿到结果进行处理后返回
                return newResponse;
            }

            //接下来都是有result字段的处理

            LogUtils.i(mTag + "result:" + result);

//            if(result.equals(null)){
//                LogUtils.i(mTag+"equals(null)");
//            }
//            if(jsonObject.has(serverResult)){
//                LogUtils.i(mTag+"has(\"result\")");
//            }


            if (result.equals(null)) {
                // 处理serverResult: null 的情况 result或data取决于服务端返回数据名
                LogUtils.i(mTag + "需要处理，原始返回的Json--result==null");

                JSONObject newJsonObject = new JSONObject();
                JSONObject obj = new JSONObject();
                newJsonObject.put(serverResult, obj); // serverResult: {}

                newResponse = getNewJsonAndResponse(newRequest, responseBody, jsonObject, newJsonObject);

                //拿到结果进行处理后返回
                return newResponse;

            } else if (jsonObject.get(serverResult) instanceof JSONArray) {
                // 处理result是数组的情况
                LogUtils.i(mTag + "需要处理，原始返回的Json--result是数组");

                JSONObject newJsonObject = new JSONObject();
                JSONObject obj = new JSONObject();
                obj.put("list", jsonObject.getJSONArray(serverResult));
                newJsonObject.put(serverResult, obj);

                newResponse = getNewJsonAndResponse(newRequest, responseBody, jsonObject, newJsonObject);

                //拿到结果进行处理后返回
                return newResponse;

            } else if (jsonObject.get(serverResult) instanceof String) {
                // 处理result是string的情况
                LogUtils.i(mTag + "需要处理，原始返回的Json--result是string");

                JSONObject newJsonObject = new JSONObject();
                JSONObject obj = new JSONObject();
                obj.put("string", jsonObject.getString(serverResult));
                newJsonObject.put(serverResult, obj);

                newResponse = getNewJsonAndResponse(newRequest, responseBody, jsonObject, newJsonObject);

                //拿到结果进行处理后返回
                return newResponse;

            } else if (jsonObject.get(serverResult) instanceof Integer) {
                // 处理result是Integer的情况
                LogUtils.i(mTag + "需要处理，原始返回的Json--result是Integer");

                JSONObject newJsonObject = new JSONObject();
                JSONObject obj = new JSONObject();
                obj.put("intValue", jsonObject.getInt(serverResult));
                newJsonObject.put(serverResult, obj);

                newResponse = getNewJsonAndResponse(newRequest, responseBody, jsonObject, newJsonObject);

                //拿到结果进行处理后返回
                return newResponse;

            } else if (jsonObject.get(serverResult) instanceof Boolean) {
                // 处理result是Integer的情况
                LogUtils.i(mTag + "需要处理，原始返回的Json--result是Boolean");

                JSONObject newJsonObject = new JSONObject();
                JSONObject obj = new JSONObject();
                obj.put("booleanValue", jsonObject.getBoolean(serverResult));
                newJsonObject.put(serverResult, obj);

                newResponse = getNewJsonAndResponse(newRequest, responseBody, jsonObject, newJsonObject);

                //拿到结果进行处理后返回
                return newResponse;

            }  else {
                LogUtils.i(mTag + "非需要处理的url,直接返回");
                // 重复使用chain.proceed(request)导致会出现重复请求问题
//                newResponse = chain.proceed(newRequest);
//                LogUtils.i(mTag + "originalResponse:" + originalResponse.toString());
//                return newResponse;

                //获取返回值类型
                MediaType mediaType = responseBody.contentType();

                newResponse = new Response.Builder()
                        .code(200)
                        .body(ResponseBody.create(mediaType,
                                jsonObject.toString()))
                        .request(newRequest)
                        .protocol(Protocol.HTTP_1_1)
                        .message("OK")
                        .build();

                return newResponse;
            }

        } catch (Exception e) {
            e.printStackTrace();
            LogUtils.i(mTag + "e--:" + e.toString());
        }
//        return  originalResponse.newBuilder().body(responseBody).build();
        return originalResponse;


//        return chain.proceed(request);
    }

    private Response getNewJsonAndResponse(Request newRequest, ResponseBody responseBody, JSONObject jsonObject, JSONObject newJsonObject) throws JSONException {
        Response newResponse;
        // 兼容code和errcode不一定同时存在的情况
        if (jsonObject.has("errcode")) {
            newJsonObject.put("errcode", jsonObject.getString("errcode"));
            newJsonObject.put("code", jsonObject.getString("errcode"));
        }
        // 兼容errmsg和msg不一定同时存在的情况
        if (jsonObject.has("errmsg")) {
            newJsonObject.put("errmsg", jsonObject.getString("errmsg"));
            newJsonObject.put(message, jsonObject.getString("errmsg"));
        }
        if (jsonObject.has("code")) {
            newJsonObject.put("code", jsonObject.getInt("code"));
        }
        if (jsonObject.has(message)) {
            newJsonObject.put(message, jsonObject.getString(message));
        }

        LogUtils.i(mTag + "newJsonObject:" + newJsonObject.toString());

        //获取返回值类型
        MediaType mediaType = responseBody.contentType();
        newResponse = new Response.Builder()
                .code(200)
                .body(ResponseBody.create(mediaType,
                        newJsonObject.toString()))
                .request(newRequest)
                .protocol(Protocol.HTTP_1_1)
                .message("OK")
                .build();
        LogUtils.i(mTag + "newResponse:" + newResponse.toString());
        return newResponse;
    }
}

