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.AvatarBean;
import com.shayu.onetoone.bean.ExchangeModel;
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.MessageConsumeConfigBean;
import com.shayu.onetoone.bean.OfficialNoticeBean;
import com.shayu.onetoone.bean.PurseBean;
import com.shayu.onetoone.bean.SystemMessageBean;
import com.shayu.onetoone.bean.TargetUserInfoBean;
import com.shayu.onetoone.bean.UserBean;
import com.shayu.onetoone.network.API;
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.List;

import io.reactivex.android.schedulers.AndroidSchedulers;
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) {
                            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);
                            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) {
                            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 = IMLoginManager.get(mContext).getUserInfo();
        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) {
        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(int 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(int tuid,
                            int type,
                            String giftId,
                            String msg,
                            String time,
                            int online,
                            String method,
                            HttpCallback<HttpCallbackModel> callback) {

        API.get().otoApi(mContext)
                .sendMessage(tuid, type, giftId, msg, time, online, method)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(model -> {
                    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 getMessageConsumeConfig(String toUid, HttpCallback<MessageConsumeConfigBean> callback) {

        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 {
                        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();
    }


    /**
     * 获取系统 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) {
                            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 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 currencyType 1星币 2砖石 3社交新币种
     * @param income       1收入 2支出
     */
    public void getFriendAppMoneyLogModel(String currencyType, String income, HttpCallback<List<FriendAppMoneyLogModel>> callback) {
        API.get().otoApi(mContext).
                getFriendAppMoneyLogModel(currencyType, income)
                .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()
                .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();
    }
}