package com.luticate.utils.dataaccess;

import android.content.Context;
import android.net.Uri;

import com.android.volley.DefaultRetryPolicy;
import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.StringRequest;
import com.android.volley.toolbox.Volley;
import com.luticate.utils.business.LuPromise;
import com.luticate.utils.dbo.LuDataAccessConfigDbo;
import com.luticate.utils.dbo.LuDbo;
import com.luticate.utils.dbo.LuPromiseError;

import org.json.JSONObject;

import java.util.HashMap;
import java.util.Map;

/**
 *
 * Created by robin on 11/27/15.
 */
public class LuRequest {

    private static RequestQueue _requestQueue = null;

    public static void init(Context ctx)
    {
        _requestQueue = Volley.newRequestQueue(ctx.getApplicationContext());
    }

    protected static <T extends LuDbo> Response.Listener<String> getListener(final Class<T> type, final LuPromise<T> promise)
    {
        return new Response.Listener<String>()
        {
            @Override
            public void onResponse(String response) {
                try {
                    T dbo = type.newInstance();
                    JSONObject json = new JSONObject(response);
                    JSONObject obj = null;
                    if (json.has("data")) {
                        obj = json.optJSONObject("data");
                        if (obj == null) {
                            obj = new JSONObject();
                            obj.put("value", json.opt("data"));
                        }
                    }
                    dbo.fromJson(obj);
                    promise.resolve(dbo);
                } catch (Exception e)
                {
                    e.printStackTrace();
                    promise.reject(new LuPromiseError("Failed to parse success server response", 200));
                }
            }
        };
    }

    protected static <T extends LuDbo> Response.ErrorListener getErrorListener(final LuPromise<T> promise)
    {
        return new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                int code = 0;
                try
                {
                    if (error != null) {
                        if (error.networkResponse != null)
                        {
                            code = error.networkResponse.statusCode;
                            JSONObject data = new JSONObject(new String(error.networkResponse.data));
                            promise.reject(new LuPromiseError(data.getString("message"), code));
                        }
                        else {
                            if (error.getCause() != null) {
                                promise.reject(new LuPromiseError(error.getCause().getMessage(), code));
                            }
                            else {
                                promise.reject(new LuPromiseError(error.toString(), code));
                            }
                        }
                    }
                    else {
                        promise.reject(new LuPromiseError("Unknown network error", code));
                    }
                } catch (Exception e)
                {
                    promise.reject(new LuPromiseError(e.getMessage(), code));
                }
            }
        };
    }

    protected static <T extends LuDbo> LuPromise<T> request(final LuDataAccessConfigDbo config,
                                                            int method, Class<T> type, String url,
                                                            final HashMap<String, String> params)
    {
        LuPromise<T> promise = new LuPromise<>();
        StringRequest request = new StringRequest(method, config.getBaseUrl() + url,
                getListener(type, promise), getErrorListener(promise))
        {
            @Override
            public String getBodyContentType() {
                return "application/x-www-form-urlencoded; charset=UTF-8";
            }

            @Override
            protected Map<String, String> getParams() {
                return params;
            }

            @Override
            public Map<String, String> getHeaders() {
                return config.getHeaders();
            }
        };
        request.setRetryPolicy(new DefaultRetryPolicy(10000,
                DefaultRetryPolicy.DEFAULT_MAX_RETRIES,
                DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));
        _requestQueue.add(request);
        return promise;
    }

    public static <T extends LuDbo> LuPromise<T> get(final LuDataAccessConfigDbo config, Class<T> type,
                                                     String url, final HashMap<String, String> getParams)
    {
        Uri.Builder uri = Uri.parse(url).buildUpon();
        for (String key : getParams.keySet())
        {
            uri.appendQueryParameter(key, getParams.get(key));
        }
        LuPromise<T> promise = new LuPromise<>();
        StringRequest request = new StringRequest(Request.Method.GET, config.getBaseUrl() + uri.toString(),
                getListener(type, promise), getErrorListener(promise))
        {
            @Override
            public Map<String, String> getHeaders() {
                return config.getHeaders();
            }
        };
        _requestQueue.add(request);
        return promise;
    }

    public static <T extends LuDbo> LuPromise<T> get(LuDataAccessConfigDbo config, Class<T> type,
                                                     String url)
    {
        return get(config, type, url, new HashMap<String, String>());
    }

    public static <T extends LuDbo> LuPromise<T> post(LuDataAccessConfigDbo config, Class<T> type,
                                                      String url, final HashMap<String, String> postParams)
    {
        return request(config, Request.Method.POST, type, url, postParams);
    }

    public static <T extends LuDbo> LuPromise<T> post(LuDataAccessConfigDbo config, Class<T> type,
                                                      String url)
    {
        return post(config, type, url, new HashMap<String, String>());
    }
}