package com.shayu.onetoone.manager;

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

import com.alibaba.fastjson.JSONObject;
import com.shayu.onetoone.bean.AuthBean;
import com.shayu.onetoone.bean.AuthBloggerBean;
import com.shayu.onetoone.bean.AvatarBean;
import com.shayu.onetoone.bean.ExchangeModel;
import com.shayu.onetoone.bean.ExchangeRecordModel;
import com.shayu.onetoone.bean.FollowBean;
import com.shayu.onetoone.bean.FriendAppMoneyLogModel;
import com.shayu.onetoone.bean.FriendAppMoneySumModel;
import com.shayu.onetoone.bean.GiftBean;
import com.shayu.onetoone.bean.GreetBean;
import com.shayu.onetoone.bean.HomeItemBean;
import com.shayu.onetoone.bean.HomeRankBean;
import com.shayu.onetoone.bean.JoinAnchorBean;
import com.shayu.onetoone.bean.LabelBean;
import com.shayu.onetoone.bean.MatchingInfoBean;
import com.shayu.onetoone.bean.MatchingItemSizeBean;
import com.shayu.onetoone.bean.MessageConsumeConfigBean;
import com.shayu.onetoone.bean.OfficialNoticeBean;
import com.shayu.onetoone.bean.PeopleNum;
import com.shayu.onetoone.bean.PurseBean;
import com.shayu.onetoone.bean.SendConsumeBean;
import com.shayu.onetoone.bean.SystemMessageBean;
import com.shayu.onetoone.bean.TargetUserInfoBean;
import com.shayu.onetoone.bean.UserBean;
import com.shayu.onetoone.bean.UserItemBean;
import com.shayu.onetoone.network.API;
import com.shayu.onetoone.utils.UserManager;
import com.yunbao.common.CommonAppConfig;
import com.yunbao.common.bean.BaseModel;
import com.yunbao.common.bean.HttpCallbackModel;
import com.yunbao.common.bean.IMLoginModel;
import com.yunbao.common.bean.UserAvatarSelectBean;
import com.yunbao.common.http.ResponseModel;
import com.yunbao.common.http.base.HttpCallback;
import com.yunbao.common.manager.IMLoginManager;
import com.yunbao.common.utils.MD5Util;

import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Action;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;
import io.rong.imkit.userinfo.RongUserInfoManager;
import io.rong.imlib.model.UserInfo;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.RequestBody;

/**
 * 网络管理类 使用参考{@link com.yunbao.common.http.live.LiveNetManager}
 */
public class OTONetManager {
    private static final String TAG = "网络请求";
    private static final String SALT = "76576076c1f5f657b634e966c8836a06";
    private static final String DEVICE = "android";
    private Context mContext;
    private static OTONetManager mInstance;


    private OTONetManager(Context context) {
        this.mContext = context;
    }

    public static OTONetManager getInstance(Context context) {
        if (mInstance == null) {
            mInstance = new OTONetManager(context);
        }
        return mInstance;
    }

    /**
     * 手机号登录
     */
    public void login(String phoneNum, String pwd, String uuid, HttpCallback<IMLoginModel> callback) {
        API.get().otoApi(mContext).loginByManager(phoneNum, pwd, uuid, "", "Android")
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<IMLoginModel>>() {
                    @Override
                    public void accept(ResponseModel<IMLoginModel> imLoginModelResponseModel) throws Exception {
                        if (callback != null) {
                            if (imLoginModelResponseModel.isError()) {
                                JSONObject jsonSrc = imLoginModelResponseModel.getSrcJSONOBject();
                                callback.onError(jsonSrc.getJSONObject("data").getString("msg"));
                                return;
                            }
                            IMLoginModel model = imLoginModelResponseModel.getData().getInfo();
                            callback.onSuccess(model);
                        }
                    }
                }, throwable -> {
                    Log.e(TAG, "accept: ", throwable);
                    if (callback != null) {
                        callback.onError(throwable.getMessage());
                    }
                }).isDisposed();
    }

    public void getBaseInfos(boolean isLogin, HttpCallback<UserBean> callback) {
        API.get().otoApi(mContext)
                .getBaseInfos(isLogin ? 1 : 0)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<UserBean>>() {
                    @Override
                    public void accept(ResponseModel<UserBean> liveGiftBeanResponseModel) throws Exception {
                        if (callback != null) {
                            IMLoginModel userInfo = liveGiftBeanResponseModel.getData().getInfo().getUser();
                            UserInfo info = new UserInfo(userInfo.getId() + "", userInfo.getUserNicename(), Uri.parse(userInfo.getAvatar()));
                            info.setExtra(JSONObject.toJSONString(userInfo));
                            RongUserInfoManager.getInstance().refreshUserInfoCache(info);
                            UserManager.saveUserBean(mContext, liveGiftBeanResponseModel.getData().getInfo());
                            callback.onSuccess(liveGiftBeanResponseModel.getData().getInfo());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void getRandJoinAnchor(HttpCallback<JoinAnchorBean> callback) {
        API.get().otoApi(mContext)
                .getRandJoinAnchor()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<JoinAnchorBean>>>() {
                    @Override
                    public void accept(ResponseModel<List<JoinAnchorBean>> model) throws Exception {
                        if (callback != null) {
                            callback.onSuccess(model.getData().getInfo().get(0));
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void getCustomerService(HttpCallback<String> callback) {
        API.get().otoApi(mContext)
                .getCustomerService()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<String>>>() {
                    @Override
                    public void accept(ResponseModel<List<String>> model) throws Exception {
                        if (callback != null) {
                            callback.onSuccess(model.getData().getInfo().get(0));
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void userLoginByThird(String uid,
                                 String openId,
                                 String promCode,
                                 String uuid,
                                 String nickName,
                                 String avatar,
                                 String type,
                                 HttpCallback<IMLoginModel> callback) {
        String sign = MD5Util.getMD5("openid=" + openId + "&" + SALT);
        API.get().otoApi(mContext)
                .userLoginByThird(uid,
                        openId,
                        promCode,
                        uuid,
                        nickName,
                        avatar,
                        CommonAppConfig.IS_GOOGLE_PLAY ? "1" : "3",
                        DEVICE,
                        sign,
                        "Android",
                        type,
                        ""
                )
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<IMLoginModel>>() {
                    @Override
                    public void accept(ResponseModel<IMLoginModel> model) throws Exception {
                        if (callback != null) {
                            callback.onSuccess(model.getData().getInfo());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void getMessageMoreGreetConfig(HttpCallback<List<GreetBean>> callback) {
        API.get().otoApi(mContext)
                .getMessageMoreGreetConfig()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<GreetBean>>>() {
                    @Override
                    public void accept(ResponseModel<List<GreetBean>> liveGiftBeanResponseModel) throws Exception {
                        if (callback != null) {
                            callback.onSuccess(liveGiftBeanResponseModel.getData().getInfo());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void addMessageMoreGreetConfig(String content, String type, HttpCallback<HttpCallbackModel> callback) {
        API.get().otoApi(mContext)
                .addMoreGreetConfig("1", content, type)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<BaseModel>>() {
                    @Override
                    public void accept(ResponseModel<BaseModel> model) throws Exception {
                        if (callback != null) {
                            if (model.isError()) {
                                // {"ret":200,"data":{"code":0,"msg":"操作成功","info":[]},"msg":""}
                                JSONObject json = model.getSrcJSONOBject();
                                callback.onSuccess(new HttpCallbackModel(json.getJSONObject("data").getInteger("code"),
                                        json.getJSONObject("data").getString("msg")));
                            } else {
                                callback.onSuccess(new HttpCallbackModel(model.getData().getCode(), model.getData().getMsg()));
                            }
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void setMoreGreetConfig(String id, String content, String type, HttpCallback<HttpCallbackModel> callback) {
        API.get().otoApi(mContext)
                .setMoreGreetConfig(id, "1", content, type)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<BaseModel>>() {
                    @Override
                    public void accept(ResponseModel<BaseModel> model) throws Exception {
                        if (callback != null) {
                            callback.onSuccess(new HttpCallbackModel(model.getData().getCode(), model.getData().getMsg()));
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void removeMoreGreetConfig(String id, HttpCallback<HttpCallbackModel> callback) {
        API.get().otoApi(mContext)
                .removeMoreGreetConfig(id)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<BaseModel>>() {
                    @Override
                    public void accept(ResponseModel<BaseModel> model) throws Exception {
                        if (callback != null) {
                            callback.onSuccess(new HttpCallbackModel(model.getData().getCode(), model.getData().getMsg()));
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void cleanMoreGreetConfig(HttpCallback<HttpCallbackModel> callback) {
        API.get().otoApi(mContext)
                .cleanMoreGreetConfig()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<BaseModel>>() {
                    @Override
                    public void accept(ResponseModel<BaseModel> model) throws Exception {
                        if (callback != null) {
                            callback.onSuccess(new HttpCallbackModel(model.getData().getCode(), model.getData().getMsg()));
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void getGreetConfigStatus(HttpCallback<Boolean> callback) {
        API.get().otoApi(mContext)
                .getGreetConfigStatus()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<Integer>>() {
                    @Override
                    public void accept(ResponseModel<Integer> model) throws Exception {
                        if (callback != null) {
                            callback.onSuccess(model.getData().getInfo() == 2);
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void setGreetConfigGreet(boolean status, HttpCallback<HttpCallbackModel> callback) {
        API.get().otoApi(mContext)
                .setGreetConfigGreet("1", status ? "2" : "1")
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<BaseModel>>() {
                    @Override
                    public void accept(ResponseModel<BaseModel> model) throws Exception {
                        if (callback != null) {
                            callback.onSuccess(new HttpCallbackModel(model.getData().getCode(), model.getData().getMsg()));
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void updateFile(File file, HttpCallback<AvatarBean> callback) {
        MultipartBody.Part uploadFile = createUploadFile(file);
        IMLoginModel userInfo = UserManager.getUserBean().getUser();
        API.get().otoApi(mContext)
                .updateFile(uploadFile, userInfo.getId() + "", userInfo.getToken())
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<AvatarBean>>() {
                    @Override
                    public void accept(ResponseModel<AvatarBean> model) throws Exception {
                        if (callback != null) {
                            callback.onSuccess(model.getData().getInfo());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void getMessageSystemLists(HttpCallback<List<OfficialNoticeBean>> callback) {
        API.get().otoApi(mContext)
                .getLists()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<OfficialNoticeBean>>>() {
                    @Override
                    public void accept(ResponseModel<List<OfficialNoticeBean>> model) throws Exception {
                        if (callback != null) {
                            callback.onSuccess(model.getData().getInfo());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void getTargetUserInfoList(List<Integer> ids, HttpCallback<List<TargetUserInfoBean>> callback) {
        if (ids.isEmpty()) {
            callback.onSuccess(new ArrayList<>());
            return;
        }
        StringBuilder sb = new StringBuilder();
        for (Integer id : ids) {
            sb.append(id).append(",");
        }
        API.get().otoApi(mContext)
                .getTargetUserInfoList(sb.toString())
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<TargetUserInfoBean>>>() {
                    @Override
                    public void accept(ResponseModel<List<TargetUserInfoBean>> model) throws Exception {
                        if (callback != null) {
                            callback.onSuccess(model.getData().getInfo());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void getTargetUserInfo(long toUid, HttpCallback<UserBean> callback) {

        API.get().otoApi(mContext)
                .getTargetUserInfo(toUid)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<UserBean>>() {
                    @Override
                    public void accept(ResponseModel<UserBean> model) throws Exception {
                        if (callback != null) {
                            callback.onSuccess(model.getData().getInfo());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void getHomeHot(String page, HttpCallback<List<HomeItemBean>> callback) {

        API.get().otoApi(mContext)
                .getHomeHot(page)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<HomeItemBean>>>() {
                    @Override
                    public void accept(ResponseModel<List<HomeItemBean>> model) throws Exception {
                        if (callback != null) {
                            callback.onSuccess(model.getData().getInfo());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void getHomeRecommend(String page, HttpCallback<List<HomeItemBean>> callback) {

        API.get().otoApi(mContext)
                .getHomeRecommend(page)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<HomeItemBean>>>() {
                    @Override
                    public void accept(ResponseModel<List<HomeItemBean>> model) throws Exception {
                        if (callback != null) {
                            callback.onSuccess(model.getData().getInfo());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void getSystemMessageList(int type, HttpCallback<List<SystemMessageBean>> callback) {

        API.get().otoApi(mContext)
                .getSystemMessageList(type)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<SystemMessageBean>>>() {
                    @Override
                    public void accept(ResponseModel<List<SystemMessageBean>> model) throws Exception {
                        if (callback != null) {
                            callback.onSuccess(model.getData().getInfo());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void sendMessage(String tuid,
                            int type,
                            String giftId,
                            String msg,
                            String time,
                            int online,
                            String method,
                            HttpCallback<SendConsumeBean> callback) {

        API.get().otoApi(mContext)
                .sendMessage(tuid, type, giftId, msg, time, online, method)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(model -> {
                    if (callback != null) {
                        if (model.isError()) {
                            JSONObject json = JSONObject.parseObject(model.getJsonSrc());
                            SendConsumeBean bean = new SendConsumeBean();
                            bean.setCode(json.getJSONObject("data").getInteger("code"));
                            bean.setMsg(json.getJSONObject("data").getString("msg"));
                            callback.onSuccess(bean);
                            return;
                        }
                        SendConsumeBean bean = model.getData().getInfo();
                        bean.setCode(model.getData().getCode());
                        bean.setMsg(model.getData().getMsg());
                        callback.onSuccess(bean);
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void sendMessageBefore(String tuid,
                                  int type,
                                  String giftId,
                                  String msg,
                                  String time,
                                  int online,
                                  String method,
                                  HttpCallback<SendConsumeBean> callback) {

        API.get().otoApi(mContext)
                .sendMessageBefore(tuid, type, giftId, msg, time, online, method)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(model -> {
                    if (callback != null) {
                        if (model.isError()) {
                            JSONObject json = JSONObject.parseObject(model.getJsonSrc());
                            SendConsumeBean bean = new SendConsumeBean();
                            bean.setCode(json.getJSONObject("data").getInteger("code"));
                            bean.setMsg(json.getJSONObject("data").getString("msg"));
                            callback.onSuccess(bean);
                            return;
                        }
                        SendConsumeBean bean = model.getData().getInfo();
                        bean.setCode(model.getData().getCode());
                        bean.setMsg(model.getData().getMsg());
                        callback.onSuccess(bean);
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }


    public void getMessageConsumeConfig(String toUid, HttpCallback<MessageConsumeConfigBean> callback) {
        if (CacheManager.consumeCache.containsKey(toUid) && CacheManager.consumeCache.get(toUid) != null) {
            callback.onSuccess(CacheManager.consumeCache.get(toUid));
            return;
        }
        API.get().otoApi(mContext)
                .getMessageConsumeConfig(toUid)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<MessageConsumeConfigBean>>() {
                    @Override
                    public void accept(ResponseModel<MessageConsumeConfigBean> model) throws Exception {
                        CacheManager.consumeCache.put(toUid,model.getData().getInfo());
                        if (callback != null) {
                            callback.onSuccess(model.getData().getInfo());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void getGiftList(HttpCallback<List<GiftBean>> callback) {

        API.get().otoApi(mContext)
                .getGiftList()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(model -> {
                    if (callback != null) {
                        callback.onSuccess(model.getData().getInfo());
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void getPurseInfo(HttpCallback<PurseBean> callback) {

        API.get().otoApi(mContext)
                .getPurseInfo()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(model -> {
                    if (callback != null) {
                        callback.onSuccess(model.getData().getInfo());
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void follow(String toUid, HttpCallback<FollowBean> callback) {

        API.get().otoApi(mContext)
                .follow(toUid)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe((Consumer<ResponseModel<List<FollowBean>>>) model -> {
                    if (callback != null) {
                        callback.onSuccess(model.getData().getInfo().get(0));
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void getHomeRank(String type, String date, HttpCallback<List<HomeRankBean>> callback) {

        API.get().otoApi(mContext)
                .getHomeRank(type, date)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(model -> {
                    if (callback != null) {
                        callback.onSuccess(model.getData().getInfo());
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void search(String keyword,
                       String age,
                       String name_auth,
                       String sex,
                       String page,
                       HttpCallback<List<HomeItemBean>> callback) {

        API.get().otoApi(mContext)
                .search(keyword, age, name_auth, sex, "", page)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(model -> {
                    if (callback != null) {
                        callback.onSuccess(model.getData().getInfo());
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void getSearchRecommend(HttpCallback<List<HomeItemBean>> callback) {

        API.get().otoApi(mContext)
                .getSearchRecommend()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<HomeItemBean>>>() {
                    @Override
                    public void accept(ResponseModel<List<HomeItemBean>> model) throws Exception {
                        if (callback != null) {
                            callback.onSuccess(model.getData().getInfo());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    private MultipartBody.Part createUploadFile(File file) {
        RequestBody requestBody = RequestBody.create(MediaType.parse("multipart/form-data"), file);
        return MultipartBody.Part.createFormData("file", file.getName(), requestBody);
    }

    /**
     * 获取系统头像
     *
     * @param callback
     */
    public void getSystemUserAvatar(HttpCallback<List<UserAvatarSelectBean>> callback) {
        API.get().otoApi(mContext)
                .getSystemUserAvatar(CommonAppConfig.getInstance().getUid())
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<UserAvatarSelectBean>>>() {
                    @Override
                    public void accept(ResponseModel<List<UserAvatarSelectBean>> objectResponseModel) throws Exception {
                        if (objectResponseModel.getData().getCode() == 0) {
                            callback.onSuccess(objectResponseModel.getData().getInfo());
                        } else {
                            callback.onError(objectResponseModel.getData().getMsg());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    /**
     * 设置基本资料
     */
    public void setInfo(
            String avatar,
            String user_nicename,
            int sex,
            String birthday,
            HttpCallback<HttpCallbackModel> callback) {

        API.get().otoApi(mContext).setInfo(avatar, user_nicename, sex, birthday)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<BaseModel>>>() {
                    @Override
                    public void accept(ResponseModel<List<BaseModel>> listResponseModel) throws Exception {
                        if (listResponseModel.getData().getCode() == 0) {
                            callback.onSuccess(new HttpCallbackModel(listResponseModel.getData().getCode(), listResponseModel.getData().getMsg()));
                        } else {
                            callback.onError(listResponseModel.getData().getMsg());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {

                    }
                }).isDisposed();
    }


    /**
     * 达人认证
     *
     * @param callback
     */
    public void authSage(
            String name, String mobile, String card_no, String card_img, String img, int sex,
            HttpCallback<HttpCallbackModel> callback) {

        API.get().otoApi(mContext)
                .authSage(name, mobile, card_no, card_img, img, sex)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<BaseModel>>>() {
                    @Override
                    public void accept(ResponseModel<List<BaseModel>> listResponseModel) throws Exception {
                        if (listResponseModel.getData().getCode() == 0) {
                            callback.onSuccess(new HttpCallbackModel(listResponseModel.getData().getCode(), listResponseModel.getData().getMsg()));
                        } else {
                            callback.onError(listResponseModel.getData().getMsg());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {

                    }
                }).isDisposed();
    }

    /**
     * 获取达人认证信息
     *
     * @param callback
     */
    public void getAuthBloggerInfo(HttpCallback<AuthBloggerBean> callback) {
        API.get().otoApi(mContext)
                .getBloggerInfo()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<AuthBloggerBean>>() {
                    @Override
                    public void accept(ResponseModel<AuthBloggerBean> listResponseModel) throws Exception {
                        if (listResponseModel.getData().getCode() == 0) {
                            callback.onSuccess(listResponseModel.getData().getInfo());
                        } else {
                            callback.onError(listResponseModel.getData().getMsg());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }


    /**
     * 获取系统 Label
     *
     * @param callback
     */
    public void getSysLabel(HttpCallback<List<LabelBean>> callback) {
        API.get().otoApi(mContext)
                .getSysLabel()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<LabelBean>>>() {
                    @Override
                    public void accept(ResponseModel<List<LabelBean>> objectResponseModel) throws Exception {
                        if (objectResponseModel.getData().getCode() == 0) {
                            UserManager.saveUserTag(objectResponseModel.getData().getInfo());
                            callback.onSuccess(objectResponseModel.getData().getInfo());
                        } else {
                            callback.onError(objectResponseModel.getData().getMsg());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void getUserItems(String page, HttpCallback<List<UserItemBean>> callback) {
        API.get().otoApi(mContext)
                .getUserItems(page)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(model -> {
                    if (callback != null) {
                        callback.onSuccess(model.getData().getInfo());
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void getMatchingNum(HttpCallback<MatchingItemSizeBean> callback) {
        API.get().otoApi(mContext)
                .getMatchingNum()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(model -> {
                    if (callback != null) {
                        callback.onSuccess(model.getData().getInfo());
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }


    public void getMatchingInfo(HttpCallback<MatchingInfoBean> callback) {

        API.get().otoApi(mContext)
                .getMatchingInfo()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(model -> {
                    if (callback != null) {
                        callback.onSuccess(model.getData().getInfo());
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void getChatTips(String toUid, HttpCallback<JSONObject> callback) {

        API.get().otoApi(mContext)
                .getChatTips(toUid)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(model -> {
                    if (callback != null) {
                        callback.onSuccess(JSONObject.parseObject(model.getJsonSrc()));
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void updateChatTips(String toUid, HttpCallback<BaseModel> callback) {

        API.get().otoApi(mContext)
                .updateChatTips(toUid)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(model -> {
                    if (callback != null) {
                        callback.onSuccess(null);
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    /**
     * 设置基本资料
     */
    public void setLabels(
            String labels,
            HttpCallback<HttpCallbackModel> callback) {

        API.get().otoApi(mContext).setLabels(labels)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<BaseModel>>>() {
                    @Override
                    public void accept(ResponseModel<List<BaseModel>> listResponseModel) throws Exception {
                        if (listResponseModel.getData().getCode() == 0) {
                            callback.onSuccess(new HttpCallbackModel(listResponseModel.getData().getCode(), listResponseModel.getData().getMsg()));
                        } else {
                            callback.onError(listResponseModel.getData().getMsg());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {

                    }
                }).isDisposed();
    }

    /**
     * 设置
     *
     * @param key 'signature' => "签名",
     *            'sex' => "性别",
     *            'user_nicename' => "昵称",
     *            'avatar' => "头像",
     *            'birthday' => "生日",
     *            'area' => "地区"
     *            is_login=> 首次登录
     *            is_chat=>聊天首次登录
     */

    public void setFiled(
            String key, String val,
            HttpCallback<HttpCallbackModel> callback) {

        API.get().otoApi(mContext).setFiled(key, val)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<BaseModel>>>() {
                    @Override
                    public void accept(ResponseModel<List<BaseModel>> listResponseModel) throws Exception {
                        if (listResponseModel.getData().getCode() == 0) {
                            if (callback != null) {
                                callback.onSuccess(new HttpCallbackModel(listResponseModel.getData().getCode(), listResponseModel.getData().getMsg()));
                            }
                        } else {
                            if (callback != null) {
                                callback.onError(listResponseModel.getData().getMsg());
                            }
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {

                    }
                }).isDisposed();
    }

    /**
     * 實名認證
     */
    public void setAuthInfo(
            String authFront, String authBack,
            HttpCallback<HttpCallbackModel> callback) {

        API.get().otoApi(mContext).setAuthInfo(authFront, authBack)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<BaseModel>>>() {
                    @Override
                    public void accept(ResponseModel<List<BaseModel>> listResponseModel) throws Exception {
                        if (listResponseModel.getData().getCode() == 0) {
                            callback.onSuccess(new HttpCallbackModel(listResponseModel.getData().getCode(), listResponseModel.getData().getMsg()));
                        } else {
                            callback.onError(listResponseModel.getData().getMsg());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {

                    }
                }).isDisposed();
    }

    /**
     * 获取实名认证
     *
     * @param callback
     */
    public void getAuthInfo(HttpCallback<AuthBean> callback) {
        API.get().otoApi(mContext)
                .getAuthInfo()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(model -> {
                    if (callback != null) {
                        callback.onSuccess(model.getData().getInfo());
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "accept: ", throwable);
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    /**
     * @param currencyType 1星币 2砖石 3社交新币种
     * @param income       1收入 2支出
     */
    public void getFriendAppMoneyLogModel(String currencyType, String income, int page, HttpCallback<List<FriendAppMoneyLogModel>> callback) {
        API.get().otoApi(mContext).
                getFriendAppMoneyLogModel(currencyType, income, page)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<FriendAppMoneyLogModel>>>() {
                    @Override
                    public void accept(ResponseModel<List<FriendAppMoneyLogModel>> listResponseModel) throws Exception {
                        if (listResponseModel.getData().getCode() == 0) {
                            callback.onSuccess(listResponseModel.getData().getInfo());
                        } else {
                            callback.onError(listResponseModel.getData().getMsg());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void getFriendAppMoneySum(HttpCallback<FriendAppMoneySumModel> callback) {
        API.get().otoApi(mContext).
                getFriendAppMoneySum(3, 1)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<FriendAppMoneySumModel>>() {
                    @Override
                    public void accept(ResponseModel<FriendAppMoneySumModel> friendAppMoneySumModelResponseModel) throws Exception {
                        if (friendAppMoneySumModelResponseModel.getData().getCode() == 0) {
                            callback.onSuccess(friendAppMoneySumModelResponseModel.getData().getInfo());
                        } else {
                            callback.onError(friendAppMoneySumModelResponseModel.getData().getMsg());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    /**
     * @param type     coin砖石  yuanbao 星币
     * @param callback
     */
    public void getExchangeList(String type, HttpCallback<List<ExchangeModel>> callback) {
        API.get().otoApi(mContext).
                getExchangeList(type)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<ExchangeModel>>>() {
                    @Override
                    public void accept(ResponseModel<List<ExchangeModel>> listResponseModel) throws Exception {
                        if (listResponseModel.getData().getCode() == 0) {
                            callback.onSuccess(listResponseModel.getData().getInfo());
                        } else {
                            callback.onError(listResponseModel.getData().getMsg());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    /**
     * 收益转换星币或砖石
     *
     * @param type     coin砖石  yuanbao 星币
     * @param number   转换 星币 或 砖石 数量
     * @param callback
     */
    public void getTransform(String type, String number, HttpCallback<List<ExchangeModel>> callback) {
        API.get().otoApi(mContext).
                getTransform(type, number)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<ExchangeModel>>>() {
                    @Override
                    public void accept(ResponseModel<List<ExchangeModel>> listResponseModel) throws Exception {
                        if (listResponseModel.getData().getCode() == 0) {
                            callback.onSuccess(listResponseModel.getData().getInfo());
                        } else {
                            callback.onError(listResponseModel.getData().getMsg());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    /**
     * @param type         10 转换星币 11转换砖石
     * @param currencyType 1星币 2砖石 3社交新币种
     * @param income       1收入 2支出
     * @param page
     * @param callback
     */
    public void getExchangeRecord(String type, String currencyType, String income, int page, HttpCallback<List<ExchangeRecordModel>> callback) {
        API.get().otoApi(mContext).
                getExchangeRecord(type, currencyType, income, page)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<ExchangeRecordModel>>>() {
                    @Override
                    public void accept(ResponseModel<List<ExchangeRecordModel>> listResponseModel) throws Exception {
                        if (listResponseModel.getData().getCode() == 0) {
                            callback.onSuccess(listResponseModel.getData().getInfo());
                        } else {
                            callback.onError(listResponseModel.getData().getMsg());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }


    public void updatePass(
            String name, String mobile, String card_no,
            HttpCallback<HttpCallbackModel> callback) {

        API.get().otoApi(mContext)
                .updaePass(name, mobile, card_no)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<BaseModel>>>() {
                    @Override
                    public void accept(ResponseModel<List<BaseModel>> listResponseModel) throws Exception {
                        if (listResponseModel.getData().getCode() == 0) {
                            callback.onSuccess(new HttpCallbackModel(listResponseModel.getData().getCode(), listResponseModel.getData().getMsg()));
                        } else {
                            callback.onError(listResponseModel.getData().getMsg());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {

                    }
                }).isDisposed();
    }

    public void getFriends(int page, HttpCallback<List<HomeItemBean>> callback) {
        API.get().otoApi(mContext).
                getFriends(page + "")
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(listResponseModel -> {
                    if (listResponseModel.getData().getCode() == 0) {
                        callback.onSuccess(listResponseModel.getData().getInfo());
                    } else {
                        callback.onError(listResponseModel.getData().getMsg());
                    }
                }, throwable -> {
                    if (callback != null) {
                        callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                    }
                }).isDisposed();
    }

    public void getFollows(int page, HttpCallback<List<HomeItemBean>> callback) {
        API.get().otoApi(mContext).
                getFollows(page + "")
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(listResponseModel -> {
                    if (listResponseModel.getData().getCode() == 0) {
                        callback.onSuccess(listResponseModel.getData().getInfo());
                    } else {
                        callback.onError(listResponseModel.getData().getMsg());
                    }
                }, throwable -> {
                    if (callback != null) {
                        callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                    }
                }).isDisposed();
    }

    public void getFans(int page, HttpCallback<List<HomeItemBean>> callback) {
        API.get().otoApi(mContext).
                getFans(page + "")
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(listResponseModel -> {
                    if (listResponseModel.getData().getCode() == 0) {
                        callback.onSuccess(listResponseModel.getData().getInfo());
                    } else {
                        callback.onError(listResponseModel.getData().getMsg());
                    }
                }, throwable -> {
                    if (callback != null) {
                        callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                    }
                }).isDisposed();
    }

    public void getPeopleNum(HttpCallback<PeopleNum> callback) {
        API.get().otoApi(mContext).
                getPeopleNum()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(listResponseModel -> {
                    if (listResponseModel.getData().getCode() == 0) {
                        callback.onSuccess(listResponseModel.getData().getInfo());
                    } else {
                        callback.onError(listResponseModel.getData().getMsg());
                    }
                }, throwable -> {
                    if (callback != null) {
                        callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                    }
                }).isDisposed();
    }


    public void getMenu(HttpCallback<List<UserItemBean>> callback) {
        API.get().otoApi(mContext).
                getMenu()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseModel<List<UserItemBean>>>() {
                    @Override
                    public void accept(ResponseModel<List<UserItemBean>> listResponseModel) throws Exception {
                        if (listResponseModel.getData().getCode() == 0) {
                            callback.onSuccess(listResponseModel.getData().getInfo());
                        } else {
                            callback.onError(listResponseModel.getData().getMsg());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        if (callback != null) {
                            callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                        }
                    }
                }).isDisposed();
    }

    public void messageReadAll(HttpCallback<HttpCallbackModel> callback) {
        API.get().otoApi(mContext).
                messageReadAll()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(listResponseModel -> {
                    if (listResponseModel.getData().getCode() == 0) {
                        if (callback != null) {
                            callback.onSuccess(new HttpCallbackModel(listResponseModel.getData().getCode(), listResponseModel.getData().getMsg()));
                        }
                    } else {
                        if (callback != null) {
                            callback.onError(listResponseModel.getData().getMsg());
                        }
                    }
                }, throwable -> {
                    if (callback != null) {
                        callback.onError(mContext.getString(com.yunbao.common.R.string.net_error));
                    }
                }).isDisposed();
    }


}