package com.benyanyi.okhttp.call;

import android.content.Context;

import com.benyanyi.okhttp.config.CallType;
import com.benyanyi.okhttp.listener.OnOkHttpListener;
import com.benyanyi.okhttp.util.CacheUtils;
import com.benyanyi.okhttp.util.FormatUtil;
import com.benyanyi.okhttp.util.Internet;
import com.benyanyi.okhttp.util.InternetBean;
import com.benyanyi.okhttp.util.OkHttpLog;

import java.io.IOException;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.Disposable;
import io.reactivex.schedulers.Schedulers;
import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.Response;
import okhttp3.ResponseBody;

/**
 * @author YanYi
 * @date 2019-08-12 09:43
 * @email ben@yanyi.red
 * @overview
 */
class ObjectCall {
    private CallType callType;
    private Call call;
    private boolean isCache;//是否需要缓存
    private String mCacheName;//缓存名称
    private Context context;
    private OnOkHttpListener<Object> onOkHttpListener;

    ObjectCall(CallBuilder builder) {
        this.callType = builder.getCallType();
        this.call = builder.getCall();
        this.isCache = builder.isCache();
        this.mCacheName = builder.getCacheName();
        this.context = builder.getContext();
    }

    void send(OnOkHttpListener<Object> okHttpListener) {
        this.onOkHttpListener = okHttpListener;
        InternetBean internetBean = Internet.ifInternet(context);
        if (internetBean.getStatus()) {
            sendCall().subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .serialize()
                    .subscribe(new Observer<Object>() {
                        @Override
                        public void onSubscribe(Disposable d) {

                        }

                        @Override
                        public void onNext(Object o) {
                            onOkHttpListener.onSuccess(o);
                        }

                        @Override
                        public void onError(Throwable e) {
                            onOkHttpListener.onFailure(e);
                        }

                        @Override
                        public void onComplete() {
                            onOkHttpListener.onCompleted();
                        }
                    });
        } else {
            if (isCache) {
                String str = CacheUtils.getInstance(context).getCacheToLocalJson(mCacheName);
                onOkHttpListener.onSuccess(str);
            }
            onOkHttpListener.onFailure(new Exception(internetBean.getMsg()));
            onOkHttpListener.onCompleted();
        }
    }

    private Observable<Object> sendCall() {
        return Observable.create(new ObservableOnSubscribe<Object>() {
            @Override
            public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
                send(emitter);
            }
        });
    }

    private void send(ObservableEmitter<Object> emitter) {
        if (callType == CallType.ASYNC) {
            async(emitter);
        } else {
            sync(emitter);
        }
    }

    private void async(final ObservableEmitter<Object> emitter) {
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                OkHttpLog.e(e.getMessage());
                emitter.onError(e);
                emitter.onComplete();
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                success(response, emitter);
            }
        });
    }

    private void sync(ObservableEmitter<Object> emitter) {
        try {
            Response response = call.execute();
            success(response, emitter);
        } catch (IOException e) {
            OkHttpLog.e(e.getMessage());
            emitter.onError(e);
            emitter.onComplete();
        }
    }

    private void success(Response response, ObservableEmitter<Object> emitter) throws IOException {
        ResponseBody body = response.body();
        if (body != null) {
            if (response.isSuccessful()) {
                if (response.networkResponse() != null) {//网络请求有数据
                    String str = body.string();
                    emitter.onNext(dataProcessing(str));
                    emitter.onComplete();
                } else {
                    dataReturn(body.string(), emitter);
                }
            } else {
                dataReturn(body.string(), emitter);
            }
        } else {
            dataReturn(null, emitter);
        }
    }

    /**
     * 数据处理
     */
    private String dataProcessing(String message) {
        String str = message;
        OkHttpLog.d(str);
        String html = "<!DOCTYPE HTML>";
        if (!str.toUpperCase().contains(html)) {
            if (FormatUtil.isNotEmpty(mCacheName)) {
                CacheUtils.getInstance(context).setCacheToLocalJson(mCacheName, str);
            }
        } else {
            if (isCache) {
                str = CacheUtils.getInstance(context).getCacheToLocalJson(mCacheName);
            }
        }
        return str;
    }

    /**
     * 数据返回
     *
     * @param message
     * @param emitter
     */
    private void dataReturn(String message, ObservableEmitter<Object> emitter) {
        if (isCache) {
            emitter.onNext(CacheUtils.getInstance(context).getCacheToLocalJson(mCacheName));
            emitter.onComplete();
        } else {
            emitter.onNext(dataProcessing(message));
            emitter.onComplete();
        }
    }
}