/*
 * Copyright (c) 2020 WildFireChat. All rights reserved.
 */

package cn.wildfire.chat.kit.net;

import android.content.Context;
import android.content.SharedPreferences;
import android.text.TextUtils;
import cn.wildfire.chat.kit.net.base.*;
import com.alibaba.fastjson.JSONObject;
import com.google.gson.Gson;
import com.google.gson.JsonSyntaxException;
import okhttp3.*;

import java.io.File;
import java.io.IOException;
import java.lang.ref.WeakReference;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.net.URLDecoder;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;


/**
 * Created by imndx on 2017/12/15.
 */

public class OKHttpHelper {
    private static final String WFC_OKHTTP_COOKIE_CONFIG = "WFC_OK_HTTP_COOKIES";
    private static final Map<String, List<Cookie>> cookieStore = new ConcurrentHashMap<>();

    private static WeakReference<Context>  AppContext;
    public static void init(Context context) {
        AppContext = new WeakReference<>(context);
    }
    private static OkHttpClient okHttpClient = new OkHttpClient.Builder()
            .readTimeout(30, TimeUnit.SECONDS)
            .writeTimeout(30, TimeUnit.SECONDS)
            .cookieJar(new CookieJar() {
                @Override
                public void saveFromResponse(HttpUrl url, List<Cookie> cookies) {
                    if (cookies == null) {
                        cookies = new ArrayList<>();
                    }
                    cookieStore.put(url.host(), cookies);
                    if (AppContext != null && AppContext.get() != null) {
                        SharedPreferences sp = AppContext.get().getSharedPreferences(WFC_OKHTTP_COOKIE_CONFIG, 0);
                        Set<String>  set = new HashSet<>();
                        for (Cookie k:cookies) {
                            set.add(gson.toJson(k));
                        }
                        sp.edit().putStringSet(url.host(), set).apply();
                    }
                }

                @Override
                public List<Cookie> loadForRequest(HttpUrl url) {
                    List<Cookie> cookies = cookieStore.get(url.host());
                    if (cookies == null) {
                        if (AppContext != null && AppContext.get() != null) {
                            SharedPreferences sp = AppContext.get().getSharedPreferences(WFC_OKHTTP_COOKIE_CONFIG, 0);
                            Set<String>  set = sp.getStringSet(url.host(), new HashSet<>());
                            cookies = new ArrayList<>();
                            for (String s:set) {
                                Cookie cookie = gson.fromJson(s, Cookie.class);
                                cookies.add(cookie);
                            }
                            cookieStore.put(url.host(), cookies);
                        }
                    }

                    return cookies;
                }
            })
            .build();

    private static Gson gson = new Gson();
    private static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");

    public static <T> void get(final String url, Map<String, String> params, final Callback<T> callback) {
        HttpUrl httpUrl = HttpUrl.parse(url);
        if (params != null) {
            HttpUrl.Builder builder = httpUrl.newBuilder();
            for (Map.Entry<String, String> entry : params.entrySet()) {
                builder.addQueryParameter(entry.getKey(), entry.getValue());
            }
            httpUrl = builder.build();
        }

        final Request request = new Request.Builder()
                .url(httpUrl)
                .get()
                .build();

        okHttpClient.newCall(request).enqueue(new okhttp3.Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                if (callback != null) {
                    callback.onFailure(-1, e.getMessage());
                }
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                handleResponse(url, call, response, callback);
            }
        });

    }

    public static <T> T syncGet(final String url, Map<String, String> params, final Callback<T> callback) {
        HttpUrl httpUrl = HttpUrl.parse(url);
        if (params != null) {
            HttpUrl.Builder builder = httpUrl.newBuilder();
            for (Map.Entry<String, String> entry : params.entrySet()) {
                builder.addQueryParameter(entry.getKey(), entry.getValue());
            }
            httpUrl = builder.build();
        }

        final Request request = new Request.Builder()
                .url(httpUrl)
                .get()
                .build();

        try {
            Response response = okHttpClient.newCall(request).execute();
            if (!response.isSuccessful()) {
                callback.onFailure(response.code(), response.message());
                return null;
            }
            Type types = callback.getClass().getGenericSuperclass();
            Type type = ((ParameterizedType) types).getActualTypeArguments()[0];
            String bodyStr = response.body().string();
            ResultInfos<T> wrapper = gson.fromJson(bodyStr, ResultInfos.class);
            if (wrapper == null) {
                return null;
            }
            if (wrapper.isSuccess() && wrapper.data != null) {
                T t= gson.fromJson(gson.toJson(wrapper.data), type);
                return t;
            } else {
                return null;
            }
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }

    }

    public static <T> void post(final String url, Map<String, Object> param, Map<String, String> header, final Callback<T> callback) {
        RequestBody body = RequestBody.create(JSON, gson.toJson(param));

        Request.Builder builder = new Request.Builder()
                .url(url)
                .post(body);
        Request request;
        if (header != null) {
            for (String key : header.keySet()) {
                String value = header.get(key);
                builder.addHeader(key,value);
            }
        }
        request = builder.build();

        okHttpClient.newCall(request).enqueue(new okhttp3.Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                if (callback != null) {
                    callback.onFailure(-1, e.getMessage());
                }
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                handleResponse(url, call, response, callback);

            }
        });
    } public static <T> T syncPost(final String url, Map<String, Object> param, Map<String, String> header, final Callback<T> callback) {
        RequestBody body = RequestBody.create(JSON, gson.toJson(param));

        Request.Builder builder = new Request.Builder()
                .url(url)
                .post(body);
        Request request;
        if (header != null) {
            for (String key : header.keySet()) {
                String value = header.get(key);
                builder.addHeader(key,value);
            }
        }
        request = builder.build();

        try {
            Response response = okHttpClient.newCall(request).execute();
            if (!response.isSuccessful()) {
                callback.onFailure(response.code(), response.message());
                return null;
            }
            Type types = callback.getClass().getGenericSuperclass();
            Type type = ((ParameterizedType) types).getActualTypeArguments()[0];
            String bodyStr = response.body().string();
            ResultInfos<T> wrapper = gson.fromJson(bodyStr, ResultInfos.class);
            if (wrapper == null) {
                return null;
            }
            if (wrapper.isSuccess() && wrapper.data != null) {
                T t= gson.fromJson(gson.toJson(wrapper.data), type);
              return t;
            } else {
               return null;
            }
        } catch (IOException e) {
            e.printStackTrace();
           return null;
        }
    }

    public static <T> T syncPost(final String url, Object param, Map<String, String> header, final Callback<T> callback) {
        RequestBody body = RequestBody.create(JSON, gson.toJson(param));

        Request.Builder builder = new Request.Builder()
                .url(url)
                .post(body);
        Request request;
        if (header != null) {
            for (String key : header.keySet()) {
                String value = header.get(key);
                builder.addHeader(key,value);
            }
        }
        request = builder.build();

        try {
            Response response = okHttpClient.newCall(request).execute();
            if (!response.isSuccessful()) {
                callback.onFailure(response.code(), response.message());
                return null;
            }
            Type types = callback.getClass().getGenericSuperclass();
            Type type = ((ParameterizedType) types).getActualTypeArguments()[0];
            String bodyStr = response.body().string();
            ResultInfos<T> wrapper = gson.fromJson(bodyStr, ResultInfos.class);
            if (wrapper == null) {
                return null;
            }
            if (wrapper.isSuccess() && wrapper.data != null) {
                T t= gson.fromJson(gson.toJson(wrapper.data), type);
              return t;
            } else {
               return null;
            }
        } catch (IOException e) {
            e.printStackTrace();
           return null;
        }
    }

    public static <T> void post(final String url, Map<String, Object> param, final Callback<T> callback) {
        RequestBody body = RequestBody.create(JSON, gson.toJson(param));
        final Request request = new Request.Builder()
                .url(url)
                .post(body)
                .build();

        okHttpClient.newCall(request).enqueue(new okhttp3.Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                if (callback != null) {
                    callback.onFailure(-1, e.getMessage());
                }
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                handleResponse(url, call, response, callback);

            }
        });
    }

    public static <T> void post(final String url, Object param, final Callback<T> callback) {
        RequestBody body = RequestBody.create(JSON, gson.toJson(param));
        final Request request = new Request.Builder()
                .url(url)
                .post(body)
                .build();

        okHttpClient.newCall(request).enqueue(new okhttp3.Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                if (callback != null) {
                    callback.onFailure(-1, e.getMessage());
                }
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                handleResponse(url, call, response, callback);

            }
        });
    }

    public static <T> void put(final String url, Map<String, String> param, final Callback<T> callback) {
        RequestBody body = RequestBody.create(JSON, gson.toJson(param));
        final Request request = new Request.Builder()
                .url(url)
                .put(body)
                .build();

        okHttpClient.newCall(request).enqueue(new okhttp3.Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                if (callback != null) {
                    callback.onFailure(-1, e.getMessage());
                }
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                handleResponse(url, call, response, callback);
            }
        });
    }

    public static <T> void upload(String url, Map<String, String> params, File file, MediaType mediaType, final Callback<T> callback) {
        MultipartBody.Builder builder = new MultipartBody.Builder()
                .setType(MultipartBody.FORM)
                .addFormDataPart("file", file.getName(),
                        RequestBody.create(mediaType, file));

        if (params != null) {
            for (Map.Entry<String, String> entry : params.entrySet()) {
                builder.addFormDataPart(entry.getKey(), entry.getValue());
            }
        }

        RequestBody requestBody = builder.build();

        Request request = new Request.Builder()
                .url(url)
                .post(requestBody)
                .build();
        okHttpClient.newCall(request).enqueue(new okhttp3.Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                if (callback != null) {
                    callback.onFailure(-1, e.getMessage());
                }
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                handleResponse(url, call, response, callback);
            }
        });
    }

    public static void clearCookies(){
        SharedPreferences sp = AppContext.get().getSharedPreferences(WFC_OKHTTP_COOKIE_CONFIG, 0);
        sp.edit().clear().apply();
        cookieStore.clear();
    }

    private static <T> void handleResponse(String url, Call call, okhttp3.Response response, Callback<T> callback) {
        if (callback != null) {
            if (!response.isSuccessful()) {
                callback.onFailure(response.code(), response.message());
                return;
            }

            Type type;
            if (callback instanceof SimpleCallback) {
                Type types = callback.getClass().getGenericSuperclass();
                type = ((ParameterizedType) types).getActualTypeArguments()[0];
            } else if (callback instanceof BaseIMResultCallBack) {
                Type types = callback.getClass().getGenericSuperclass();
                type = ((ParameterizedType) types).getActualTypeArguments()[0];
            }else if (callback instanceof BaseResultCallBack) {
                Type types = callback.getClass().getGenericSuperclass();
                type = ((ParameterizedType) types).getActualTypeArguments()[0];
            }else if (callback instanceof RawResultCallBack) {
                type = JSONObject.class;
            } else {
                Type[] types = callback.getClass().getGenericInterfaces();
                type = ((ParameterizedType) types[0]).getActualTypeArguments()[0];
            }

            if (type.equals(Void.class)) {
                callback.onSuccess((T) null);
                return;
            }

            if (type.equals(String.class)) {
                try {
                    callback.onSuccess((T) response.body().string());
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return;
            }


            try {
                StatusResult statusResult;
                if (type instanceof Class && type.equals(StatusResult.class)) {
                    statusResult = gson.fromJson(response.body().string(), StatusResult.class);
                    if (statusResult.isSuccess()) {
                        callback.onSuccess((T) statusResult);
                    } else {
                        callback.onFailure(statusResult.getCode(), statusResult.getMessage());
                    }
                }
                else if(callback instanceof BaseResultCallBack) {
                    String bodyStr = response.body().string();
                    ResultInfos<T> wrapper = gson.fromJson(bodyStr, ResultInfos.class);
                    if (wrapper == null) {
                        callback.onFailure(-1, "response is null");
                        return;
                    }
                    if (wrapper.isSuccess() && wrapper.code == 0) {
                        if (wrapper.data != null && wrapper.data.toString().equalsIgnoreCase("false")) {
                            //添加特殊返回类型false
                            wrapper.data = null;
                        }
                        T t= gson.fromJson(gson.toJson(wrapper.data), type);
                        callback.onSuccess(t);
                    } else {
                        callback.onFailure(wrapper.code, wrapper.msg);
                    }
//                    if (wrapper.code != 0) {
//                        callback.onFailure(wrapper.code, wrapper.msg);
//                        return;
//                    }
//                    if (wrapper.isSuccess() && wrapper.data != null) {
//
//                        T t= gson.fromJson(gson.toJson(wrapper.data), type);
//                        callback.onSuccess(t);
//                    } else {
//                        callback.onFailure(wrapper.code, wrapper.msg);
//                    }
                } else if(callback instanceof BaseIMResultCallBack) {
                    String bodyStr = response.body().string();
                    if (TextUtils.isEmpty(bodyStr)) {
                        callback.onFailure(-1, "response is null");
                        return;
                    }
                    bodyStr = URLDecoder.decode(bodyStr, "UTF-8");
                    ResultIMInfos<T> wrapper = gson.fromJson(bodyStr, ResultIMInfos.class);
                    if (wrapper == null) {
                        callback.onFailure(-1, "response is null");
                        return;
                    }
                    if (wrapper.isSuccess() && wrapper.code == 0) {
                        if (wrapper.result != null && wrapper.result.toString().equalsIgnoreCase("false")) {
                            //添加特殊返回类型false
                            wrapper.result = null;
                        }
                        T t= gson.fromJson(gson.toJson(wrapper.result), type);
                        callback.onSuccess(t);
                    } else {
                        callback.onFailure(wrapper.code, wrapper.message);
                    }
                } else if (callback instanceof RawResultCallBack) {
                    String bodyStr = response.body().string();
                    com.alibaba.fastjson.JSONObject wrapper = com.alibaba.fastjson.JSONObject.parseObject(bodyStr);
                    if (wrapper == null) {
                        callback.onFailure(-1, "response is null");
                        return;
                    }
                    callback.onSuccess((T) wrapper);
                } else {
                    String bodyStr = response.body().string();
                    ResultWrapper<T> wrapper = gson.fromJson(bodyStr, new ResultType(type));
                    if (wrapper == null) {
                        callback.onFailure(-1, "response is null");
                        return;
                    }
                    if (wrapper.isSuccess() && wrapper.getResult() != null) {
                        callback.onSuccess(wrapper.getResult());
                    } else {
                        callback.onFailure(wrapper.getCode(), wrapper.getMessage());
                    }
                }
            } catch (JsonSyntaxException e) {
                e.printStackTrace();
                callback.onFailure(-1, e.getMessage());
            } catch (IOException e) {
                e.printStackTrace();
                callback.onFailure(-1, e.getMessage());
            }
        }
    }

    private static class ResultType implements ParameterizedType {
        private final Type type;

        public ResultType(Type type) {
            this.type = type;
        }

        @Override
        public Type[] getActualTypeArguments() {
            return new Type[]{type};
        }

        @Override
        public Type getOwnerType() {
            return null;
        }

        @Override
        public Type getRawType() {
            return ResultWrapper.class;
        }
    }
}