package com.hc.webapp.other;

import android.support.annotation.NonNull;

import com.hc.request.core.CallServer;
import com.hc.request.core.DefaultCallback;
import com.hc.request.core.IHttpCallback;
import com.orhanobut.logger.Logger;
import com.yanzhenjie.nohttp.RequestMethod;
import com.yanzhenjie.nohttp.rest.StringRequest;

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

import java.util.Random;

/**
 * @author jewel
 * @email jewelbao88@gmail.com
 * @gitsite https://github.com/jewelbao
 * @since 2019/1/9
 */
public class ThirdPartPlatform {

    private static final int STEP_FIRST = 100;
    private static final int STEP_SECOND = 200;
    private static final int STEP_THIRD = 300;
    private static final int STEP_FOURTH = 400;
    private static final int STEP_FINAL = 500;

    public void start(String firstStepUrl, String secondStepUrl, String thirdStepUrl, String fourStepUrl, int k, final IHttpCallback<String> callback) {
        StringRequest request = new StringRequest(firstStepUrl, RequestMethod.GET);
        CallServer.getInstance().requestString(STEP_FIRST, request, new DefaultCallback<String>() {

            @Override
            public void onSuccess(int what, @NonNull String data) {
                //Log.d(TAG,"第一步:" + bodyStr);
                Logger.d("智慧平台请求第一步成功：%s", data);
                new Thread(() -> secondStep(secondStepUrl, thirdStepUrl, fourStepUrl, k, callback)).start();
            }

            @Override
            public void onError(int what, Throwable e) {
                callback.onError(STEP_FIRST, e);
                Logger.e(e, "智慧平台请求发生异常");
            }
        });
    }

    private void secondStep(String secondStepUrl, String thirdStepUrl, String fourStepUrl, int k, final IHttpCallback<String> callback) {
        if (callback == null) {
            return;
        }
        try {
            final int delayTime = getNum(2, 6);
            Logger.d("延迟%s秒", delayTime);
            Thread.sleep(delayTime * 1000);
            StringRequest request = new StringRequest(secondStepUrl, RequestMethod.POST);
            request.add("k", k);
            CallServer.getInstance().requestString(STEP_SECOND, request, new DefaultCallback<String>() {

                @Override
                public void onSuccess(int what, @NonNull String data) {
                    Logger.d("智慧平台请求第二步成功：%s", data);
                    new Thread(() -> thirdStep(thirdStepUrl, fourStepUrl, callback)).start();
                }

                @Override
                public void onError(int what, Throwable e) {
                    callback.onError(STEP_SECOND, e);
                    Logger.e(e, "智慧平台第二步请求发生异常");
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
            callback.onError(STEP_SECOND, e);
            Logger.e(e, "智慧平台第二步逻辑处理异常");
        }
    }

    private void thirdStep(String thirdStepUrl, String fourStepUrl, final IHttpCallback<String> callback) {
        if (callback == null) {
            return;
        }
        try {
            final int delayTime = getNum(5, 9);
            Logger.d("延迟%s秒", delayTime);
            Thread.sleep(delayTime * 1000);
            StringRequest request = new StringRequest(thirdStepUrl, RequestMethod.GET);
            CallServer.getInstance().requestString(STEP_THIRD, request, new DefaultCallback<String>() {

                @Override
                public void onSuccess(int what, @NonNull String data) {
                    Logger.d("智慧平台请求第三步成功：%s", data);
                    thirdStepJudge(data, fourStepUrl, callback);
                }

                @Override
                public void onError(int what, Throwable e) {
                    callback.onError(STEP_THIRD, e);
                    Logger.e(e, "智慧平台第三步请求发生异常");
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
            callback.onError(STEP_THIRD, e);
            Logger.e(e, "智慧平台第三步逻辑处理异常");
        }
    }

    private void thirdStepJudge(String data, String fourStepUrl, IHttpCallback<String> callback) {
        try {
            JSONObject thirdResult = new JSONObject(data);
            if (thirdResult.has("result")) {
                String result = thirdResult.getString("result");
                if (result.equals("2")) {
                    new Thread(() -> fourthStep(fourStepUrl, callback)).start();
                } else {
                    callback.onFail(STEP_THIRD, data);
                }
            }
        } catch (JSONException e) {
            e.printStackTrace();
            callback.onError(STEP_THIRD, e);
            Logger.e(e, "智慧平台第三步逻辑处理异常");
        }
    }

    private void fourthStep(String fourStepUrl, final IHttpCallback<String> callback) {
        if (callback == null) {
            return;
        }
        try {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("productid", "");
            jsonObject.put("serviceid", "");
            jsonObject.put("name", "");
            jsonObject.put("price", "");
            jsonObject.put("producttype", "");
            jsonObject.put("starttime", "");
            jsonObject.put("endtime", "");
            jsonObject.put("continueable", "");
            jsonObject.put("point", "");
            jsonObject.put("authflag", "");
            jsonObject.put("contentid", "");

            StringRequest request = new StringRequest(fourStepUrl, RequestMethod.POST);
            request.setDefineRequestBodyForJson(jsonObject.toString());
            CallServer.getInstance().requestString(STEP_FOURTH, request, new DefaultCallback<String>() {

                @Override
                public void onSuccess(int what, @NonNull String data) {
                    super.onSuccess(what, data);
                    Logger.d("智慧平台请求第四步成功：%s", data);
                    try {
                        finalStep(data, callback);
                    } catch (JSONException e) {
                        e.printStackTrace();
                        callback.onError(STEP_FINAL, e);
                        Logger.e(e, "智慧平台最终请求发生异常");
                    }
                }

                @Override
                public void onError(int what, Throwable e) {
                    super.onError(what, e);
                    callback.onError(STEP_FOURTH, e);
                    Logger.e(e, "智慧平台第四步请求发生异常");
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
            callback.onError(STEP_FOURTH, e);
            Logger.e(e, "智慧平台第四步逻辑处理异常");
        }
    }

    private void finalStep(String data, IHttpCallback<String> callback) throws JSONException {
        if (callback == null) {
            return;
        }
        JSONObject fourthResult = new JSONObject(data);
        if (fourthResult.has("result")) {
            String result = fourthResult.getString("result");
            if (result.equals("true")) {
                callback.onSuccess(STEP_FINAL, data);
            } else {
                callback.onFail(STEP_FINAL, data);
            }
        }
    }

    private int getNum(int startNum, int endNum) {
        if (endNum > startNum) {
            Random random = new Random();
            return random.nextInt(endNum - startNum) + startNum;
        }
        return 0;
    }
}