package com.xscm.moduleutil.http;

//import com.blankj.utilcode.util.LogUtils;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;

import com.blankj.utilcode.util.GsonUtils;
import com.blankj.utilcode.util.LogUtils;
import com.blankj.utilcode.util.ToastUtils;
import com.franmontiel.persistentcookiejar.ClearableCookieJar;
import com.franmontiel.persistentcookiejar.PersistentCookieJar;
import com.franmontiel.persistentcookiejar.cache.SetCookieCache;
import com.franmontiel.persistentcookiejar.persistence.SharedPrefsCookiePersistor;
import com.google.gson.reflect.TypeToken;
import com.xscm.moduleutil.base.CommonAppContext;
import com.xscm.moduleutil.bean.AlbumBean;
import com.xscm.moduleutil.bean.AppPay;
import com.xscm.moduleutil.bean.AppUpdateModel;
import com.xscm.moduleutil.bean.BannerModel;
import com.xscm.moduleutil.bean.BindType;
import com.xscm.moduleutil.bean.BlackUserBean;
import com.xscm.moduleutil.bean.CharmRankingResp;
import com.xscm.moduleutil.bean.CircleListBean;
import com.xscm.moduleutil.bean.CommentBean;
import com.xscm.moduleutil.bean.ExpandColumnBean;
import com.xscm.moduleutil.bean.FirstChargeBean;
import com.xscm.moduleutil.bean.FirstChargeGiftBean;
import com.xscm.moduleutil.bean.GiftBean;
import com.xscm.moduleutil.bean.GiftBoxBean;
import com.xscm.moduleutil.bean.GiftBoxRecordBean;
import com.xscm.moduleutil.bean.GiftLabelBean;
import com.xscm.moduleutil.bean.GiftName;
import com.xscm.moduleutil.bean.GiftPackBean;
import com.xscm.moduleutil.bean.GiftPackListCount;
import com.xscm.moduleutil.bean.GiftUserWallBean;
import com.xscm.moduleutil.bean.HeadlineBean;
import com.xscm.moduleutil.bean.HeatedBean;
import com.xscm.moduleutil.bean.HostBean;
import com.xscm.moduleutil.bean.MusicSongBean;
import com.xscm.moduleutil.bean.MyBagDataBean;
import com.xscm.moduleutil.bean.MyCpRoom;
import com.xscm.moduleutil.bean.MyFootResp;
import com.xscm.moduleutil.bean.MyRoomBean;
import com.xscm.moduleutil.bean.NewsDataBean;
import com.xscm.moduleutil.bean.NewsMessageList;
import com.xscm.moduleutil.bean.PersonaltyBean;
import com.xscm.moduleutil.bean.PkSwTokenBean;
import com.xscm.moduleutil.bean.PlaceholderBean;
import com.xscm.moduleutil.bean.RealNameBean;
import com.xscm.moduleutil.bean.RechargeBean;
import com.xscm.moduleutil.bean.RelationCardBean;
import com.xscm.moduleutil.bean.RevenueBean;
import com.xscm.moduleutil.bean.RewardUserBean;
import com.xscm.moduleutil.bean.RoomBgBean;
import com.xscm.moduleutil.bean.RoomCharmRankBean;
import com.xscm.moduleutil.bean.RoomDetails;
import com.xscm.moduleutil.bean.RoomRelationBean;
import com.xscm.moduleutil.bean.RoomSearchResp;
import com.xscm.moduleutil.bean.RoomSingleton;
import com.xscm.moduleutil.bean.RoomSubsidy;
import com.xscm.moduleutil.bean.RoomSubsidyDetails;
import com.xscm.moduleutil.bean.RoomTime;
import com.xscm.moduleutil.bean.RoomTypeModel;
import com.xscm.moduleutil.bean.RoomUserCharmListBean;
import com.xscm.moduleutil.bean.RoonGiftModel;
import com.xscm.moduleutil.bean.SongMusicBean;
import com.xscm.moduleutil.bean.ThemeBean;
import com.xscm.moduleutil.bean.TopRoom;
import com.xscm.moduleutil.bean.UserBean;
import com.xscm.moduleutil.bean.UserInfo;
import com.xscm.moduleutil.bean.UserOnlineStatusBean;
import com.xscm.moduleutil.bean.UserTagBean;
import com.xscm.moduleutil.bean.WalletBean;
import com.xscm.moduleutil.bean.WalletConfig;
import com.xscm.moduleutil.bean.WithdrawalBean;
import com.xscm.moduleutil.bean.blindboxwheel.BlindBoxBean;
import com.xscm.moduleutil.bean.blindboxwheel.BlindReslutBean;
import com.xscm.moduleutil.bean.blindboxwheel.XlhDrawBean;
import com.xscm.moduleutil.bean.room.AuctionBean;
import com.xscm.moduleutil.bean.room.FriendUserBean;
import com.xscm.moduleutil.bean.room.RoomApplyListBean;
import com.xscm.moduleutil.bean.room.RoomAuction;
import com.xscm.moduleutil.bean.room.RoomBean;
import com.xscm.moduleutil.bean.room.RoomInfoResp;
import com.xscm.moduleutil.bean.room.RoomOnline;
import com.xscm.moduleutil.bean.zhuangb.ZhuangBanShangChengBean;
import com.xscm.moduleutil.listener.MessageListenerSingleton;
import com.xscm.moduleutil.utils.SpUtil;
import com.xscm.moduleutil.utils.SystemUtils;
import com.xscm.moduleutil.utils.logger.DataLogger;
import com.xscm.moduleutil.utils.logger.DataLoggingInterceptor;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Type;
import java.net.Proxy;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Collections;
import java.util.EventListener;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import io.reactivex.disposables.Disposable;
import okhttp3.Cache;
import okhttp3.OkHttpClient;
import okhttp3.ResponseBody;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;

public class RetrofitClient {

    private static RetrofitClient INSTANCE;
    private static ApiServer sApiServer;
    public static final int DEFAULT_TIME_OUT = 60;
    private static OkHttpClient client;
    private final Retrofit mRetrofit;

    public OkHttpClient getHttpClient() {
        return client;
    }

    File cacheFile = new File(CommonAppContext.getInstance().getCacheDir(), "cache");
    Cache cache = new Cache(cacheFile, 1024 * 1024 * 100); // 100MB 的缓存空间
    boolean isNetworkAvailable = checkNetworkConnection(); // 实现这个方法来检查网络状态
    String cacheControl = isNetworkAvailable ? "max-age=0" : "only-if-cached, max-stale=86400";

    private boolean checkNetworkConnection() {
        ConnectivityManager connectivityManager = (ConnectivityManager) CommonAppContext.getInstance().getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
        return activeNetworkInfo != null && activeNetworkInfo.isConnected();
    }

    private OkHttpClient provideOkHttpClient() {
        Map<String, String> headers = Collections.emptyMap();
        if (SpUtil.isAgreePolicy()) {
            headers = SystemUtils.getSystemParams();
        }
        SetCookieCache cookieCache = new SetCookieCache();
        ClearableCookieJar cookieJar =
                new PersistentCookieJar(cookieCache, new SharedPrefsCookiePersistor(CommonAppContext.getInstance()));
        try {
            X509TrustManager trustAllCert = new X509TrustManager() {
                @Override
                public void checkClientTrusted(X509Certificate[] chain, String authType) {
                }

                @Override
                public void checkServerTrusted(X509Certificate[] chain, String authType) {
                }

                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    return new X509Certificate[]{};
                }
            };
            SSLContext sslContext = null;
            sslContext = SSLContext.getInstance("SSL");
            sslContext.init(null, new TrustManager[]{trustAllCert}, new SecureRandom());

            final OkHttpClient client = new OkHttpClient.Builder()
//                .addInterceptor(new LoggerInterceptor("HttpLog", true))
                    .addInterceptor(new DataLoggingInterceptor(new DataLogger()))
                    .addInterceptor(new AccessTokenInterceptor(headers))
                    .proxy(Proxy.NO_PROXY)
                    .sslSocketFactory(sslContext.getSocketFactory(), trustAllCert)
                    .hostnameVerifier((hostname, session) -> true)
                    .cookieJar(cookieJar)
                    .connectTimeout(DEFAULT_TIME_OUT, TimeUnit.SECONDS)
                    .readTimeout(DEFAULT_TIME_OUT, TimeUnit.SECONDS)
                    .writeTimeout(DEFAULT_TIME_OUT, TimeUnit.SECONDS)
                    .build();
            RetrofitClient.client = client;
        } catch (KeyManagementException | NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
        return client;
    }

    private Retrofit provideRetrofit(OkHttpClient client) {
        return new Retrofit.Builder()
                .addConverterFactory(MyConverterFactory.create())/**/
//                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
//                .baseUrl("http://chat.qxmier.com/")
                .baseUrl(CommonAppContext.getInstance().getCurrentEnvironment().getServerUrl())
                .client(client)

                .build();
    }

//    private static Retrofit mRainRetrofit;
//
//    public static Retrofit getRainRetrofit() {
//        if (mRainRetrofit == null) {
//            synchronized (RetrofitClient.class) {
//                mRainRetrofit = new Retrofit.Builder()
//                        .addConverterFactory(RainConverterFactory.create())
//                        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
//                        .baseUrl(BuildConfig.RAIN_GAME_BASE_URL)
//                        .client(client)
//                        .build();
//            }
//        }
//        return mRainRetrofit;
//    }

    private RetrofitClient() {
        mRetrofit = provideRetrofit(provideOkHttpClient());
        sApiServer = mRetrofit.create(ApiServer.class);
    }

    public static RetrofitClient getInstance() {
        if (INSTANCE == null) {
            synchronized (RetrofitClient.class) {
                if (INSTANCE == null) {
                    INSTANCE = new RetrofitClient();
                }
            }
        }
        return INSTANCE;
    }

    public <T> T createApiClient(Class<T> apiClientClass) {
        return mRetrofit.create(apiClientClass);
    }

    public void login() {
//        login("18473492252", "123456");
//        login("18229732986", "123456");
    }

    public void appUpdate(BaseObserver<AppUpdateModel> observer) {
        sApiServer.appUpdate().compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void sendCode(String mobile, String event, BaseObserver<Object> observer) {
        sApiServer.sendCode(mobile, event).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void mobileView(String mobile, String new_mobile, String sms_code, BaseObserver<String> observer) {
        sApiServer.mobileView(mobile, new_mobile, sms_code).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                if (response.code() == 200) {
                    BaseModel<String> body = response.body();
                    observer.onNext(body.getMsg());

                }
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void mobileView2(String new_mobile, String sms_code, BaseObserver<String> observer) {
        sApiServer.mobileView2(new_mobile, sms_code).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                if (response.code() == 200) {
                    BaseModel<String> body = response.body();
                    observer.onNext(body.getMsg());
                }
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void login(String mobile, String password, BaseObserver<List<UserBean>> observer) {
        sApiServer.login(mobile, password).enqueue(new Callback<BaseModel<List<UserBean>>>() {

            @Override
            public void onResponse(Call<BaseModel<List<UserBean>>> call, Response<BaseModel<List<UserBean>>> response) {
                if (response.code() == 200){
                    BaseModel<List<UserBean>> listBaseModel=response.body();
                    if (listBaseModel!=null){
                        int code=listBaseModel.getCode();
                        if (code==1){
                            observer.onNext(listBaseModel.getData());
                        }else if (code==301){
                            ToastUtils.showShort(listBaseModel.getMsg());
                        }else {
                            ToastUtils.showShort(listBaseModel.getMsg());
                        }
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<List<UserBean>>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void userLogin(String mobile, String password, BaseObserver<List<UserBean>> observer) {
        sApiServer.userLogin(mobile, password).enqueue(new Callback<BaseModel<List<UserBean>>>() {
            @Override
            public void onResponse(Call<BaseModel<List<UserBean>>> call, Response<BaseModel<List<UserBean>>> response) {
//                if (response.code()==200){
//                    BaseModel<List<UserBean>> listBaseModel=response.body();
//                    if (listBaseModel!=null){
//                        int code=listBaseModel.getCode();
//                        if (code==1){
//                            observer.onNext(listBaseModel.getData());
//                        }
//                        else {
//                            LogUtils.e("@@@",response);
//                        }
//                    }
//                }

                if (response.code() == 200) {
                    LogUtils.e("Raw JSON", response.body()); // 打印原始响应内容
                    BaseModel<List<UserBean>> string = response.body();
                    if (string != null) {
                        LogUtils.e("@@@", response);
                        int code = string.getCode();
                        if (code == 1) {
                            observer.onNext(string.getData());
                        } else if (code == 301) {
//                            try {
                                ToastUtils.showShort(string.getMsg());
//                                ToastUtils.showShort("提示当前账号已在别的地方登陆，如果不是本人操作请修改密码");
//                                CommonAppContext.getInstance().clearLoginInfo();
//                            } catch (ClassNotFoundException e) {
//                                throw new RuntimeException(e);
//                            }
                        }else {

                            ToastUtils.showShort(string.getMsg());
                        }

                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<List<UserBean>>> call, Throwable t) {
                LogUtils.e("@@@", t);
            }
        });
    }

    public void exchangeCoin(String earnings_num, BaseObserver<String> observer) {
        sApiServer.exchangeCoin(earnings_num).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void delfoot(BaseObserver<String> observer) {
        sApiServer.delfoot().enqueue(new Callback<BaseModel<String>>() {


            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void firstCharge(String uid, BaseObserver<FirstChargeBean> observer) {
        sApiServer.firstCharge(uid).enqueue(new Callback<BaseModel<FirstChargeBean>>() {

            @Override
            public void onResponse(Call<BaseModel<FirstChargeBean>> call, Response<BaseModel<FirstChargeBean>> response) {
                if (response.code() == 200) {
                    BaseModel<FirstChargeBean> baseModel = response.body();
                    if (baseModel != null) {
                        observer.onNext(baseModel.getData());
                    } else {
                        ToastUtils.showShort("获取数据失败");
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<FirstChargeBean>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void giftWall(String userId, BaseObserver<GiftUserWallBean> observer) {
        sApiServer.giftWall(userId).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void withdrawal(String number, String type, String sms_code, BaseObserver<String> observer) {
        sApiServer.withdrawal(number, type, sms_code).enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                if (response.code() == 200) {
                    try {
                        String json = response.body().string();
                        BaseModel<String> baseModel = GsonUtils.fromJson(json, BaseModel.class);
                        if (baseModel.getCode() == 1) {
                            baseModel.setData(baseModel.getMsg());
                            observer.onNext(baseModel.getData());
                        } else {
                            baseModel.setData(baseModel.getMsg());
                            observer.onNext(baseModel.getData());
                        }

                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                LogUtils.e("提现失败", t);
            }


        });
    }

    public void getMessagetitle(String type, String page, String page_limit, BaseObserver<List<NewsMessageList>> observer) {
        sApiServer.getMessagetitle(type, page, page_limit).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void withdrawalList(String page, String page_limit, String search_stime, String search_etime, BaseObserver<List<WithdrawalBean>> observer) {
        sApiServer.withdrawalList(page, page_limit, search_stime, search_etime).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getRoomRank(String roomId, String type, String time_type, String page, String page_limit, BaseObserver<List<CharmRankingResp>> observer) {
        sApiServer.getRoomRank(roomId, type, time_type, page, page_limit).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void wealthRanking(String ranking_type, String type, BaseObserver<PlaceholderBean> observer) {
        if (ranking_type.equals("0")) {
            sApiServer.roomRanking(type).compose(new DefaultTransformer<>()).subscribe(observer);
        } else if (ranking_type.equals("1") || ranking_type.equals("2")) {
            sApiServer.wealthRanking(ranking_type, type).compose(new DefaultTransformer<>()).subscribe(observer);
        } else if (ranking_type.equals("3")) {
            sApiServer.guildRanking().compose(new DefaultTransformer<>()).subscribe(observer);
        } else if (ranking_type.equals("4")) {
            sApiServer.loveRanking(type).compose(new DefaultTransformer<>()).subscribe(observer);
        }
    }

    public void dailyTasksBoxRecord(BaseObserver<List<GiftBoxRecordBean>> observer) {
        sApiServer.dailyTasksBoxRecord().compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void packIncome(String page, String page_limit, BaseObserver<List<MyBagDataBean>> observer) {
        sApiServer.packIncome(page, page_limit).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void packOutcome(String page, String page_limit, BaseObserver<List<MyBagDataBean>> observer) {
        sApiServer.packOutcome(page, page_limit).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void giftPack(BaseObserver<List<GiftPackBean>> observer) {
        sApiServer.giftPack().enqueue(new Callback<BaseModel<List<GiftPackBean>>>() {

            @Override
            public void onResponse(Call<BaseModel<List<GiftPackBean>>> call, Response<BaseModel<List<GiftPackBean>>> response) {
                if (response.code() == 200){
                    BaseModel<List<GiftPackBean>> baseModel = response.body();
                    if (baseModel.getCode() == 1) {
                        observer.onNext(baseModel.getData());
                    } else {
                        observer.onNext(null);
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<List<GiftPackBean>>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void getGiftPack(String roomId, String userId, String heart_id,String auction_id,BaseObserver<String> observer){
        sApiServer.getGiftPack(roomId,userId,heart_id,auction_id).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                if (response.code() == 200){
                    BaseModel<String> baseModel = response.body();
                    if (baseModel.getCode() == 1){
                        observer.onNext(baseModel.getMsg());
                    }else {
                        observer.onNext(null);
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void getGiftPackListCount(BaseObserver<GiftPackListCount> observer){
        sApiServer.getGiftPackListCount().enqueue(new Callback<BaseModel<GiftPackListCount>>() {
            @Override
            public void onResponse(Call<BaseModel<GiftPackListCount>> call, Response<BaseModel<GiftPackListCount>> response) {
                if (response.code() == 200){
                    BaseModel<GiftPackListCount> baseModel = response.body();
                    if (baseModel.getCode() == 1){
                        observer.onNext(baseModel.getData());
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<GiftPackListCount>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void roomUserReconnect(String roomId){
        sApiServer.roomUserReconnect(roomId).compose(new DefaultTransformer<>()).subscribe();
    }

    public void tasksLihen(BaseObserver<GiftBoxBean> observer) {
        sApiServer.tasksLihen().enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                if (response.code() == 200) {
                    String json = null;
                    try {
                        json = response.body().string();
                        Type type = new TypeToken<BaseModel<GiftBoxBean>>() {
                        }.getType();
                        BaseModel<GiftBoxBean> baseModel = GsonUtils.fromJson(json, type);
                        observer.onNext(baseModel.getData());
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }

                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void dailyTasksOpenBox(String gift_box_id, BaseObserver<GiftName> observer) {
        sApiServer.dailyTasksOpenBox(gift_box_id).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void dailyTasksReceive(String task_id, BaseObserver<String> observer) {
        sApiServer.dailyTasksReceive(task_id).enqueue(new Callback<ResponseBody>() {

            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                if (response.code() == 200) {
                    observer.onNext("任务完成");
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void dailyTasksComplete(String task_id, BaseObserver<RoomSingleton> observer) {
        sApiServer.dailyTasksComplete(task_id).enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                if (response.code() == 200) {
                    String json = null;
                    try {
                        json = response.body().string();
                        Type type = new TypeToken<BaseModel<RoomSingleton>>() {
                        }.getType();
                        BaseModel<RoomSingleton> baseModel = GsonUtils.fromJson(json, type);
                        observer.onNext(baseModel.getData());
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void sendHeadine(String content, String money, String roomId, BaseObserver<String> observer) {
        sApiServer.sendHeadine(content, money, roomId).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void currentHeadline(BaseObserver<HeadlineBean> observer) {
        sApiServer.currentHeadline().compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void upUserNickname(BaseObserver<String> observer) {
        sApiServer.upUserNickname().enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                try {
                    String json = response.body().string();
                    BaseModel<String> baseModel = GsonUtils.fromJson(json, BaseModel.class);
                    observer.onNext(baseModel.getData().toString());

                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                t.printStackTrace();
            }
        });

    }

    public void getRevenueData(String page, String page_limit, String in_out_type, String start_time, String end_time, String gift_type, BaseObserver<List<RevenueBean>> observer) {
        sApiServer.getRevenueData(page, page_limit, in_out_type, start_time, end_time, gift_type).enqueue(new Callback<BaseModel<List<RevenueBean>>>() {
            @Override
            public void onResponse(Call<BaseModel<List<RevenueBean>>> call, Response<BaseModel<List<RevenueBean>>> response) {
                if (response.code() == 200) {
                    BaseModel<List<RevenueBean>> baseModel = response.body();
                    if (baseModel != null) {
                        if (baseModel.getData() != null && baseModel.getData().size() > 0) {
                            observer.onNext(baseModel.getData());
                        } else {
                            observer.onNext(new ArrayList<>());
                        }
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<List<RevenueBean>>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void realNameInfo(BaseObserver<RealNameBean> observer) {
        sApiServer.realNameInfo().compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void addBlackList(String userId, BaseObserver<String> observer) {
        sApiServer.addBlackList(userId).enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                try {
                    String json = response.body().string();
                    BaseModel<String> baseModel = GsonUtils.fromJson(json, BaseModel.class);
                    observer.onNext(baseModel.getData());

                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void upUserPic(String sex, BaseObserver<String> observer) {
        sApiServer.upUserPic(sex).enqueue(new Callback<ResponseBody>() {
                    @Override
                    public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                        try {
                            String json = response.body().string();
                            BaseModel<String> baseModel = GsonUtils.fromJson(json, BaseModel.class);
                            observer.onNext(baseModel.getData());

                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }

                    @Override
                    public void onFailure(Call<ResponseBody> call, Throwable t) {
                        t.printStackTrace();
                    }
                });

//                .enqueue(new Callback<BaseModel<String>>() {
//            @Override
//            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
//                if (response.code() == 200){
//                    BaseModel<String> baseModel = response.body();
//                    if (baseModel.getCode()==1){
//                        onNextRetu(response, observer);
//                    }
//                }
//            }
//
//            @Override
//            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
//                LogUtils.e("@@@", t);
//            }
//        });
    }

    public void sendPk(String roomIda, String createUserId, String roomIdb, BaseObserver<Object> observer) {
        sApiServer.sendPk(roomIda, createUserId, roomIdb).enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                try {
                    String json = response.body().string();
                    BaseModel<String> baseModel = GsonUtils.fromJson(json, BaseModel.class);
                    ToastUtils.showShort(baseModel.getMsg());
                    observer.onNext(baseModel.getData());

                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                LogUtils.e("发起pk失败", t);
            }
        });
    }

    public void refusePk(String roomId, String is_pk, BaseObserver<String> observer) {
        sApiServer.refusePk(is_pk, roomId).enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                try {
                    String json = response.body().string();
                    BaseModel<String> baseModel = GsonUtils.fromJson(json, BaseModel.class);
                    observer.onNext(baseModel.getData());

                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                LogUtils.e("不再接受 PK", t);
            }
        });
    }

    public void recharge(BaseObserver<List<RechargeBean>> observer) {
        sApiServer.recharge().compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void endPk(String pk_id, String type, String user_id, BaseObserver<String> observer) {
        sApiServer.endPk(pk_id, type, user_id).enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                if (response.code() == 200) {
                    try {
                        String json = response.body().string();
                        BaseModel<String> baseModel = GsonUtils.fromJson(json, BaseModel.class);
                        observer.onNext(baseModel.getData());

                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                LogUtils.e("结束 PK", t);
            }
        });
    }

    public void switchAccounts(String loginId, BaseObserver<List<UserBean>> observer) {
        sApiServer.switchAccounts(loginId).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void searchPkRoom(String roomId, String page, String limit, BaseObserver<List<RoomBean>> observer) {
        sApiServer.searchPkRoom(roomId, page, limit).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void userUpdate(String nickname, String birthday, String sex, String avatar, String init_code, String user_id, BaseObserver<UserBean> observer) {
        sApiServer.userUpdate(nickname, birthday, sex, avatar, init_code, user_id).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void authorization(BaseObserver<String> observer) {
        sApiServer.authorization().enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                if (response.code() == 200) {
                    try {
                        String json = response.body().string();
                        BaseModel<String> baseModel = GsonUtils.fromJson(json, BaseModel.class);
                        observer.onNext(baseModel.getData());

                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void oauthLogin(String netease_token, BaseObserver<List<UserBean>> observer) {
        sApiServer.oauthLogin(netease_token).enqueue(new Callback<BaseModel<List<UserBean>>>() {
            @Override
            public void onResponse(Call<BaseModel<List<UserBean>>> call, Response<BaseModel<List<UserBean>>> response) {
                if (response.code() == 200) {
                    BaseModel<List<UserBean>> baseModel = response.body();
                    if (baseModel.getCode()==1) {
                        observer.onNext(baseModel.getData());
                    }else if (baseModel.getCode()==301){
                        ToastUtils.showShort(baseModel.getMsg());
                        observer.onNext(null);
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<List<UserBean>>> call, Throwable t) {
                LogUtils.e("授权登录失败", t);
            }
        });
    }

    public void getThemeData(BaseObserver<ThemeBean> observer) {
        sApiServer.getThemeData().enqueue(new Callback<BaseModel<ThemeBean>>() {

            @Override
            public void onResponse(Call<BaseModel<ThemeBean>> call, Response<BaseModel<ThemeBean>> response) {
                if (response.code() == 200) {
                    BaseModel<ThemeBean> baseModel = response.body();
                    if (baseModel.getData() != null) {
                        observer.onNext(baseModel.getData());
                    } else {
                        observer.onNext(null);
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<ThemeBean>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void authCode(String netease_token, int type, BaseObserver<List<UserBean>> observer) {
        if (type == 1) {
            sApiServer.authCode1(netease_token).compose(new DefaultTransformer<>()).subscribe(observer);
        } else {
            sApiServer.authCode(netease_token).compose(new DefaultTransformer<>()).subscribe(observer);
        }
    }

    public void getUserFollowList(String page, String page_limit, BaseObserver<List<BlackUserBean>> observer) {
        sApiServer.getUserFollowList(page, page_limit).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getUserFansList(String page, String page_limit, BaseObserver<List<BlackUserBean>> observer) {
        sApiServer.getUserFansList(page, page_limit).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getBlacklist(String page, String page_limit, BaseObserver<List<BlackUserBean>> observer) {
        sApiServer.getBlacklist(page, page_limit).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getLockMiniList(String page, String page_limit, BaseObserver<List<BlackUserBean>> observer) {
        sApiServer.getLockMiniList(page, page_limit).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void realName(String real_name, String card_number, BaseObserver<RealNameBean> observer) {
        sApiServer.realName(real_name, card_number).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    //获取扩列数据
    public void getExpandColumn(String type, String page, String page_limit, BaseObserver<List<ExpandColumnBean>> observer) {
        sApiServer.getExpandColumn(type, page, page_limit).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    //获取官方公告数据或者系统消息，
    public void getOfficialNotice(BaseObserver<NewsDataBean> observer) {
        sApiServer.getOfficialNotice().compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getAlbumList(String page, String page_limit, String userId, BaseObserver<List<AlbumBean>> observer) {
        sApiServer.getAlbumList(page, page_limit, userId).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void sjRoomName(BaseObserver<String> observer) {
        sApiServer.sjRoomName().enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                if (response.code() == 200) {
                    try {
                        String json = response.body().string();
                        BaseModel<String> baseModel = GsonUtils.fromJson(json, BaseModel.class);
                        observer.onNext(baseModel.getData());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                LogUtils.e("获取房间名称失败", t);
            }
        });
    }

    public void getMyRoom(String type, String page, String page_limit, BaseObserver<List<MyRoomBean>> observer) {
        sApiServer.getMyRoom(type, page, page_limit).enqueue(new Callback<BaseModel<List<MyRoomBean>>>() {
            @Override
            public void onResponse(Call<BaseModel<List<MyRoomBean>>> call, Response<BaseModel<List<MyRoomBean>>> response) {
                if (response.code() == 200) {
                    BaseModel<List<MyRoomBean>> listBaseModel = response.body();
                    if (listBaseModel != null) {
                        observer.onNext(listBaseModel.getData());
                    } else {
                        observer.onNext(null);
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<List<MyRoomBean>>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void getBanners(BaseObserver<List<BannerModel>> observer) {
        sApiServer.getBanners("3").enqueue(new Callback<BaseModel<List<BannerModel>>>() {
            @Override
            public void onResponse(Call<BaseModel<List<BannerModel>>> call, Response<BaseModel<List<BannerModel>>> response) {
                if (response.code() == 200) {
                    BaseModel<List<BannerModel>> listBaseModel = response.body();
                    if (listBaseModel != null) {
                        observer.onNext(listBaseModel.getData());
                    } else {
                        observer.onNext(null);
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<List<BannerModel>>> call, Throwable t) {
                LogUtils.e("获取轮播图失败", t);
            }
        });
    }


    public void getTopRooms(String page, String page_limit, String is_top, String label_id, BaseObserver<List<TopRoom>> observer) {
        sApiServer.getTopRooms(page, page_limit, is_top, label_id).enqueue(new Callback<BaseModel<List<TopRoom>>>() {
            @Override
            public void onResponse(Call<BaseModel<List<TopRoom>>> call, Response<BaseModel<List<TopRoom>>> response) {
                if (response.code() == 200) {
                    BaseModel<List<TopRoom>> listBaseModel = response.body();

                    if (listBaseModel != null) {
                        observer.onNext(listBaseModel.getData());
                    } else {
                        observer.onNext(null);
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<List<TopRoom>>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void getRoomCategories(BaseObserver<List<RoomTypeModel>> observer) {
        sApiServer.getRoomCategories().compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getRewardList(String id, int page, int page_limit, BaseObserver<List<RewardUserBean>> observer) {
        sApiServer.getRewardList(id, page + "", page_limit + "").compose(new DefaultTransformer<>()).subscribe(observer);

    }

    public void getGiftLabel(String have_hot, BaseObserver<List<GiftLabelBean>> observer) {
        sApiServer.getGiftLabel(have_hot).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getGiftList(int type,String roomId, BaseObserver<List<RoonGiftModel>> observer) {
        sApiServer.getGiftList(type,roomId).compose(new DefaultTransformer<>()).subscribe(observer);
    }


    public void topicList(String page, String page_limit, BaseObserver<List<HeatedBean>> observer) {
        sApiServer.topicList(page, page_limit).compose(new DefaultTransformer<>()).subscribe(observer);
    }


    public void getCategories(BaseObserver<List<HeatedBean>> observer) {//动态顶部热门话题
        sApiServer.getCategories().compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getCircleList(String page, String page_limit, BaseObserver<List<CircleListBean>> observer) {//动态列表
        sApiServer.getCircleList(page, page_limit).enqueue(new Callback<BaseModel<List<CircleListBean>>>() {

            @Override
            public void onResponse(Call<BaseModel<List<CircleListBean>>> call, Response<BaseModel<List<CircleListBean>>> response) {
                if (response.code() == 200){
                    BaseModel<List<CircleListBean>> listBaseModel = response.body();
                    if (listBaseModel != null) {
                        observer.onNext(listBaseModel.getData());
                    } else {
                        observer.onNext(null);
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<List<CircleListBean>>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void getCircleUserList(String user_id, String page, String page_limit, BaseObserver<List<CircleListBean>> observer) {//用户主页动态列表
        sApiServer.getCircleUserList(user_id, page, page_limit).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void topicId(String topic_id, BaseObserver<List<CircleListBean>> observer) {//动态列表
        sApiServer.topicId(topic_id).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void zoneDetail(String topic_id, BaseObserver<CircleListBean> observer) {//动态列表
        sApiServer.zoneDetail(topic_id).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getUserHome(String user_id, BaseObserver<UserInfo> observer) {
        sApiServer.getUserHome(user_id).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getCommentList(String id, String page, String page_limit, BaseObserver<CommentBean> observer) {
        sApiServer.getCommentList(id, page, page_limit).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void song(String roomId, String user_id, String song_code, String song_name, String singer, String poster, String duration, BaseObserver<List<SongMusicBean>> observer) {
        sApiServer.song(roomId, user_id, song_code, song_name, singer, poster, duration).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getMyInfo(BaseObserver<UserInfo> observer) {//点击我的获取数据
        sApiServer.getMyInfo().compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getUserTagList(BaseObserver<List<UserTagBean>> observer) {
        sApiServer.getUserTagList().compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getLikeList(String id, BaseObserver<List<CircleListBean.LikeList>> observer) {
        sApiServer.getLikeList(id).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getAlbumDetail(String albumId, String pwd, String page, String page_limit, BaseObserver<AlbumBean> observer) {
        sApiServer.getAlbumDetail(albumId, pwd, page, page_limit).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getSubsidy(String roomId, BaseObserver<RoomSubsidy> observer) {
        sApiServer.getSubsidy(roomId).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getSubsidyDetail(String roomId, BaseObserver<RoomSubsidyDetails> observer) {
//        sApiServer.getSubsidyDetail(roomId).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getPersonaltyList(BaseObserver<List<PersonaltyBean>> observer) {
        sApiServer.getPersonaltyList().compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getDecorateList(String type, BaseObserver<List<ZhuangBanShangChengBean>> observer) {
        sApiServer.getDecorateList(type).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void roomGetIn(String roomId, String password, BaseObserver<RoomInfoResp> observer) {
        sApiServer.roomGetIn(roomId, password).enqueue(new Callback<BaseModel<RoomInfoResp>>() {

            @Override
            public void onResponse(Call<BaseModel<RoomInfoResp>> call, Response<BaseModel<RoomInfoResp>> response) {
                if (response.code() == 200){
                    BaseModel<RoomInfoResp> roomInfoRespBaseModel = response.body();
                    if (roomInfoRespBaseModel.getCode()==1){
                        observer.onNext(roomInfoRespBaseModel.getData());
                    }else {
                        MessageListenerSingleton.getInstance().quitGroup(roomId);
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<RoomInfoResp>> call, Throwable t) {

            }
        });
    }

    public void updatePassword(String roomId, String password, BaseObserver<String> observer) {
        sApiServer.updatePassword(roomId, password).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getMyFoot(String page, BaseObserver<List<MyFootResp>> observer) {
        sApiServer.getMyFoot(page, "10").compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void myCpRoom(BaseObserver<List<MyCpRoom>> observer) {
        sApiServer.myCpRoom().enqueue(new Callback<BaseModel<List<MyCpRoom>>>() {
            @Override
            public void onResponse(Call<BaseModel<List<MyCpRoom>>> call, Response<BaseModel<List<MyCpRoom>>> response) {
                if (response.code() == 200) {
                    BaseModel<List<MyCpRoom>> listBaseModel = response.body();

                    if (listBaseModel != null) {
                        observer.onNext(listBaseModel.getData());
                    } else {
                        observer.onNext(null);
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<List<MyCpRoom>>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void startPk(String pk_id, String pk_times, BaseObserver<String> observer) {
        sApiServer.startPk(pk_id, pk_times).enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                if (response.code() == 200) {
                    try {
                        String json = response.body().string();
                        BaseModel<String> baseModel = GsonUtils.fromJson(json, BaseModel.class);
                        observer.onNext(baseModel.getData());

                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                LogUtils.e("开始pk", t);
            }
        });
    }

    public void getRoomOnline(String roomId, String page, String page_limit, BaseObserver<RoomOnline> observer) {
        sApiServer.getRoomOnline(roomId, page, page_limit).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void wallet(BaseObserver<WalletBean> observer) {
        sApiServer.wallet().compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void appPay(String user_id, String money, String coin, String type, BaseObserver<AppPay> observer) {
        sApiServer.appPay(user_id, money, coin, type).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void bindType(String userId, BaseObserver<BindType> observer) {
        sApiServer.bindType(userId).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getWalletConfig(BaseObserver<WalletConfig> observer) {
        sApiServer.getWalletConfig().compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void bind(String userId, String type, String alipayAccount, String bank_card_number, String bank_card, String open_bank, BaseObserver<String> observer) {
        sApiServer.bind(userId, type, alipayAccount, bank_card_number, bank_card, open_bank).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void roomApplyListBean(String roomId, BaseObserver<RoomApplyListBean> observer) {
        sApiServer.roomApplyListBean(roomId).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getRoomUserInfo(String room_id, String user_id, BaseObserver<UserInfo> observer) {
        sApiServer.getRoomUserInfo(room_id, user_id).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void songList(String room_id, BaseObserver<List<MusicSongBean>> observer) {
        sApiServer.songList(room_id).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    // TODO: 2025/3/15 获取主持人列表
    public void getHostList(String roomId, String type, BaseObserver<List<HostBean>> observer) {
        sApiServer.getHostList(roomId, type).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getSearch(String keyWord, String type, BaseObserver<List<RoomSearchResp>> observer) {
        sApiServer.getSearch(keyWord, type).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getBackgroundList(BaseObserver<RoomBgBean> observer) {
        sApiServer.getBackgroundList().compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void getCharmList(String roomId, String stime, String etime, String p, BaseObserver<RoomDetails> observer) {
        sApiServer.getCharmList(roomId, stime, etime, p).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    // TODO: 2025/6/28 房间竞拍开始
    public void roomAuction(String roomId, String userId, String giftId, String relation_id, String auction_type, String time_day, BaseObserver<AuctionBean> observer) {
        sApiServer.roomAuction(roomId, userId, giftId, relation_id, auction_type, time_day).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void roomAuctionTime(String gift_id, BaseObserver<RoomTime> observer) {
        sApiServer.roomAuctionTime(gift_id).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void roomAuctionJoin(String auctionId, String userId, String giftId, String num, String type, BaseObserver<RoomAuction.AuctionListBean> observer) {
        sApiServer.roomAuctionJoin(auctionId, userId, giftId, num, type).enqueue(new Callback<BaseModel<RoomAuction.AuctionListBean>>() {

            @Override
            public void onResponse(Call<BaseModel<RoomAuction.AuctionListBean>> call, Response<BaseModel<RoomAuction.AuctionListBean>> response) {
                if (response.code() == 200){
                    BaseModel<RoomAuction.AuctionListBean> baseModel = response.body();

                    if (baseModel.getCode()==1) {
                        observer.onNext(baseModel.getData());
                    }else {
                        ToastUtils.showShort(baseModel.getMsg());
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<RoomAuction.AuctionListBean>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void auctionDelay(String auctionId, BaseObserver<String> observer) {
        sApiServer.auctionDelay(auctionId).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void auctionEnd(String auctionId, String roomId, BaseObserver<String> observer) {
        sApiServer.auctionEnd(auctionId, roomId).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                if (response.code() == 200) {

                    observer.onNext(null);
                }
//                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void auctionMode(String roomId, String labelId, BaseObserver<String> observer) {
        sApiServer.auctionMode(roomId, labelId).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void uploadBgImage(String id, String image_url, BaseObserver<String> observer) {
        sApiServer.setUploadBgImg(id, image_url).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }


    public void editRoom(String room_id, String room_name, String room_cover, String room_intro, String room_background, BaseObserver<String> observer) {
        sApiServer.editRoom(room_id, room_name, room_cover, room_intro, room_background).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void setPresidedRatio(String room_id, String user_id, String ratio, BaseObserver<String> observer) {
        sApiServer.setPresidedRatio(room_id, user_id, ratio).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }


    public void postHostAdd(String roomId, String userId, String type, String is_add, BaseObserver<String> observer) {
        sApiServer.getPresidedRatio(roomId, userId, type, is_add).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void reward_zone(String id, String gift_id, String num, String is_pack, BaseObserver<String> observer) {
        sApiServer.reward_zone(id, gift_id, num, is_pack).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void upSong(String did, String type, BaseObserver<String> observer) {
        sApiServer.upSong(did, type).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void clearApply(String room_id, BaseObserver<String> observer) {
        sApiServer.clearApply(room_id).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void agreePit(String room_id, String user_id, BaseObserver<String> observer) {
        sApiServer.agreePit(room_id, user_id).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
            }
        });
    }

    public void refusePit(String room_id, String user_id, BaseObserver<String> observer) {
        sApiServer.refusePit(room_id, user_id).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
            }
        });
    }

    public void helpApply(String room_id, String user_id, BaseObserver<String> observer) {
        sApiServer.helpApply(room_id, user_id)
                .enqueue(new Callback<BaseModel<String>>() {
                    @Override
                    public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                        onNextRetu(response, observer);
                    }

                    @Override
                    public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                        ToastUtils.showShort(t.toString());
                    }
                });
    }

    public void setRoomApply(String room_id, String gift_id, String gift_price, BaseObserver<String> observer) {
        sApiServer.setRoomApply(room_id, gift_id, gift_price).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void giveGift(String user_id, String gid, String num, String to_uid, String gift_type, BaseObserver<String> observer) {
        sApiServer.giveGift(user_id, gid, num, to_uid, gift_type).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void roomGift(String room_id, String gift_id, String gift_num, String to_uid, String type, String pit_number,String heart_id, BaseObserver<String> observer) {
        sApiServer.roomGift(room_id, gift_id, gift_num, to_uid, type, pit_number,heart_id).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void firstChargeGift(BaseObserver<FirstChargeGiftBean> observer) {
        sApiServer.firstChargeGift().compose(new DefaultTransformer<>()).subscribe(observer);
//                .enqueue(new Callback<ResponseBody>() {
//            @Override
//            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
//                if (response.code() == 200) {
//                    try {
//                        String json = response.body().string();
//                        BaseModel<FirstChargeGiftBean> data =GsonUtils.fromJson(json, BaseModel.class);
////                        String data1=GsonUtils.toJson(data.getData());
////                        LogUtils.e("data1",data.getData());
////                        FirstChargeGiftBean firstChargeGiftBean=new FirstChargeGiftBean();
////                        firstChargeGiftBean.setName(data.getData().getName());
////                        List<FirstChargeGiftBean.GiftBag>  giftBags=new ArrayList<>();
////                        for (int i=0;i<data.getData().getGift_bag().size();i++){
////
////                            FirstChargeGiftBean.GiftBag giftBag=new FirstChargeGiftBean.GiftBag();
////                            giftBag.setName(data.getData().getGift_bag().get(i).getName());
////                            giftBag.setMoney(data.getData().getGift_bag().get(i).getMoney());
////                            giftBag.setTitle1(data.getData().getGift_bag().get(i).getTitle1());
////                            giftBag.setTitle2(data.getData().getGift_bag().get(i).getTitle2());
////                            List<RoonGiftModel> roonGiftModels=new ArrayList<>();
////                            for (int j=0;j<data.getData().getGift_bag().get(i).getGift_list().size();j++){
////                                RoonGiftModel roonGiftModel=new RoonGiftModel();
////                                roonGiftModel.setGift_name(data.getData().getGift_bag().get(i).getGift_list().get(j).getGift_name());
////                                roonGiftModel.setNum(data.getData().getGift_bag().get(i).getGift_list().get(j).getNum());
////                                roonGiftModel.setGift_price(data.getData().getGift_bag().get(i).getGift_list().get(j).getGift_price());
////                                roonGiftModel.setType(data.getData().getGift_bag().get(i).getGift_list().get(j).getType());
////                                roonGiftModel.setBase_image(data.getData().getGift_bag().get(i).getGift_list().get(j).getBase_image());
////                                roonGiftModels.add(roonGiftModel);
////                            }
////                            giftBag.setGift_list(roonGiftModels);
////                            giftBags.add(giftBag);
////                        }
////
////                        firstChargeGiftBean.setGift_bag(giftBags);
//
//
//
////                        List<FirstChargeGiftBean> data2=GsonUtils.fromJson(data1, new TypeToken<List<FirstChargeGiftBean>>(){}.getType());
////                        observer.onNext(data2.get(0));
////                        FirstChargeGiftBean firstChargeGiftBean = GsonUtils.fromJson(data1, FirstChargeGiftBean.class);
////                        Object data3=GsonUtils.fromJson(data1, FirstChargeGiftBean.class);
////                        LogUtils.e("data3",data3);
//                        observer.onNext(data.getData());
//                    }catch (Exception e){
//                        e.printStackTrace();
//                    }
//                }
//            }
//
//            @Override
//            public void onFailure(Call<ResponseBody> call, Throwable t) {
//                t.printStackTrace();
//            }
//        });
    }

    public void applyPit(String roomId, String pitNumber, BaseObserver<String> observer) {
        sApiServer.applyPit(roomId, pitNumber).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void startFriend(String roomId, BaseObserver<String> observer) {
        sApiServer.startFriend(roomId).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                if (response.code() == 200) {
                    BaseModel<String> baseModel = response.body();
                    if (baseModel.getCode() != 1) {
                        com.hjq.toast.ToastUtils.show(baseModel.getMsg());
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void delay(String friend_id, String room_id, String delay_times, BaseObserver<String> observer) {
        sApiServer.delay(friend_id, room_id, delay_times).enqueue(new Callback<BaseModel<String>>() {

            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                if (response.code() == 200) {
                    BaseModel<String> baseModel = response.body();
                    if (baseModel.getCode() != 1) {
                        com.hjq.toast.ToastUtils.show(baseModel.getMsg());
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void endFriend(String friend_id, String room_id, BaseObserver<FriendUserBean> observer) {
        sApiServer.endFriend(friend_id, room_id).enqueue(new Callback<BaseModel<FriendUserBean>>() {

            @Override
            public void onResponse(Call<BaseModel<FriendUserBean>> call, Response<BaseModel<FriendUserBean>> response) {
                if (response.code() == 200) {
                    BaseModel<FriendUserBean> baseModel = response.body();
                    if (baseModel.getCode() != 1) {
                        com.hjq.toast.ToastUtils.show(baseModel.getMsg());
                    }
                    observer.onNext(baseModel.getData());
                }
            }

            @Override
            public void onFailure(Call<BaseModel<FriendUserBean>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void createRelation(String room_id, String friend_id, String user1_id, String user2_id, String relation_id, BaseObserver<String> observer) {
        sApiServer.createRelation(room_id, friend_id, user1_id, user2_id, relation_id).enqueue(new Callback<BaseModel<String>>() {

            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                if (response.code() == 200) {
                    BaseModel<String> baseModel = response.body();
                    if (baseModel.getCode() != 1) {
                        com.hjq.toast.ToastUtils.show(baseModel.getMsg());
                    }else {
                        observer.onNext("");
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void setMutePit(String roomId, String user_id, String isMute, BaseObserver<String> observer) {
        sApiServer.setMutePit(roomId, user_id, isMute).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void setLockPit(String roomId, String pitNumber, String isLock, BaseObserver<String> observer) {
        sApiServer.setLockPit(roomId, pitNumber, isLock).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void downPit(String roomId, String pitNumber, BaseObserver<String> observer) {
        sApiServer.downPit(roomId, pitNumber).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void kickOutRoom(String room_id, String user_id, BaseObserver<String> observer) {
        sApiServer.kickOutRoom(room_id, user_id).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void applySong(String room_id, BaseObserver<String> observer) {
        sApiServer.applySong(room_id).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void agreeSong(String room_id, String type, BaseObserver<String> observer) {
        sApiServer.agreeSong(room_id, type).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void endSong(String room_id, BaseObserver<String> observer) {
        sApiServer.endSong(room_id).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void postRoomInfo(String roomId, BaseObserver<RoomInfoResp> observer) {
        sApiServer.postRoomInfo(roomId).enqueue(new Callback<BaseModel<RoomInfoResp>>() {
            @Override
            public void onResponse(Call<BaseModel<RoomInfoResp>> call, Response<BaseModel<RoomInfoResp>> response) {
                if (response.code() == 200){
                    BaseModel<RoomInfoResp> baseModel = response.body();
                    if (baseModel.getCode() != 1){
                        observer.onNext(null);
                    }else {
                        observer.onNext(baseModel.getData());
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<RoomInfoResp>> call, Throwable t) {

            }
        });
    }

    public void getCharmRank(String roomId, BaseObserver<List<RoomCharmRankBean>> observer) {
        sApiServer.getCharmRank(roomId).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void roomRelationList(String type, BaseObserver<List<RoomRelationBean>> observer) {
        sApiServer.roomRelationList(type).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void roomAuctionList(String auction_id, BaseObserver<List<RoomAuction.AuctionListBean>> observer) {
        sApiServer.roomAuctionList(auction_id).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void changeSong(String room_id, String now_did, BaseObserver<String> observer) {
        sApiServer.changeSong(room_id, now_did).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void hostUserPit(String room_id, String pit_number, String user_id, String type, BaseObserver<String> observer) {
        sApiServer.hostUserPit(room_id, pit_number, user_id, type).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void giveCoin(String user_id, String coin, BaseObserver<String> observer) {
        sApiServer.giveCoin(user_id, coin).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                if (response.code() == 200) {
                    BaseModel<String> baseModel = response.body();
                    if (baseModel.getCode() == 1) {
                        com.hjq.toast.ToastUtils.show(baseModel.getMsg());
                        observer.onNext(baseModel.getData());
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void relationCard(String user_id, BaseObserver<RelationCardBean> observer) {
        sApiServer.relationCard(user_id).compose(new DefaultTransformer<>()).subscribe(observer);
    }

    public void topRelationCard(String id, BaseObserver<String> observer) {
        sApiServer.topRelationCard(id).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void deleteRelationCard(String id, BaseObserver<String> observer) {
        sApiServer.deleteRelationCard(id).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }


    public void quitRoom(String room_id, String user_id, BaseObserver<String> observer) {
        sApiServer.quitRoom(room_id, user_id).enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                observer.onNext(null);
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void checkTxt(String room_name, String room_cover, String room_intro, BaseObserver<String> observer) {
        sApiServer.checkTxt(room_name, room_cover, room_intro).enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                if (response.code() == 200) {
                    try {
                        String json = response.body().string();
                        BaseModel<String> baseModel = GsonUtils.fromJson(json, BaseModel.class);
                        if (baseModel.getCode() == 1) {
                            observer.onNext(baseModel.getData());
                        } else {
                            com.hjq.toast.ToastUtils.show(baseModel.getMsg());
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void setUserDecorate(String decorateId, BaseObserver<String> observer) {
        sApiServer.setUserDecorate(decorateId).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void cancelUserDecorate(String type, BaseObserver<String> observer) {
        sApiServer.cancelUserDecorate(type).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                if (response.code() == 200) {
                    observer.onNext("取消成功");
                }
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void publishZone(String images, String content, String topic_id, String room_id, String ip, BaseObserver<String> observer) {

        sApiServer.publishZone(images, content, topic_id, room_id, ip).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void likeZone(String zone_id, BaseObserver<String> observer) {
        sApiServer.likeZone(zone_id).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void deleteComment(String id, BaseObserver<String> observer) {
        sApiServer.deleteComment(id).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });

    }

    public void deleteZone(String id, BaseObserver<String> observer) {
        sApiServer.deleteZone(id).enqueue(new Callback<BaseModel<String>>() {

            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void commentZone(String id, String content, String pid, String reply_to, BaseObserver<String> observer) {
        sApiServer.commentZone(id, content, pid, reply_to).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }


    public void clearLoginInfo(BaseObserver<String> observer) {
        sApiServer.clearLoginInfo(SpUtil.getToken()).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void cancel(BaseObserver<String> observer) {
        sApiServer.cancel(SpUtil.getToken()).enqueue(new Callback<BaseModel<String>>() {

            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void getPostData(String new_password, String mobile, String code, String userId, BaseObserver<String> observer) {
        sApiServer.getPostData(new_password, mobile, code, userId).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
//                ToastUtils.showShort("提示当前账号已在别的地方登陆，如果不是本人操作请修改密码");
                if (t.toString().contains("登录失效")) {
                    try {
                        CommonAppContext.getInstance().clearLoginInfo();
                        ToastUtils.showShort(t.toString());
                    } catch (ClassNotFoundException e) {
                        throw new RuntimeException(e);
                    }
                }
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void forgotPassword(String new_password, String mobile, String sms_code, BaseObserver<String> observer) {
        sApiServer.forgotPassword(new_password, mobile, sms_code).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void createAlbum(String name, String pwd, String image, BaseObserver<String> observer) {
        sApiServer.createAlbum(name, pwd, image).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void editAlbum(String album_id, String name, String pwd, String image, BaseObserver<String> observer) {
        sApiServer.editAlbum(album_id, name, pwd, image).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void editUserInfo(int type, String nickname, String birthday, String sex, String avatar, String images, String profile, String tag_id, BaseObserver<String> observer) {
        if (type == 1) {
            sApiServer.editUserInfo(nickname, birthday, sex, avatar, images, profile, tag_id).enqueue(new Callback<BaseModel<String>>() {

                @Override
                public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                    onNextRetu(response, observer);
                }

                @Override
                public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                    ToastUtils.showShort(t.toString());
                }
            });
        } else {
            sApiServer.editUserBg(images).enqueue(new Callback<BaseModel<String>>() {

                @Override
                public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                    onNextRetu(response, observer);
                }

                @Override
                public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                    ToastUtils.showShort(t.toString());
                }
            });
        }
    }

    public void userGuanz(String user_id, String type, BaseObserver<String> observer) {
        sApiServer.userGuanz(user_id, type).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void acceptPk(String pk_id, String type, BaseObserver<String> observer) {
        sApiServer.acceptPk(pk_id, type).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void clearUserCharm(String roomId, String userId, BaseObserver<String> observer) {
        sApiServer.clearUserCharm(roomId, userId).enqueue(new Callback<BaseModel<String>>() {

            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
                t.printStackTrace();
            }
        });
    }

    public void userOnlineStatus(String user_id, String roomId, BaseObserver<List<UserOnlineStatusBean>> observer) {
        sApiServer.userOnlineStatus(user_id, roomId).enqueue(new Callback<BaseModel<List<UserOnlineStatusBean>>>() {
            @Override
            public void onResponse(Call<BaseModel<List<UserOnlineStatusBean>>> call, Response<BaseModel<List<UserOnlineStatusBean>>> response) {
                if (response.code() == 200) {
                    BaseModel<List<UserOnlineStatusBean>> baseModel = response.body();
                    observer.onNext(baseModel.getData());
                }
            }

            @Override
            public void onFailure(Call<BaseModel<List<UserOnlineStatusBean>>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void postRoomSwToken(String roomId, BaseObserver<PkSwTokenBean> observer) {
        sApiServer.postRoomSwToken(roomId).enqueue(new Callback<BaseModel<PkSwTokenBean>>() {

            @Override
            public void onResponse(Call<BaseModel<PkSwTokenBean>> call, Response<BaseModel<PkSwTokenBean>> response) {
                if (response.code() == 200) {
                    BaseModel<PkSwTokenBean> baseModel = response.body();
                    observer.onNext(baseModel.getData());
                }
            }

            @Override
            public void onFailure(Call<BaseModel<PkSwTokenBean>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void removeBlackList(String user_id, BaseObserver<String> observer) {
        sApiServer.removeBlackList(user_id).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void upAddAlbum(String album_id, String images, String content, BaseObserver<String> observer) {
        sApiServer.upAddAlbum(album_id, images, content).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void moveAlbum(String id, String new_album_id, BaseObserver<String> observer) {
        sApiServer.moveAlbum(id, new_album_id).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void address_ip(String address_ip, BaseObserver<String> observer) {
        sApiServer.address_ip(address_ip).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
//                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
//                com.blankj.utilcode.util.ToastUtils.showShort(t.toString());
            }
        });
    }

    public void deleteAlbum(String id, int type, BaseObserver<String> observer) {
        if (type == 1) {
            sApiServer.deleteAlbumImage(id).enqueue(new Callback<BaseModel<String>>() {
                @Override
                public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                    onNextRetu(response, observer);
                }

                @Override
                public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                    ToastUtils.showShort(t.toString());
                }
            });
        } else {
            sApiServer.deleteAlbum(id).enqueue(new Callback<BaseModel<String>>() {
                @Override
                public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                    onNextRetu(response, observer);
                }

                @Override
                public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                    ToastUtils.showShort(t.toString());
                }
            });
        }
    }


    public void likeAlbum(String albumId, BaseObserver<String> observer) {
        sApiServer.likeAlbum(albumId).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void getRealNameResult(String orderNo, BaseObserver<String> observer) {
        sApiServer.getRealNameResult(orderNo).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void changeRoom(String roomId, String userId, BaseObserver<String> observer) {
        sApiServer.changeRoom(roomId, "-99").enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void changeRoomType(String roomId, String type, BaseObserver<String> observer) {
        sApiServer.changeRoomType(roomId, type).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                ToastUtils.showShort(t.toString());
            }
        });
    }

    public void onNextRetu(Response<BaseModel<String>> response, BaseObserver<String> observer) {
        if (response.code() == 200) {
            BaseModel<String> string = response.body();
            if (string != null) {
                int code = string.getCode();
                if (code == 1) {
                    observer.onNext(string.getMsg());

                } else if (code == 301) {
                    try {
//                        com.blankj.utilcode.util.ToastUtils.showShort("提示当前账号已在别的地方登陆，如果不是本人操作请修改密码");
                        ToastUtils.showShort(string.getMsg());
                        CommonAppContext.getInstance().clearLoginInfo();
                    } catch (ClassNotFoundException e) {
                        throw new RuntimeException(e);
                    }
                    ToastUtils.showShort(string.getMsg());
                }else {
                    ToastUtils.showShort(string.getMsg());
                }
            }

        }
    }
    ///获取活动礼物列表
    public void getBoxGiftList(String giftBagId, String roomId, BaseObserver<BlindBoxBean> observer){
        sApiServer.getBoxGiftList(giftBagId, roomId).enqueue(new Callback<BaseModel<BlindBoxBean>>() {
            @Override
            public void onResponse(Call<BaseModel<BlindBoxBean>> call, Response<BaseModel<BlindBoxBean>> response) {
                if (response.code() == 200) {
                    BaseModel<BlindBoxBean> baseModel = response.body();
                    if (baseModel.getCode()==1) {
                        observer.onNext(baseModel.getData());
                    }else {
                        observer.onNext(null);
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<BlindBoxBean>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }
    ///巡乐会
    public void getBoxGiftListXLH( String roomId, BaseObserver<BlindBoxBean> observer){
        sApiServer.getBoxGiftListXLH(roomId).enqueue(new Callback<BaseModel<BlindBoxBean>>() {
            @Override
            public void onResponse(Call<BaseModel<BlindBoxBean>> call, Response<BaseModel<BlindBoxBean>> response) {
                if (response.code() == 200) {
                    BaseModel<BlindBoxBean> baseModel = response.body();
                    observer.onNext(baseModel.getData());
                }
            }

            @Override
            public void onFailure(Call<BaseModel<BlindBoxBean>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    ///巡乐会抽奖
    public void xlhChou(String roomId, String num,BaseObserver<List<XlhDrawBean>> observer){
        sApiServer.xlhChou(roomId,num).enqueue(new Callback<BaseModel<List<XlhDrawBean>>>() {
            @Override
            public void onResponse(Call<BaseModel<List<XlhDrawBean>>> call, Response<BaseModel<List<XlhDrawBean>>> response) {
                if (response.code() == 200) {
                    BaseModel<List<XlhDrawBean>> baseModel = response.body();
                    if (baseModel.getCode()==1) {
                        if (baseModel != null && baseModel.getData() != null) {
                            observer.onNext(baseModel.getData());
                        }
                    }else {
                        observer.onNext(null);
                        ToastUtils.showShort(baseModel.getMsg());
                    }

                }
            }

            @Override
            public void onFailure(Call<BaseModel<List<XlhDrawBean>>> call, Throwable t) {
                t.printStackTrace();
            }
        });

    }

    ///盲盒转盘抽奖
    public void drawGiftList(String giftBagId, String gift_user_ids, String roomId, String num,String heart_id,BaseObserver<BlindReslutBean> observer){
        sApiServer.drawGiftList(giftBagId, gift_user_ids, roomId, num,heart_id).enqueue(new Callback<BaseModel<BlindReslutBean>>() {
            @Override
            public void onResponse(Call<BaseModel<BlindReslutBean>> call, Response<BaseModel<BlindReslutBean>> response) {
                if (response.code() == 200) {
                    BaseModel<BlindReslutBean> baseModel = response.body();
                    if (baseModel.getCode()==1) {
                        observer.onNext(baseModel.getData());
                    }else {
                        observer.onNext(null);
                        ToastUtils.showShort(baseModel.getMsg());
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<BlindReslutBean>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void getMyRecord(String giftBagId,String page,String pageSize,BaseObserver<List<GiftBean>> observer){
        sApiServer.getMyRecord(giftBagId,page,pageSize).enqueue(new Callback<BaseModel<List<GiftBean>>>() {
            @Override
            public void onResponse(Call<BaseModel<List<GiftBean>>> call, Response<BaseModel<List<GiftBean>>> response) {
                if (response.code()==200){
                    BaseModel<List<GiftBean>> baseModel = response.body();
                    if (baseModel.getCode()==1){
                        observer.onNext(baseModel.getData());
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<List<GiftBean>>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void xlhAllRecord(String roomId,String page,String pageSize,BaseObserver<List<GiftBean>> observer){
        sApiServer.xlhAllRecord(roomId,page,pageSize).enqueue(new Callback<BaseModel<List<GiftBean>>>() {
            @Override
            public void onResponse(Call<BaseModel<List<GiftBean>>> call, Response<BaseModel<List<GiftBean>>> response) {
                if (response.code()==200){
                    BaseModel<List<GiftBean>> baseModel = response.body();
                    if (baseModel.getCode()==1){
                        observer.onNext(baseModel.getData());
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<List<GiftBean>>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void xlhMyRecord(String roomId,String page,String pageSize,BaseObserver<List<GiftBean>> observer){
        sApiServer.xlhMyRecord(roomId,page,pageSize).enqueue(new Callback<BaseModel<List<GiftBean>>>() {
            @Override
            public void onResponse(Call<BaseModel<List<GiftBean>>> call, Response<BaseModel<List<GiftBean>>> response) {
                if (response.code()==200){
                    BaseModel<List<GiftBean>> baseModel = response.body();
                    if (baseModel.getCode()==1){
                        observer.onNext(baseModel.getData());
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<List<GiftBean>>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void getAllRecord(String giftBagId,String page,String pageSize,BaseObserver<List<GiftBean>> observer){
        sApiServer.getAllRecord(giftBagId,page,pageSize).enqueue(new Callback<BaseModel<List<GiftBean>>>() {
            @Override
            public void onResponse(Call<BaseModel<List<GiftBean>>> call, Response<BaseModel<List<GiftBean>>> response) {
                if (response.code()==200){
                    BaseModel<List<GiftBean>> baseModel = response.body();
                    if (baseModel.getCode()==1){
                        observer.onNext(baseModel.getData());
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<List<GiftBean>>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void giftSend(String send_id,BaseObserver<String> observer){
        sApiServer.giftSend(send_id).enqueue(new Callback<BaseModel<String>>() {
            @Override
            public void onResponse(Call<BaseModel<String>> call, Response<BaseModel<String>> response) {
                onNextRetu(response, observer);
            }

            @Override
            public void onFailure(Call<BaseModel<String>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

    public void roomUserCharmList(String room_id, String user_id, BaseObserver<List<RoomUserCharmListBean>> observer){
        sApiServer.roomUserCharmList(room_id,user_id).enqueue(new Callback<BaseModel<List<RoomUserCharmListBean>>>() {
            @Override
            public void onResponse(Call<BaseModel<List<RoomUserCharmListBean>>> call, Response<BaseModel<List<RoomUserCharmListBean>>> response) {
                if (response.code()==200){
                    BaseModel<List<RoomUserCharmListBean>> baseModel = response.body();
                    if (baseModel.getCode()==1){
                        observer.onNext(baseModel.getData());
                    }else if (baseModel.getCode()==0){
                        observer.onNext(null);
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseModel<List<RoomUserCharmListBean>>> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }

}