package com.wd.common.utils;

import android.app.Activity;
import android.app.Dialog;
import android.text.TextUtils;

import com.alibaba.fastjson.JSONObject;
import com.wd.base.log.Logger;
import com.wd.capability.network.BaseObserver;
import com.wd.capability.network.RetrofitClient;
import com.wd.capability.network.bean.MetaBean;
import com.wd.capability.network.cachedata.CacheData;
import com.wd.capability.network.cachedata.CacheH5PageData;
import com.wd.capability.network.constant.EventConstants;
import com.wd.capability.network.constant.ParameterConstant;
import com.wd.capability.network.fetcher.BaseDataFetcher;
import com.wd.capability.network.response.BaseResponse;
import com.wd.common.api.RequestApi;
import com.wd.common.dialog.CommandDialog;
import com.wd.common.dialog.PrizeDrawDialog;
import com.wd.common.incentive.constants.TaskOperateTypeConstants;
import com.wd.common.incentive.task.TaskManager;
import com.wd.common.interact.ICommentDataNewListener;
import com.wd.common.interact.follow.model.FollowDataFetcher;
import com.wd.common.interact.like.callback.LikeCallback;
import com.wd.common.interfaces.AudioChannelBack;
import com.wd.common.interfaces.OnGetContentBeanSuccessListener;
import com.wd.common.listener.IUploadImgListener;
import com.wd.common.listener.ResultCallback;
import com.wd.common.listener.ResultMd5Callback;
import com.wd.fastcoding.base.R;
import com.wd.foundation.bean.CompParameterBean;
import com.wd.foundation.bean.collect.CollectContentBean;
import com.wd.foundation.bean.collect.CollectTagsBean;
import com.wd.foundation.bean.comment.CommentListBean;
import com.wd.foundation.bean.comment.CommentStatusBean;
import com.wd.foundation.bean.comment.DisplayWorkInfoBean;
import com.wd.foundation.bean.convenience.AskBean;
import com.wd.foundation.bean.convenience.CertRegisterBean;
import com.wd.foundation.bean.convenience.CheckRegisterBean;
import com.wd.foundation.bean.custom.comp.ChannelInfoBean;
import com.wd.foundation.bean.custom.comp.GroupBean;
import com.wd.foundation.bean.custom.comp.PageBean;
import com.wd.foundation.bean.custom.comp.TopicInfoBean;
import com.wd.foundation.bean.custom.content.CommentItem;
import com.wd.foundation.bean.custom.content.ContentBean;
import com.wd.foundation.bean.custom.content.ContentTypeConstant;
import com.wd.foundation.bean.custom.vote.InteractiveComponentBean;
import com.wd.foundation.bean.custom.vote.live.LiveInteractiveVotingBean;
import com.wd.foundation.bean.incentive.LevelInfoBean;
import com.wd.foundation.bean.live.RoomDataBean;
import com.wd.foundation.bean.live.SendMessageTalkToEveryOneBean;
import com.wd.foundation.bean.live.WatermarkBean;
import com.wd.foundation.bean.livedate.EventMessage;
import com.wd.foundation.bean.publish.EditDataBean;
import com.wd.foundation.bean.request.PublishCommentParameterBean;
import com.wd.foundation.bean.response.AudioPlaybackQuantityBean;
import com.wd.foundation.bean.response.CodeIdentifyBean;
import com.wd.foundation.bean.response.CommonConfigBean;
import com.wd.foundation.bean.response.GetPullAddressBean;
import com.wd.foundation.bean.response.ImageCoverBean;
import com.wd.foundation.bean.response.InteractResponseDataBean;
import com.wd.foundation.bean.response.InviterResp;
import com.wd.foundation.bean.response.LiveCommentBean;
import com.wd.foundation.bean.response.MasterFollowsStatusBean;
import com.wd.foundation.bean.response.MyAskMarkBean;
import com.wd.foundation.bean.response.NewsDetailBean;
import com.wd.foundation.bean.response.PersonalInfoBean;
import com.wd.foundation.wdkitcore.constant.BaseConstants;
import com.wd.foundation.wdkit.constant.IntentConstants;
import com.wd.foundation.wdkit.file.MyFileUtils;
import com.wd.foundation.wdkit.utils.CommonUtil;
import com.wd.foundation.wdkit.system.DeviceUtil;
import com.wd.foundation.wdkit.utils.MyActivityManager;
import com.wd.foundation.wdkit.utils.SpUtils;
import com.wd.foundation.bean.utils.TimeUtil;
import com.wd.foundation.wdkit.utils.ToastNightUtil;
import com.wd.foundation.wdkitcore.livedata.LiveDataBus;
import com.wd.foundation.wdkitcore.tools.ArrayUtils;
import com.wd.foundation.wdkitcore.tools.HostUtil;
import com.wd.foundation.wdkitcore.tools.JsonUtils;
import com.wd.foundation.wdkitcore.tools.ResUtils;
import com.wd.foundation.wdkitcore.tools.StringUtils;

import org.jetbrains.annotations.NotNull;

import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import okhttp3.ResponseBody;


/**
 * 公共网络请求类
 */
public class CommonNetUtils extends BaseDataFetcher<RequestApi> {

    private static final String TAG = "CommonNetUtils";

    /**
     * 抽奖弹框
     */
    public PrizeDrawDialog prizeDrawDialog;

    private static CommonNetUtils instance = new CommonNetUtils();

    public static CommonNetUtils getInstance() {
        return instance;
    }

    public static String onSuccess = "onSuccess";
    public static String dealSpecialCode = "dealSpecialCode";
    public static String onError = "onError";
    public static String Tag = "CommonNetUtils";

    //postValue 与 setValue 一样都是用来更新 LiveData 数据的方法：
    //setValue 只能在主线程调用，同步更新数据
    //postValue 可在后台线程调用，其内部会切换到主线程调用 setValue
    //当连续调用 postValue 时，有可能只会收到最后一次数据更新通知。 （这些暂时的 以后还是用viewmodel）

    /**
     * 获取IM--token appid  和  key
     */
    public void getIMAppidAppKey(BaseObserver<String> baseObserver) {
//        Observable<BaseResponse<String>> requestData = getRetrofit().getIMAppKey();
//        request(requestData, baseObserver);
    }

    // 提前获取到 userid  和设备id
    public void getToken(final String userId, final String userName, final ResultCallback<String> callback) {

        Observable<BaseResponse<String>> codeData = getRetrofit().getIMToken(userId, userName);
        request(codeData, new BaseObserver<String>() {
            @Override
            protected void dealSpecialCode(int code, String message) {

            }

            @Override
            public void onSuccess(String s) {
                if (callback != null) {
                    callback.onSuccess(s);
                }

            }

            @Override
            public void _onError(String e) {
                if (callback != null) {
                    callback.onError(e);
                }

            }
        });
    }


    /**
     * 获取直播信息  或者 音频详情 获取详情页信息
     *
     * @param contentId
     */
    public void getLiveDetail(String contentId, String relType, String relId, final ResultCallback<NewsDetailBean> callback) {
        Map<String, Object> params = new HashMap<>();
        //稿件ID不能为空
        if (StringUtils.isBlank(contentId)) {
            if (callback != null) {
                callback.onError("");
            }
            return;
        }
        params.put(ParameterConstant.CONTENTID, contentId);

        if (StringUtils.isNotBlank(relId)) {
            params.put(ParameterConstant.CONTENT_REL_ID, relId);
        }
        if (StringUtils.isNotBlank(relType)) {
            params.put(ParameterConstant.CONTENT_REL_TYPE, relType);
        }
        Observable<BaseResponse<List<NewsDetailBean>>> codeData = getRetrofit().getOneNewsDetail(params);
        request(codeData, new BaseObserver<List<NewsDetailBean>>() {
            @Override
            protected void dealSpecialCode(int code, String message) {
                if (callback != null) {
                    callback.onError(message);
                }
            }

            @Override
            public void onSuccess(List<NewsDetailBean> newsDetailBeanList) {
                if (CommonUtil.isEmpty(newsDetailBeanList)) {
                    if (callback != null) {
                        callback.onError(ResUtils.getString(R.string.res_content_no_exist));
                    }
                    return;
                }
                if (callback != null) {
                    NewsDetailBean mNewsDetailBean = newsDetailBeanList.get(0);
                    callback.onSuccess(mNewsDetailBean);
                }
            }

            @Override
            public void _onError(String e) {
                if (callback != null) {
                    callback.onError(e);
                }

            }
        });
    }

    /**
     * 获取直播信息  或者 音频详情 获取详情页信息
     *
     * @param contentId
     */
    public void getNewsDetail(String contentId,String relId, String relType, OnGetContentBeanSuccessListener mOnGetContentBeanSuccessListener) {
        if (StringUtils.isBlank(contentId)) {
            return;
        }
        Map<String, Object> params = new HashMap<>();
        //稿件ID不能为空
        if (StringUtils.isBlank(contentId)) {
            if (mOnGetContentBeanSuccessListener != null) {
                mOnGetContentBeanSuccessListener.onGetDataFailure("");
            }
            return;
        }
        params.put(ParameterConstant.CONTENTID, contentId);

        if (StringUtils.isNotBlank(relId)) {
            params.put(ParameterConstant.CONTENT_REL_ID, relId);
        }
        if (StringUtils.isNotBlank(relType)) {
            params.put(ParameterConstant.CONTENT_REL_TYPE, relType);
        }
        Observable<BaseResponse<List<NewsDetailBean>>> observable = getRetrofit().getOneNewsDetail(params);
        request(observable, new BaseObserver<List<NewsDetailBean>>() {
            @Override
            protected void dealSpecialCode(int code, String message) {
                if (mOnGetContentBeanSuccessListener != null) {
                    mOnGetContentBeanSuccessListener.onGetDataFailure(message);
                }
            }

            @Override
            protected void onSuccess(List<NewsDetailBean> newsDetailBeanList) {
//                if (CommonUtil.isEmpty(newsDetailBeanList)) {
//                    return;
//                }
                if (mOnGetContentBeanSuccessListener != null) {
                    if (CommonUtil.isEmpty(newsDetailBeanList)){
                        mOnGetContentBeanSuccessListener.onGetDataSuccess(null);
                    }else{
                        ContentBean contentBean = HistorySqliteDataChange.newsDetailBeanToUiBean(newsDetailBeanList.get(0));
                        mOnGetContentBeanSuccessListener.onGetDataSuccess(contentBean);
                    }
                }
            }

            @Override
            public void _onError(String message) {
                if (mOnGetContentBeanSuccessListener != null) {
                    mOnGetContentBeanSuccessListener.onGetDataFailure(message);
                }
            }
        });
    }
    /**
     * 发送消息大家聊
     * 登录发评论和未登录以游客发送评论
     */
    public void sendMessageTalkToEveryone(String text, String liveId, String mliveId, String roomId, String title, String customizeExpression, BaseObserver<LiveCommentBean> baseObserver) {

        if (PDUtils.isLogin()) {
            SendMessageTalkToEveryOneBean sendMessageTalkToEveryOneBean = new SendMessageTalkToEveryOneBean(text, liveId, mliveId, roomId, title
                    , SpUtils.getUserId(), SpUtils.getUserName(), SpUtils.getHeadPhotoUrl(),"audience", DeviceUtil.getDeviceId(), customizeExpression);

            Observable<BaseResponse<LiveCommentBean>> observable = getRetrofit().sendMessageTalkToEveryone(getBody(sendMessageTalkToEveryOneBean));
            request(observable,baseObserver);
            //执行任务：评论
            TaskManager.getInstance().executePointLevelOperate(TaskOperateTypeConstants.COMMENT);
        }else{
            //未登录，以游客形式评论发送, 游客暂无头像
            SendMessageTalkToEveryOneBean sendMessageTalkToEveryOneBean = new SendMessageTalkToEveryOneBean(text, liveId, mliveId, roomId, title
                    , "", SpUtils.getTouristNickname(),"", "tourist", DeviceUtil.getDeviceId(), customizeExpression);
            Observable<BaseResponse<LiveCommentBean>> observable = getRetrofit().sendMessageTouristToEveryone(getBody(sendMessageTalkToEveryOneBean));
            request(observable, baseObserver);
        }

        //保存游客评论第一条的时间，格式：yyyy-MM-dd HH:mm:ss--直播评论
        try {
            //没有存时间时，需要保持下
            if(TextUtils.isEmpty(SpUtils.getLiveFirstCommentTime())) {
                String currentDatetime = TimeUtil.currentDatetime();
                SpUtils.saveLiveFirstCommentTime(currentDatetime);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 发送消息大家聊 (发送带有图片的)
     * 登录发评论和未登录以游客发送评论
     */
    public void sendMessageTalkToEveryone(String text, String liveId, String mliveId, String roomId
            , String title, String imageUrl,String pictureResolutions, String customizeExpression, BaseObserver<LiveCommentBean> baseObserver) {
        List<String> strings = new ArrayList<>();
        strings.add(imageUrl);

        if (PDUtils.isLogin()) {
            SendMessageTalkToEveryOneBean sendMessageTalkToEveryOneBean = new SendMessageTalkToEveryOneBean(text, liveId, mliveId, roomId, title
                    , SpUtils.getUserId(), SpUtils.getUserName(), SpUtils.getHeadPhotoUrl(), "audience", DeviceUtil.getDeviceId(), customizeExpression);
            sendMessageTalkToEveryOneBean.imageUrl = imageUrl;
            sendMessageTalkToEveryOneBean.pictureResolutions = pictureResolutions;
            Observable<BaseResponse<LiveCommentBean>> observable = getRetrofit().sendMessageTalkToEveryone(getBody(sendMessageTalkToEveryOneBean));
            request(observable, baseObserver);
            //执行任务：评论
            TaskManager.getInstance().executePointLevelOperate(TaskOperateTypeConstants.COMMENT);
        }else {
            SendMessageTalkToEveryOneBean sendMessageTalkToEveryOneBean = new SendMessageTalkToEveryOneBean(text, liveId, mliveId, roomId, title
                    , "", SpUtils.getTouristNickname(), "", "tourist", DeviceUtil.getDeviceId(), customizeExpression);
            sendMessageTalkToEveryOneBean.imageUrl = imageUrl;
            sendMessageTalkToEveryOneBean.pictureResolutions = pictureResolutions;
            Observable<BaseResponse<LiveCommentBean>> observable = getRetrofit().sendMessageTouristToEveryone(getBody(sendMessageTalkToEveryOneBean));
            request(observable, baseObserver);
        }

        //保存游客评论第一条的时间，格式：yyyy-MM-dd HH:mm:ss--直播评论
        try {
            //没有存时间时，需要保持下
            if(TextUtils.isEmpty(SpUtils.getLiveFirstCommentTime())) {
                String currentDatetime = TimeUtil.currentDatetime();
                SpUtils.saveLiveFirstCommentTime(currentDatetime);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 游客评论合并接口
     * @param observer
     */
    public void visitorMergeComment(BaseObserver<Object> observer) {
        HashMap<String, Object> queryMap = new HashMap<>(16);
        queryMap.put(ParameterConstant.TIME, SpUtils.getTouristFirstCommentTime());
        queryMap.put(ParameterConstant.DEVICEID, DeviceUtil.getDeviceId());
        Observable<BaseResponse<Object>> certRegisterObservable = getRetrofit().
                visitorMergeComment(getBody(queryMap));
        request(certRegisterObservable,observer);
    }

    /**
     * 直播和回放的游客评论合并接口
     * @param observer
     */
    public void LiveMessageMergeComment(BaseObserver<Object> observer) {
        HashMap<String, Object> queryMap = new HashMap<>(16);
        queryMap.put(ParameterConstant.TIME, SpUtils.getLiveFirstCommentTime());
        queryMap.put(ParameterConstant.DEVICEID, DeviceUtil.getDeviceId());

        Observable<BaseResponse<Object>> certRegisterObservable = getRetrofit().
                liveMessageMergeComment(getBody(queryMap));
        request(certRegisterObservable,observer);
    }

    /**
     * 点赞接口
     */
    public void setLike(long liveId, String number ) {
        HashMap<String, Object> queryMap = new HashMap<>();
        queryMap.put("liveId", liveId + "");
        queryMap.put("number", number);
        queryMap.put("deviceId", DeviceUtil.getDeviceId());
        Observable<BaseResponse<Number>> codeData = getRetrofit().setLike(queryMap);
        request(codeData, new BaseObserver<Number>() {
            @Override
            protected void dealSpecialCode(int code, String message) {

            }

            @Override
            public void onSuccess(Number bean) {
                if (bean == null){
                    return;
                }
               // 点赞数据本地更新改造，不依赖接口
//                roomDataBean.setLikeNum(bean.toString());
//                ToastUtils.showShort("点赞接口回调成功");
//                LiveDataBus.getInstance().with(EventConstants.ZH_ROOM_NUMBER_EVENT, RoomDataBean.class).postValue(roomDataBean);

            }

            @Override
            public void _onError(String e) {
//                ToastUtils.showShort("点赞接口回调失败");
            }
        });
        //执行任务：点赞
        TaskManager.getInstance().executePointLevelOperate(TaskOperateTypeConstants.LIKE);
    }

    /**
     * C端在线人次访问
     */
    public void getOnlineVisits(String liveId, String number, String roomId) {
        HashMap<String, Object> queryMap = new HashMap<>();
        queryMap.put("liveId", liveId);
        queryMap.put("number", number);
        queryMap.put("roomId", roomId);
        if (PDUtils.isLogin()) {
            String senderUserName = SpUtils.getUserName();
            queryMap.put("senderUserName", senderUserName);
            queryMap.put("userId", SpUtils.getUserId());
        }
        Observable<BaseResponse<Object>> codeData = getRetrofit().getOnlineVisits(getBody(queryMap));
        request(codeData, new BaseObserver<Object>() {

            @Override
            protected void dealSpecialCode(int code, String message) {

            }

            @Override
            protected void onSuccess(Object o) {

            }
        });
    }

    /**
     * C端人数
     */
    public void getRoomData(String liveId, BaseObserver<RoomDataBean> baseObserver) {
        HashMap<String, Object> queryMap = new HashMap<>();
        queryMap.put("liveId", liveId);
        Observable<BaseResponse<RoomDataBean>> codeData = getRetrofit().getRoomData(queryMap);
        request(codeData, baseObserver);
    }

    /**
     * 查询直播间水印
     */
    public void getLiveRoomWatermarkData(String liveId,String landscape, BaseObserver<WatermarkBean> baseObserver) {
        HashMap<String, Object> queryMap = new HashMap<>();
        //id	是直播流id
        queryMap.put("id", liveId);
        //tenancy	是 租户字段（1-视界 2-英文版 3-中文版）
        queryMap.put("tenancy", "3");
        //landscape	是 2竖屏，1，横屏
        queryMap.put("landscape", landscape);
        Observable<BaseResponse<WatermarkBean>> codeData = getRetrofit().getLiveRoomWatermark(queryMap);
        request(codeData, baseObserver);
    }


    /**
     * 获取H5专题接口数据作为缓存数据，仅需要处理成功即可
     * @param pageId
     * @param topicId
     */
    public void getPageInfoForH5Subject(String pageId, String topicId) {
        Map<String, Object> map = new HashMap<>();
        map.put("pageId", pageId);
        map.put("topicId", topicId);
        Observable<ResponseBody> pageDataObservable = getRetrofit().getPageDataForH5Topic(map);
        RetrofitClient.execute(pageDataObservable, new Observer<ResponseBody>() {
            @Override
            public void onSubscribe(@NotNull Disposable d) {

            }

            @Override
            public void onNext(@NotNull ResponseBody responseBody) {
                try {
                    JSONObject jsonObject = JSONObject.parseObject(responseBody.string());
                    CacheH5PageData.getInstance().addPageInfoCache(pageId, topicId, jsonObject);
                    //page请求成功进行请求comp
                    JSONObject data = jsonObject.getJSONObject("data");
                    if (null != data){
                        PageBean pageBean = JsonUtils.convertJsonToObject(data.toString(), PageBean.class);
                        getCompInfoForH5Subject(pageBean);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onError(@NotNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    /**
     * 获取H5专题接口Comp数据作为缓存数据，仅需要处理成功即可
     * 只请求第一页
     */
    public void getCompInfoForH5Subject(PageBean pageBean) {
        if (null == pageBean){
            return;
        }
        String pageId = pageBean.getId();
        Map<String, Object> map = new HashMap<>();
        // 必须参数取第一个楼层
        if (ArrayUtils.isNotEmpty(pageBean.getGroups()) ){
            GroupBean groupBean = pageBean.getGroups().get(0);
            if (null != groupBean){
                map.put("groupId", groupBean.getId());
            }
        }
        map.put("pageNum", 1);

        map.put("pageSize", 20);

        map.put("pageId", pageId);

        map.put("loadStrategy", "first_load");

        map.put("refreshTime", pageBean.getRefreshTime());

        ChannelInfoBean channelInfo = pageBean.getChannelInfo();
        if (null != channelInfo){
            // 非必须参数
            if (!TextUtils.isEmpty(channelInfo.getChannelId())) {
                map.put("channelId", channelInfo.getChannelId());
            }

            if (!TextUtils.isEmpty(channelInfo.getChannelStrategy())) {
                map.put("channelStrategy", channelInfo.getChannelStrategy());
            }
        }

        TopicInfoBean topicInfo = pageBean.getTopicInfo();
        String topicId = "";
        int topicType;
        if (null != topicInfo){
            topicId = topicInfo.getTopicId();
            topicType = topicInfo.getTopicType();
            if (!TextUtils.isEmpty(topicId)) {
                map.put("topicId",topicId);
            }
            if (0 != topicType){
                map.put("topicType",topicType);
            }
        }

        Observable<ResponseBody> pageDataObservable = getRetrofit().getGroupDataForH5Topic(map);
        String finalTopicId = topicId;
        RetrofitClient.execute(pageDataObservable, new Observer<ResponseBody>() {
            @Override
            public void onSubscribe(@NotNull Disposable d) {

            }

            @Override
            public void onNext(@NotNull ResponseBody responseBody) {
                try {
                    JSONObject jsonObject = JSONObject.parseObject(responseBody.string());
                    CacheH5PageData.getInstance().addCompInfoCacheData(pageId, finalTopicId, jsonObject);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onError(@NotNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }


    /**
     * 获取页面详情信息
     *
     * @param pageId
     * @param callback
     */
    public void getPageInfor(String pageId, final ResultMd5Callback<PageBean> callback) {
        Map<String, Object> map = new HashMap<>();
        map.put("pageId", pageId);
        Observable<BaseResponse<PageBean>> pageDataObservable = getRetrofit().getPageData(map);
        request(pageDataObservable, new BaseObserver<PageBean>() {

            @Override
            protected void dealSpecialCode(int code, String message) {
                if (callback != null) {
                    callback.onError(message);
                }
            }

            @Override
            protected void onSuccess(PageBean pageBean, MetaBean metaBean, String msg, int code) {
                if (callback != null) {
                    callback.onSuccess(pageBean,metaBean,msg,code);
                }
            }

            @Override
            protected void onSuccess(PageBean pageBean) {

            }


            @Override
            protected void _onError(String e) {
                ToastNightUtil.showShort(e);
                if (callback != null) {
                    callback.onError(e);
                }
            }
        });
    }


    /**
     * 获取早晚报页面信息
     * @param callback
     */
    public void getDailyPaperId(final ResultCallback<PageBean> callback) {
        Observable<BaseResponse<PageBean>> pageDataObservable = getRetrofit().dailyPaperTopic();
        request(pageDataObservable, new BaseObserver<PageBean>() {

            @Override
            protected void dealSpecialCode(int code, String message) {
                if (callback != null) {
                    callback.onError(message);
                }
            }

            @Override
            protected void onSuccess(PageBean pageBean) {
                if (callback != null) {
                    callback.onSuccess(pageBean);
                }
            }


            @Override
            protected void _onError(String e) {
                ToastNightUtil.showShort(e);
                if (callback != null) {
                    callback.onError(e);
                }
            }
        });
    }


    /**
     * 用户关注/取消关注接口
     * @param pageId
     * @param attentionUserId
     * @param attentionUserType
     * @param attentionCreatorId
     * @param status   状态（ 0：取消关注 1：关注）
     */
    public void operation(String pageId, String attentionUserId, String attentionUserType, String attentionCreatorId, int status) {
        if (TextUtils.isEmpty(SpUtils.getUserToken())) {
            ToastNightUtil.showShort(ResUtils.getString(R.string.please_login));
            return;
        }
        HashMap<String, Object> queryMap = new HashMap<>();
        queryMap.put("attentionUserId", attentionUserId); // 被关注用户ID
        queryMap.put("attentionUserType", attentionUserType);// 被关注用户类型
        queryMap.put("status", status); // 状态（ 0：取消关注 1：关注）
        queryMap.put("userId", SpUtils.getUserId()); // 关注用户ID
        queryMap.put("attentionCreatorId", attentionCreatorId);//被关注用户的创作者id
        queryMap.put(ParameterConstant.USER_TYPE, SpUtils.getUserType());
        Observable<BaseResponse<Object>> register = getRetrofit().postFocusUser(getBody(queryMap));
        request(register, new BaseObserver<String>() {
            @Override
            protected void dealSpecialCode(int code, String message) {

            }

            @Override
            public void onSuccess(String mData) {

                EventMessage mEventMessage = new EventMessage(EventConstants.FRESH_FOLLOW_CREATOR_EVENT);
                mEventMessage.putExtra(IntentConstants.USER_ID, attentionUserId);
                mEventMessage.putExtra(IntentConstants.PARAM_CREATOR_ID, attentionCreatorId);
                mEventMessage.putExtra(IntentConstants.PARAM_PAGE_ID, pageId);
                mEventMessage.putExtra(IntentConstants.IS_FOLLOW, status == 1);
                //全局刷新创作者关注状态
                LiveDataBus.getInstance().with(EventConstants.FRESH_FOLLOW_CREATOR_EVENT).postValue(mEventMessage);
//                if(status == 1){
//                    ToastNightUtil.showShort(R.string.toast_follow_success);
//                }
                if(status == 1){
                    //执行任务：关注
                    TaskManager.getInstance().executePointLevelOperate(TaskOperateTypeConstants.FOLLOW);
                }
            }

            @Override
            public void _onError(String e) {
                EventMessage mEventMessage = new EventMessage(EventConstants.FRESH_FOLLOW_CREATOR_EVENT);
                mEventMessage.putExtra(IntentConstants.USER_ID, attentionUserId);
                mEventMessage.putExtra(IntentConstants.PARAM_CREATOR_ID, attentionCreatorId);
                mEventMessage.putExtra(IntentConstants.PARAM_PAGE_ID, pageId);
                //全局刷新创作者关注状态
                LiveDataBus.getInstance().with(EventConstants.FRESH_FOLLOW_CREATOR_ERROR_EVENT).postValue(mEventMessage);
            }
        });
    }
    /**
     * 用户关注/取消关注接口
     * @param attentionUserId
     * @param attentionUserType
     * @param attentionCreatorId
     * @param status   状态（ 0：取消关注 1：关注）
     */
    public void operation(String attentionUserId, String attentionUserType, String attentionCreatorId, int status, BaseObserver<String> baseObserver) {
        if (TextUtils.isEmpty(SpUtils.getUserToken())) {
            ToastNightUtil.showShort(ResUtils.getString(R.string.please_login));
            return;
        }
        HashMap<String, Object> queryMap = new HashMap<>();
        queryMap.put("attentionUserId", attentionUserId); // 被关注用户ID
        queryMap.put("attentionUserType", attentionUserType);// 被关注用户类型
        queryMap.put("status", status); // 状态（ 0：取消关注 1：关注）
        queryMap.put("userId", SpUtils.getUserId()); // 关注用户ID
        queryMap.put("attentionCreatorId", attentionCreatorId);//被关注用户的创作者id
        queryMap.put(ParameterConstant.USER_TYPE, SpUtils.getUserType());
        Observable<BaseResponse<Object>> register = getRetrofit().postFocusUser(getBody(queryMap));
        request(register, baseObserver);
    }

    /**
     * 查询单个创作者关注状态
     */
    public void getMasterStatusRequest(String creatorId, FollowDataFetcher.GetFollowStatusListener mGetFollowStatusListener) {
        //未登录不需调用
        if (TextUtils.isEmpty(SpUtils.getUserToken())) {
            return;
        }
        //批量查询创作者的关注状态-参数为空不调用接口
        if (StringUtils.isBlank(creatorId)){
            return;
        }
        Map<String, Object> map = new HashMap<>();
        List<Map<String, Object>> listMap = new ArrayList<>();
        Map<String, Object> mapT = new HashMap<>();
        mapT.put("creatorId", creatorId);
        listMap.add(mapT);
        map.put("creatorIds", listMap);
        Observable<BaseResponse<List<MasterFollowsStatusBean>>> codeData = getRetrofit().getBatchAttentionStatus(getBody(map));
        request(codeData, new BaseObserver<List<MasterFollowsStatusBean>>() {
            @Override
            protected void dealSpecialCode(int code, String message) {

            }

            @Override
            public void onSuccess(List<MasterFollowsStatusBean> list) {
                if (mGetFollowStatusListener != null) {
                    if (CommonUtil.isEmpty(list)) {
                        return;
                    }
                    mGetFollowStatusListener.onSuccess(list.get(0));
                }
            }

            @Override
            public void _onError(String e) {

            }
        });
    }


    /**
     * 上传封面
     */
    public void sendImageCover(String format, String useType, BaseObserver<ImageCoverBean> baseObserver) {
        Map<String, Object> map = new HashMap<>();
        map.put("toward", "h");
        //格式mp4 png等
        map.put("format", format);
        //preview预告片 cover封面图share分享图
        map.put("useType", useType);
        map.put("contentType", "image/png");
        Observable<BaseResponse<ImageCoverBean>> codeData = getRetrofit().createImageCover(getBody(map));
        request(codeData, baseObserver);

    }

    public void uploadImageTry(String mUrl, String callback, String sourcePath, IUploadImgListener listenCallback) {
        uploadImage(mUrl, callback, sourcePath,listenCallback);
    }

    /**
     * 上传图片
     */
    public void uploadImage(String mUrl, String callback, String sourcePath,IUploadImgListener mListener) {
        OutputStream outputStream = null;
        try {
            File file = new File(sourcePath);
    //        putImg(mUrl,sourcePath);
            URL url = new URL(mUrl);
            URLConnection rulConnection = url.openConnection();
            HttpURLConnection httpUrlConnection = (HttpURLConnection) rulConnection;
            httpUrlConnection.setRequestMethod("PUT");
            httpUrlConnection.setDoOutput(true);
            httpUrlConnection.setDoInput(true);
            httpUrlConnection.setUseCaches(false);
            httpUrlConnection.setRequestProperty("Content-type", "image/png");
            httpUrlConnection.setRequestProperty("x-oss-callback", callback);
            httpUrlConnection.connect();
            outputStream = httpUrlConnection.getOutputStream();
    //读取文件写入
            outputStream.write(MyFileUtils.readFileToByteArray(file));
            if (httpUrlConnection.getResponseCode() == 200) {
                mListener.onSuccess("0");
                Logger.d("上传图片response 成功", httpUrlConnection.getResponseMessage() + ":" + httpUrlConnection.getResponseCode());

            }else {
                Logger.d("上传图片response", httpUrlConnection.getResponseMessage() + ":" + httpUrlConnection.getResponseCode());
                mListener.onFailure("");
            }
        }catch (Exception e)
        {
            e.printStackTrace();
            mListener.onFailure("");
        }finally {
            if(outputStream != null){
                try{
                    outputStream.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 用户基本信息-创作者，没有性别、生日
     */
    public void getMyDetail() {
        Observable<BaseResponse<PersonalInfoBean>> userInfo = getRetrofit().getMyDetail();
        request(userInfo, new BaseObserver<PersonalInfoBean>() {

            @Override
            protected void dealSpecialCode(int code, String message) {

            }

            @Override
            public void onSuccess(PersonalInfoBean myDetailBean) {
                if (myDetailBean == null) {
                    return;
                }
                //保存开关
                BaseConstants.speakControl = myDetailBean.getSpeakControl();
                BaseConstants.cnCommentAllowed = myDetailBean.getCnCommentAllowed();
                BaseConstants.cnContentPublish = myDetailBean.getCnContentPublish();
                SpUtils.saveUserName(myDetailBean.getRmhName());
                SpUtils.saveHeadPhotoUrl(myDetailBean.getRmhHeadUrl());

            }

            @Override
            public void _onError(String e) {

            }
        });
    }

    /**
     * 用户基本信息-创作者
     */
    public void getMyDetail(BaseObserver<PersonalInfoBean> observer){
        Observable<BaseResponse<PersonalInfoBean>> userInfo = getRetrofit().getMyDetail();
        request(userInfo, observer);
    }


    /**
     * 获取 CompInfo接口数据
     */
    public void getCompInfoData(CompParameterBean bean, BaseObserver<GroupBean> baseObserver) {
        //不使用缓存
        Map<String, Object> map = new HashMap<>();
        // 必须参数
        map.put("groupId", bean.groupId);

        map.put("pageNum", bean.pageNum);

        map.put("pageSize", bean.pageSize);

        map.put("pageId", bean.pageId);

        map.put("loadStrategy", bean.loadStrategy);

        map.put("refreshTime", bean.refreshTime);

        // 非必须参数
        if (!TextUtils.isEmpty(bean.channelId)) {
            map.put("channelId", bean.channelId);
        }

        if (!TextUtils.isEmpty(bean.channelStrategy)) {
            map.put("channelStrategy", bean.channelStrategy);
        }
        if (!TextUtils.isEmpty(bean.topicId)) {
            map.put("topicId", bean.topicId);
            map.put("topicType", bean.topicType);
        }
        Observable<BaseResponse<GroupBean>> groupDataObservable = getRetrofit().getGroupData(map);
        request(groupDataObservable, baseObserver);
    }


    /**
     * 批量查询内容点赞、评论数 音频专题
     * 非批量、非图文详情且readFlag=0调用访问，使用V2
     */
    public void sendBatchDyNumRequest(TopicInfoBean topicInfoBean, String isDetail, BaseObserver<InteractResponseDataBean> observer) {

        Map<String, Object> map = new HashMap<>();
        map.put(ParameterConstant.CONTENTID, topicInfoBean.getTopicId());
        map.put(ParameterConstant.CONTENT_TYPE, topicInfoBean.getTopicType());
        if (StringUtils.isNotBlank(topicInfoBean.getRelId())  && !"0".equals(topicInfoBean.getRelId()) ){
            map.put(ParameterConstant.CONTENT_RELLD, topicInfoBean.getRelId());
        }
        map.put("detail", isDetail);
        map.put("rmhPlatform", topicInfoBean.getRmhPlatform());
        Observable<BaseResponse<InteractResponseDataBean>> observable = getRetrofit().getInteractDataV2(map);
        request(observable, observer);
    }

    public  void getCommentList(String contentId, String contentType, int pageNum, int pageSize, BaseObserver<CommentListBean> observer) {
        Map<String, Object> map = new HashMap<>();
        //内容id 内容类型
        map.put(ParameterConstant.CONTENTID, contentId);
        map.put(ParameterConstant.CONTENT_TYPE, contentType);
        map.put(ParameterConstant.PAGENUM, pageNum);
        map.put(ParameterConstant.PAGESIZE, pageSize);
        //用户信息  如果userType为2、3、4时，creatorId必填
        map.put(ParameterConstant.USER_ID, SpUtils.getUserId());
        map.put(ParameterConstant.USER_TYPE, SpUtils.getUserType());
        map.put(ParameterConstant.CREATORID, SpUtils.getCreatorId());
        //时间
        map.put(ParameterConstant.TIME, TimeUtil.getDateToString(System.currentTimeMillis()));
        Observable<BaseResponse<CommentListBean>> observable = getRetrofit().getCommentList(map);
        request(observable, observer);
    }


    /**
     * 批量查询内容点赞、评论数 动态详情，单个使用V2接口
     */
    public void sendBatchDyNumRequest(NewsDetailBean newsDetailBean, BaseObserver<InteractResponseDataBean> observer) {
        if(newsDetailBean == null){
            return;
        }
        Map<String, Object> map = new HashMap<>();
        map.put(ParameterConstant.CONTENTID, newsDetailBean.getNewsId());
        map.put(ParameterConstant.CONTENT_TYPE, newsDetailBean.getNewsType());
        if (newsDetailBean.getReLInfo() != null){
            String relId = newsDetailBean.getReLInfo().getRelId();
            if (StringUtils.isNotBlank(relId)  && !"0".equals(relId) ){
                map.put(ParameterConstant.CONTENT_RELLD, relId);
            }
        }
        map.put("detail", newsDetailBean.getIsDetail());
        map.put("rmhPlatform", newsDetailBean.rmhPlatform);
        Observable<BaseResponse<InteractResponseDataBean>> observable = getRetrofit().getInteractDataV2(map);
        request(observable, observer);
    }

    /**
     * 批量查询我的点赞状态
     */
    public void getCommentStatusList(BaseObserver<List<CommentStatusBean>> observer, List<Integer> commentIdList) {
        if(!PDUtils.isLogin()){
            return;
        }
        if(commentIdList == null || commentIdList.size() < 1){
            return;
        }
        Map<String, Object> map = new HashMap<>();
        map.put("commentIdList", commentIdList);
        Observable<BaseResponse<List<CommentStatusBean>>> observable = getRetrofit().batchCommentStatus(getBody(map));
        request(observable, observer);
    }

    /**
     * 查询直播收藏状态   还可以 用于查动态详情的  点赞是公共的
     */
    public void sendLiveCollectiontStatusRequest(List<DisplayWorkInfoBean> list, BaseObserver<List<DisplayWorkInfoBean>> observer) {
        if (ArrayUtils.isEmpty(list)) {
            return;
        }
        //登录才能查询
        if (!PDUtils.isLogin()){
            return;
        }

        Map<String, Object> map = new HashMap<>();
        List<Map<String, Object>> listMap = new ArrayList<>();
        for (DisplayWorkInfoBean bean : list) {
            if (bean == null) {
                continue;
            }
            Map<String, Object> mapT = new HashMap<>();
            String contentId = bean.getContentId();
            // 内容 id 为空，不塞到数组里查询点赞收藏状态
            if (StringUtils.isBlank(contentId)) {
                continue;
            }
            mapT.put(ParameterConstant.CONTENTID, contentId);
            String contentType = bean.getContentSource();
            // 内容类型为空，不塞到数组里查询点赞收藏状态
            if (StringUtils.isBlank(contentType)) {
                continue;
            }
            mapT.put(ParameterConstant.CONTENT_TYPE, contentType);
            if (!TextUtils.isEmpty(bean.getContentRelId()) && !"0".equals(bean.getContentRelId())) {
                mapT.put(ParameterConstant.CONTENT_RELLD, bean.getContentRelId());
            }
            if (!TextUtils.isEmpty(bean.getRelType()) && !"0".equals(bean.getRelType())) {
                mapT.put(ParameterConstant.CONTENT_REL_TYPE, bean.getRelType());
            }
            listMap.add(mapT);
        }
        // 要查询的点赞和收藏的内容集合为空，则不进行查询点赞收藏状态
        if (CommonUtil.isEmpty(listMap)) {
            return;
        }
        map.put("contentList", listMap);
        Observable<BaseResponse<List<DisplayWorkInfoBean>>> codeData = getRetrofit().batchLikeAndCollectStatus(getBody(map));
        request(codeData, observer);
    }

    /**
     * 评论点赞
     */
    public void contentExecuteLike(String commentId, String targetId, String targetType, int status,
                                   LikeCallback likeCallback) {
        Map<String, Object> map = new HashMap<>();
        map.put("commentId", commentId);
        map.put("targetId", targetId);
        map.put("targetType", targetType);
        map.put("status", status);
        map.put("userName", SpUtils.getUserName());
        map.put("userHeaderUrl", SpUtils.getHeadPhotoUrl());
        Observable<BaseResponse<Object>> requestData = getRetrofit().commentLike(getBody(map));
        request(requestData, new BaseObserver<String>() {
            @Override
            protected void dealSpecialCode(int code, String message) {
                if (likeCallback != null) {
                    likeCallback.onFailed(message);
                }
            }

            @Override
            public void onSuccess(String s) {

                EventMessage mEventMessage = new EventMessage(EventConstants.FRESH_ZAN_CREATOR_EVENT);
                mEventMessage.putExtra(IntentConstants.CONTENT_ID, commentId);
                mEventMessage.putExtra(IntentConstants.TARGET_ID, targetId);
                mEventMessage.putExtra(IntentConstants.IS_ZAN, 0 == status);
                //全局刷新创作者关注状态
                LiveDataBus.getInstance().with(EventConstants.FRESH_ZAN_CREATOR_EVENT).postValue(mEventMessage);

                String newLikeStatus = "0";
                if (0 == status) {
                    newLikeStatus = "1";
                } else {
                    newLikeStatus = "0";
                }
                if (likeCallback != null) {
                    likeCallback.onSuccess(s, status+"", newLikeStatus);
                }


            }

            @Override
            public void _onError(String e) {
                if (likeCallback != null) {
                    likeCallback.onFailed(e);
                }
            }
        });
        if(1 == status){
            //执行任务：点赞
            TaskManager.getInstance().executePointLevelOperate(TaskOperateTypeConstants.LIKE);
        }
    }

    /**
     * 活动:用户剩余投稿次数查询
     */
    public void getActivitySizeByCreatorId(String collectId, BaseObserver<Integer> baseObserver) {
        Map<String, String> params = new HashMap<>();
        params.put("collectId", collectId);
        String creatorId = SpUtils.getCreatorId();
        if(StringUtils.isEmpty(creatorId) || StringUtils.isEqual("1",BaseConstants.cnContentPublish)){
            //1：普通用户，2：创作者
            params.put("identity", "1");
            params.put("targetId", SpUtils.getUserId());
        }else {
            params.put("identity", "2");
            params.put("targetId", creatorId);
        }
        Observable<BaseResponse<Integer>> requestData = getRetrofit().getActivitySizeByCreatorId(params);
        request(requestData, baseObserver);
    }

    /**
     * 音频播放量
     *
     * @param topicId
     */
    public void getAudioPlaybackVolume(String topicId, BaseObserver<AudioPlaybackQuantityBean> observer) {
        Observable<BaseResponse<AudioPlaybackQuantityBean>> codeData = getRetrofit().getAudioPlaybackVolume(topicId);
        request(codeData, observer);
    }

    /**
     * 音频播放量
     *
     * @param topicIdList
     */
    public void getAudioPlaybackVolumes(String topicIdList, BaseObserver<List<AudioPlaybackQuantityBean>> observer) {
        Observable<BaseResponse<List<AudioPlaybackQuantityBean>>> codeData = getRetrofit().getAudioPlaybackVolumes(topicIdList);
        request(codeData, observer);
    }
    /**
     * 个人主页基本信息查询(包含普通用户主页和号主主页信息)
     */
    public void getPersonalCenterInfo(String userId, String userType, String creatorId, BaseObserver<PersonalInfoBean> observer) {
        boolean isSelf = userId.equals(SpUtils.getUserId());
        Observable<BaseResponse<PersonalInfoBean>> requestData;
        //判断查询个人中心自己
        if (isSelf) {
            requestData = getRetrofit().getMyDetail();
        } else {
            if (!StringUtils.isBlank(creatorId)) {
                userId = "";
                userType = "";
            } else {
                creatorId = "";
            }
            HashMap<String, Object> queryMap = new HashMap<>();
            queryMap.put(ParameterConstant.USER_ID, userId);
            queryMap.put(ParameterConstant.USER_TYPE, userType);
            queryMap.put(ParameterConstant.CREATORID, creatorId);
            requestData = getRetrofit().getPersonalCenterInfo(getBody(queryMap));
        }

        request(requestData, observer);
    }

    /**
     * 查询用户是否注册留言系统
     * @param observer
     */
    public void checkAskRegister(BaseObserver<CheckRegisterBean> observer) {
        Observable<BaseResponse<CheckRegisterBean>> checkRegisterObservable = getRetrofit().checkAskRegister();
        request(checkRegisterObservable,observer);
    }

    /**
     * 【问政】留言用户实名注册接口
     * @param observer
     */
    public void certAskRegister(BaseObserver<CertRegisterBean> observer) {
        Observable<BaseResponse<CertRegisterBean>> certRegisterObservable = getRetrofit().
                certAskRegister(getBody(new HashMap<>()));
        request(certRegisterObservable,observer);
    }

    /**
     * 获取问政-我的留言列表接口数据
     * @param observer
     */
    public void getLeaveWordList(BaseObserver<AskBean> observer) {
        Map<String, Object> map = new HashMap<>();
        map.put("pageNum", 1);
        map.put("pageSize", 20);
        Observable<BaseResponse<AskBean>> leaveWordListObservable = getRetrofit().
                getLeaveWordList(map);
        request(leaveWordListObservable,observer);
    }

    /**
     * 移动生产-内容详情接口
     * @param observer
     */
    public void getPublishOperateData(List<String> ids,BaseObserver<List<EditDataBean>> observer) {
        Observable<BaseResponse<List<EditDataBean>>> publishOperateDataObservable =
                getRetrofit().getPublishOperateData(getBody(ids));
        request(publishOperateDataObservable, observer);
    }

    // 多路直播 专用查询多个流
    public void sendQueryVLivePullStreamList(String liveId, BaseObserver<List<GetPullAddressBean>> baseObserver) {
        Observable<BaseResponse<List<GetPullAddressBean>>> codeData  = getRetrofit().queryVLivePullStreamList(liveId);
        request(codeData, baseObserver);

    }

    /**
     * 人民号类型，单个直播
     * */
    public void sendQueryVLivePullStream(String vliveId,BaseObserver<GetPullAddressBean> baseObserver) {
        Observable<BaseResponse<GetPullAddressBean>>  codeData = getRetrofit().queryVLivePullStream(vliveId);
        request(codeData, baseObserver);
    }

    /**
     * 查询用户是否被禁言（830）
     */
    public void userisMte(String mliveId, BaseObserver<Object> baseObserver) {
        if (!PDUtils.isLogin()) {
            //没登录不需要查询用户是否被禁言
           return;
        }
        Observable<BaseResponse<Object>> observable = getRetrofit().userisMte(mliveId);
        request(observable, baseObserver);
    }

    /**
     * 查询直播点赞状态
     */
    public void liveIsLike(String mliveId, BaseObserver<Object> baseObserver) {
        if(TextUtils.isEmpty(mliveId)){
            return;
        }
        Map<String, Object> params = new HashMap<>(16);
        params.put("liveId", mliveId);
        params.put("deviceId", DeviceUtil.getDeviceId());
        if (PDUtils.isLogin()) {
            params.put("userId", SpUtils.getUserId());
        }else{
            //没登录不需要查询点赞状态
            return;
        }
        Observable<BaseResponse<Object>> observable = getRetrofit().liveIsLike(params);
        request(observable, baseObserver);
    }

    /**
     * 问政-我的留言小红点
     */
    public void getMyAskMarkData(BaseObserver<MyAskMarkBean> baseObserver){
        Observable<BaseResponse<MyAskMarkBean>> observable = getRetrofit().myAskMark();
        request(observable, baseObserver);
    }

    /**
     *  获取推荐列表
     * @param contentId     当前数据id
     * @param relId         当前内容关系id
     * @param channelId     频道id
     * @param recType      推荐类型
     */
    public void getRecList(String contentId,String relId,String channelId,int recType, BaseObserver<List<ContentBean>> baseObserver){
        Map<String, Object> params = new HashMap<>();
        params.put(ParameterConstant.IMEI, DeviceUtil.getDeviceId());
        String userId = SpUtils.getUserId();
        if (!TextUtils.isEmpty(userId)) {
            params.put(ParameterConstant.USER_ID, userId);
        }
        params.put("contentId", contentId);
        params.put("relId", relId);
        //当前数据类型 1:视频,2:直播,5:专题,8:图文,9:组图,10:H5新闻
        params.put("contentType", ContentTypeConstant.URL_TYPE_EIGHT);
        //推荐类型：1.详情推荐；2.搜索推荐
        params.put("recType", recType);
        //频道id
        params.put("channelId", channelId);
        Observable<BaseResponse<List<ContentBean>>> observable = getRetrofit().getRecList(getBody(params));
        request(observable, baseObserver);
    }

    /**
     * 查询投票,登录/未登录分开处理
     */
    public void getUserVotePoll(String liveId, BaseObserver<LiveInteractiveVotingBean> baseObserver) {
        if(PDUtils.isLogin()){
            Observable<BaseResponse<LiveInteractiveVotingBean>> observable = getRetrofit().userLoginVotePoll(liveId);
            request(observable, baseObserver);
        }else{
            Observable<BaseResponse<LiveInteractiveVotingBean>> observable = getRetrofit().userVotePoll(liveId);
            request(observable, baseObserver);
        }
    }

    /**
     * 用户投票接口
     */
    public void setUserVote(String itemId, String voteId, String liveId) {
        HashMap<String, Object> queryMap = new HashMap<>();
        queryMap.put("itemId", itemId);
        queryMap.put("voteId", voteId);
        queryMap.put("liveId", liveId);

        Observable<BaseResponse<Object>> observable = getRetrofit().userVote(getBody(queryMap));
        request(observable, new BaseObserver<Object>() {
            @Override
            protected void dealSpecialCode(int code, String message) {
                ToastNightUtil.showShort(message);
            }

            @Override
            protected void onSuccess(Object bean) {
                ToastNightUtil.showShort("投票成功");
            }

            @Override
            protected void _onError(String e) {
                ToastNightUtil.showShort(e);
            }
        });
    }

    /**
     * 查询互动组件(830)
     */
    public void userQueryInteractiveComponents(String userId, BaseObserver<List<InteractiveComponentBean>> baseObserver) {
        Observable<BaseResponse<List<InteractiveComponentBean>>> observable = getRetrofit().userQueryInteractiveComponents(userId);
        request(observable, baseObserver);
    }

    /**
     * 查询当前用户收藏标签接口
     *      * tagName	标签名称 可不传，不传查询所有
     *      * pageNum	1 若前端未传，则默认查询第一页
     *      * pageSize	 10 若前端未传，则默认每页10条数据
     */
    public void getUserCollectTags(String tagName,int pageNum,int pageSize, BaseObserver<CollectTagsBean> baseObserver) {
        Map<String, Object> map = new HashMap<>();
        map.put("tagName",tagName);
        map.put("pageNum",pageNum);
        map.put("pageSize",pageSize);
        map.put("operateTag",BaseConstants.collectOperateTag);
        Observable<BaseResponse<CollectTagsBean>> observable = getRetrofit().getUserCollectTags(map);
        request(observable, baseObserver);
    }

    /**
     * 增加或移除收藏标签接口
     * tagId和tagName不能都传，也不能都不传
     * tagId	Long非必须标签id（传此值代表删除标签）
     * tagName	string非必须标签名称（传此值代表新增标签）
     * operateType	integer必须操作类型：1-添加，2-删除
     */
    public void operateUserCollectTags(long tagId,String tagName,int operateType, BaseObserver<Long> baseObserver) {
        Map<String, Object> map = new HashMap<>();
        if(tagId > 0){
            map.put("tagId",tagId);
        }
        if(!TextUtils.isEmpty(tagName)){
            map.put("tagName",tagName);
        }
        map.put("operateType",operateType);
        Observable<BaseResponse<Long>> observable = getRetrofit().operateUserCollectTags(getBody(map));
        request(observable, baseObserver);
    }

    /**
     * 添加或移除收藏内容关联标签接口
     * operateType	integer必须操作类型：1-添加，2-删除
     * contentList	object []必须
     *  item 类型: object
     *      contentId	string必须内容id
     *      contentType	integer必须内容类别，1:点播,2:直播,3:活动,4:广告,5:专题,6:链接,7:榜单,8:图文,9:组图,10:H5新闻,11:频道,12:组件,13:音频,14:动态图文,15:动态视频,【不支持问政】
     *      contentRelId	string必须【人民号内容为空】默认0
     *      tagId	Long必须标签id
     */
    public void operateUserCollectContentTags(int operateType, List<CollectContentBean> contentList, BaseObserver<Object> baseObserver) {
        Map<String, Object> map = new HashMap<>();
        map.put("operateType",operateType);
        map.put("contentList",contentList);
        Observable<BaseResponse<Object>> observable = getRetrofit().operateUserCollectContentTags(getBody(map));
        request(observable, baseObserver);
    }

    /**
     * 退出直播间调用
     * {@link #getOnlineVisits(String, String, String)}
     */
    public void updateOfflineVisits(String liveId, String number, String roomId) {
        HashMap<String, Object> queryMap = new HashMap<>();
        queryMap.put("liveId", liveId);
        queryMap.put("number", number);
        queryMap.put("roomId", roomId);
        if (PDUtils.isLogin()) {
            String senderUserName = SpUtils.getUserName();
            queryMap.put("senderUserName", senderUserName);
            queryMap.put("userId", SpUtils.getUserId());
        }
        Observable<BaseResponse<Object>> codeData = getRetrofit().updateOfflineVisits(getBody(queryMap));
        request(codeData, new BaseObserver<Object>() {

            @Override
            protected void dealSpecialCode(int code, String message) {

            }

            @Override
            protected void onSuccess(Object o) {

            }
        });
    }

    /**
     * 识别剪贴板口令
     */
//    public void identifyClipboardCode() {
//        String clipboardCode = ClipboardUtils.getInstance().getClipboardCode();
//        Logger.t(TAG).i("initCommand clipboardCode:" + clipboardCode);
//
//        if (TextUtils.isEmpty(clipboardCode)) {
//            return;
//        }
//
//        int codeType = ClipboardUtils.getCodeType(clipboardCode);
//
//        if(codeType == 1){
//            //中文端口令
//            actzhCodeIdentify(clipboardCode);
//        }else if(codeType == 2){
//            //邀请好友
//            clipboardCode = ClipboardUtils.getCommandContent(clipboardCode);
//            inviterIdentifyCode(clipboardCode);
//        }
//    }

    /**
     * 中文端识别口令
     * @param clipboardCode
     */
    public void actzhCodeIdentify(String clipboardCode){
        if(StringUtils.isEmpty(clipboardCode)){
            return;
        }
        Activity activity = MyActivityManager.INSTANCE.getCurrentActivity();
        HashMap<String, Object> queryMap = new HashMap<>();
        queryMap.put("shareOid", clipboardCode);
        Observable<BaseResponse<CodeIdentifyBean>> codeData = getRetrofit().codeIdentify(getBody(queryMap));
        request(codeData, new BaseObserver<CodeIdentifyBean>() {

            @Override
            protected void dealSpecialCode(int code, String message) {
                Logger.t(TAG).i("dealSpecialCode code:"+code+",message:"+message);
            }

            @Override
            protected void onSuccess(CodeIdentifyBean codeIdentifyBean) {

                Logger.t(TAG).i("onSuccess codeIdentify:"+ JsonUtils.convertObjectToJson(codeIdentifyBean));

                if(codeIdentifyBean == null || StringUtils.isEmpty(codeIdentifyBean.getShareOid())){
                    return;
                }

                // 清空剪切板内容
//                ClipboardUtils.getInstance().clearClipboard();

                //抽奖弹框测试
                if(prizeDrawDialog != null && prizeDrawDialog.getDialog().isShowing()){
                    prizeDrawDialog.getDialog().dismiss();
                }
                // 展示抽奖弹窗
                prizeDrawDialog = new PrizeDrawDialog(activity).builder()
                        .setData(codeIdentifyBean)
                        .setClickListener(new PrizeDrawDialog.DialogClickListener() {
                            @Override
                            public void onJump() {
                                // 未登录
                                if(!PDUtils.isLogin()){
                                    // 是否需要登录
                                    String isLogin = codeIdentifyBean.getIsLogin();
                                    // 0：不需要登录；1：需要登录; 默认1
                                    if(StringUtils.isEqual("1",isLogin)){
                                        // 保存内链数据
                                        String innerUrl = codeIdentifyBean.getInnerUrl();
                                        SpUtils.savePrizeDrawInnerUrlData(innerUrl);
                                        // 跳转到登录页面
                                        ProcessUtils.toOneKeyLoginActivity();
                                        return;
                                    }
                                }
                                // 关闭抽奖弹框
                                Dialog dialog = prizeDrawDialog.getDialog();
                                if (dialog != null) {
                                    dialog.dismiss();
                                }
                                // 跳转到抽奖详情页
                                String innerUrl = codeIdentifyBean.getInnerUrl();
                                if(!StringUtils.isEmpty(innerUrl)){
//                                    //埋点：助力好友按钮点击
//                                    GeneralTrack.getInstance().friendsAssistanceClickTrack(codeIdentifyBean);
                                    ProcessUtils.goToH5Page(new ContentBean(innerUrl));
                                }
                            }

                            @Override
                            public void onClose() { // 弹窗关闭回调
                                // 清空内链地址
                                SpUtils.savePrizeDrawInnerUrlData("");
                            }
                        })
                        .show();
            }

            @Override
            protected void _onError(String message) {
                super._onError(message);
                Logger.t(TAG).i("_onError message:"+message);
            }
        });
    }

    /**
     * 中文端-口令使用
     * @param shareOid
     */
    private void codeMakeUse(String shareOid){
        if(StringUtils.isEmpty(shareOid)){
            return;
        }
        HashMap<String, Object> queryMap = new HashMap<>();
        queryMap.put("shareOid", shareOid);
        Observable<BaseResponse<Object>> codeData = getRetrofit().codeMakeUse(getBody(queryMap));
        request(codeData, new BaseObserver<Object>() {

            @Override
            protected void dealSpecialCode(int code, String message) {
                Logger.t(TAG).i("dealSpecialCode code:"+code+",message:"+message);
            }

            @Override
            protected void onSuccess(Object obj) {
                Logger.t(TAG).i("onSuccess codeMakeUse:");
            }

            @Override
            protected void _onError(String message) {
                super._onError(message);
                Logger.t(TAG).i("_onError message:"+message);
            }
        });
    }

    /**
     * 邀请好友识别口令
     * @param clipboardCode
     */
    private void inviterIdentifyCode(String clipboardCode){
        if(StringUtils.isEmpty(clipboardCode)){
            return;
        }
        Activity activity = MyActivityManager.INSTANCE.getCurrentActivity();
        HashMap<String, Object> queryMap = new HashMap<>();
        queryMap.put("inviterCode", clipboardCode);
        Observable<BaseResponse<InviterResp>> codeData = getRetrofit().inviter(getBody(queryMap));
        request(codeData, new BaseObserver<InviterResp>() {

            @Override
            protected void dealSpecialCode(int code, String message) {
                Logger.t(TAG).i("dealSpecialCode code:"+code+",message:"+message);
            }

            @Override
            protected void onSuccess(InviterResp inviterResp) {
                Logger.t(TAG).i("onSuccess inviterResp:"+ JsonUtils.convertObjectToJson(inviterResp));
                if (inviterResp == null) {
                    return;
                }
                // 登录状态验证此字段
                if (!inviterResp.isInviterTure()) {
                    return;
                }
                // 提示文案
                String message;
                if (PDUtils.isLogin()){
                    message = inviterResp.getMessage();
                }else {
                    SpUtils.saveInviterCode(clipboardCode);
                    message = inviterResp.getMessage();
                }
                if (TextUtils.isEmpty(message)) {
                    return;
                }
                // 登录状态下清空剪切板内容
                if (PDUtils.isLogin()){
//                    // 清空剪切板内容
//                    ClipboardUtils.getInstance().clearClipboard();
                }
                // 展示弹窗
                Logger.t(TAG).i("commandDialog show");
                CommandDialog commandDialog = new CommandDialog(activity, message);
                commandDialog.show();
            }

            @Override
            protected void _onError(String message) {
                super._onError(message);
                Logger.t(TAG).i("_onError message:"+message);
            }
        });
    }

    /**
     * 批查用户登记信息
     */
    public String batchUserLevelInfor(List<CommentItem> data, BaseObserver<List<LevelInfoBean>> observer) {
        List<String> list = new ArrayList<>();
        for(CommentItem bean : data){
            String fromUserId = bean.getFromUserId();
            if(!TextUtils.isEmpty(fromUserId)){
                if(list.contains(fromUserId)){
                    continue;
                }
                list.add(bean.getFromUserId());
            }
        }
        //接口请求
        Observable<BaseResponse<List<LevelInfoBean>>> requestData = getRetrofit().batchUser(getBody(list));
        request(requestData,observer);
        return list.toString();
    }

    /**
     * 请求音频频道数据
     * */
    public void loadAudioChannelData(String channelId, String pageId, AudioChannelBack back){
        Map<String, Object> map = new HashMap<>();
        map.put("pageId", pageId);
        RetrofitClient.execute(RetrofitClient.getInstance().create(RequestApi.class).getPageData(map), new BaseObserver<PageBean>() {

            @Override
            protected void dealSpecialCode(int code, String message) {
                if(back != null){
                    back.loadFail();
                }
            }

            @Override
            protected void onSuccess(PageBean pageBean) {
            }

            @Override
            protected void onSuccess(PageBean pageBean, MetaBean metaBean, String msg, int code) {
                if(back == null){
                    CacheData localCacheData = CacheData.getLocalCacheData(CacheData.audioChannelCacheKey);
                    // 新旧数据md5值对比
                    if(localCacheData == null || localCacheData.md5 == null || !localCacheData.md5.equals(metaBean.getMd5())){
                        // 更新缓存数据
                        CacheData.saveDataToPreference(CacheData.audioChannelCacheKey, pageBean, metaBean.getMd5());
                    }
                }else{
                    back.loadAudioChannelSuccess(pageBean, metaBean, msg, code);
                }
                if (pageBean == null) {
                    return;
                }
                if (pageBean.getGroups() != null && pageBean.getGroups().size() > 0) {
                    for (int i = 0; i < pageBean.getGroups().size(); i++) {
                        GroupBean groupBean = pageBean.getGroups().get(i);
                        loadSubData(pageBean,groupBean, channelId, pageId, i,back);
                        if (i == 2) {
                            //只请求2个模块数据
                            break;
                        }
                    }
                }
            }

            @Override
            protected void _onError(String e) {
                if(back != null){
                    back.noNetwork();
                }
            }
        });
    }
    /**
     * 请求每个模块的具体数据
     * 今日推荐 or 精选栏目
     * 这个接口服务端让我们传refreshTime 到秒  后面给他000
     */
    private void loadSubData(PageBean pageBean,GroupBean mGroupBean, String channelId, String pageId, int type, AudioChannelBack back) {
        Map<String, Object> groupMap = new HashMap<>();
        groupMap.put("channelId", channelId);
        groupMap.put("channelStrategy", "2");
        groupMap.put("groupId", mGroupBean.getId());
        groupMap.put("loadStrategy", "first_load");
        groupMap.put("pageId", pageId);
        groupMap.put("pageNum", 1);
        groupMap.put("pageSize", 50);
        groupMap.put("recommend", 0);
        if(pageBean != null){
            groupMap.put("refreshTime", pageBean.getRefreshTime());
        }else {
            groupMap.put("refreshTime", TimeUtil.getSecondTimes(HostUtil.serverTime));
        }
        groupMap.put("topicId", "");
        RetrofitClient.execute(RetrofitClient.getInstance().create(RequestApi.class).getGroupData(groupMap), new BaseObserver<GroupBean>() {

            @Override
            protected void dealSpecialCode(int code, String message) {

            }

            @Override
            protected void onSuccess(GroupBean groupBean) {

            }

            @Override
            protected void onSuccess(GroupBean groupBean, MetaBean metaBean, String msg, int code) {
                if(back == null){
                    CacheData localCacheData = CacheData.getLocalCacheData(CacheData.audioChannelCacheKey+type);
                    // 新旧数据md5值对比
                    if(localCacheData == null || localCacheData.md5 == null || !localCacheData.md5.equals(metaBean.getMd5())){
                        // 更新缓存数据
                        CacheData.saveDataToPreference(CacheData.audioChannelCacheKey+type, groupBean, metaBean.getMd5());
                    }
                }else{
                    //今日推荐
                    if (type == 0) {
                        back.loadTodaysRecommendationSuccess( groupBean, metaBean, msg, code);
                    } else if (type == 1) {
                        back.loadSelectedColumnsSuccess(groupBean, metaBean, msg, code);
                    }
                }
            }


            @Override
            protected void _onError(String e) {

            }
        });
    }

    /**
     * 查询创作者当日继续发文数量
     */
    public void getRemainingDispatchNum(BaseObserver<Integer> observer){
        String creatorId = SpUtils.getCreatorId();
        if (StringUtils.isBlank(creatorId)){
            return;
        }
        Observable<BaseResponse<Integer>> register = getRetrofit().getRemainingDispatchNum(creatorId);
        request(register, observer);
    }

    /**
     * 构建评论提交请求参数
     */
    public Observable<BaseResponse<CommentItem>> createSubmitRequestData(PublishCommentParameterBean parameterBean) {
        Map<String, Object> map = new HashMap<>();
        if(parameterBean == null){
            return getRetrofit().submitPushComment(getBody(map));
        }
        //评论内容、评论类型
        map.put(ParameterConstant.COMMENT_CONTENT, parameterBean.getCommentContent());
        map.put(ParameterConstant.COMMENT_TYPE, parameterBean.getCommentType());
        //图片
        map.put(ParameterConstant.COMMENT_PICS, parameterBean.getCommentPics());
        //被评论id、内容类型
        map.put(ParameterConstant.TARGET_ID, parameterBean.getTargetId());
        map.put(ParameterConstant.TARGET_TYPE, parameterBean.getTargetType());
        //被评论的内容关系id、被评论的内容关系类型，1.频道关系；2.专题关系
        String targetRelId = parameterBean.getTargetRelId();
        if (!TextUtils.isEmpty(targetRelId)) {
            map.put(ParameterConstant.TARGET_REL_ID, targetRelId);
        }
        String targetRelType = parameterBean.getTargetRelType();
        if (!TextUtils.isEmpty(targetRelType)) {
            map.put(ParameterConstant.TARGET_REL_TYPE, targetRelType);
        }
        //父类id、根部id
        map.put(ParameterConstant.PARENT_ID, parameterBean.getParentId());
        map.put(ParameterConstant.ROOT_COMMENT_ID, parameterBean.getRootCommentId());
        // 【迭代二新增】
        String targetTitle = parameterBean.getTargetTitle();
        if (!StringUtils.isBlank(targetTitle)) {
            map.put(ParameterConstant.REQUEST_TARGET_TITLE, targetTitle);
        }else {
            map.put(ParameterConstant.REQUEST_TARGET_TITLE, "null");
        }
        String keyArticle = parameterBean.getKeyArticle();
        if (!StringUtils.isBlank(keyArticle)) {
            map.put(ParameterConstant.REQUEST_KEY_ARTICLE, keyArticle);
        }
        //是否领导人文章 0 否，1 是，不存在就传0
        map.put(ParameterConstant.REQUEST_KEY_LEADER_ARTICLE, parameterBean.getLeaderArticle());
        String targetRelObjectId = parameterBean.getTargetRelObjectId();
        if (!StringUtils.isBlank(targetRelObjectId)) {
            map.put(ParameterConstant.REQUEST_TARGET_REL_OBJECT_ID, targetRelObjectId);
        }

        if(!PDUtils.isLogin()){
            //未登录，游客评论
            String userName = SpUtils.getTouristNickname();
            String deviceId = DeviceUtil.getDeviceId();
            map.put(ParameterConstant.USER_NAME, userName);
            map.put(ParameterConstant.DEVICEID, deviceId);
            return getRetrofit().submitVisitorPushComment(getBody(map));
        }

        //接口请求
        return getRetrofit().submitPushComment(getBody(map));
    }

    /**
     * 构建删除请求参数
     *
     * @param commentId
     * @param targetId
     * @return
     */
    public Observable<BaseResponse<String>> createDelRequestData(String commentId, String targetId, String uuid) {
        Map<String, Object> map = new HashMap<>();
        map.put("commentId", TextUtils.isEmpty(commentId) ? "0" : commentId);
        map.put("targetId", targetId);
        map.put("uuid", uuid);
        if(PDUtils.isLogin()){
            return getRetrofit().delComment(getBody(map));
        }else {
            //游客删除评论
            String deviceId = DeviceUtil.getDeviceId();
            map.put(ParameterConstant.DEVICEID, deviceId);
            return getRetrofit().delVisitorComment(getBody(map));
        }
    }


    /**
     * 提交评论
     */
    public void submitPushComment(PublishCommentParameterBean parameterBean) {
        if(parameterBean == null){
            return;
        }
        String rootCommentId = parameterBean.getRootCommentId();
        Observable<BaseResponse<CommentItem>> submitRequestData = createSubmitRequestData(parameterBean);
        request(submitRequestData, new BaseObserver<CommentItem>() {
            @Override
            protected void dealSpecialCode(int code, String message) {
                ToastNightUtil.showShort(message);
            }

            @Override
            public void onSuccess(CommentItem pushCommentBean) {

            }

            @Override
            protected void onSuccess(CommentItem pushCommentBean, MetaBean metaBean, String msg, int code) {
                super.onSuccess(pushCommentBean, metaBean, msg, code);
                if (StringUtils.isEqual("-1", rootCommentId)) {
                    //执行任务：评论
                    TaskManager.getInstance().executePointLevelOperate(TaskOperateTypeConstants.COMMENT);
                } else {
                    //执行任务：回复
                    TaskManager.getInstance().executePointLevelOperate(TaskOperateTypeConstants.REPLY);
                }
                if(!PDUtils.isLogin()){
                    //未登录，游客评论
                    String touristFirstCommentTime = SpUtils.getTouristFirstCommentTime();
                    if(StringUtils.isEmpty(touristFirstCommentTime)){
                        //保存游客评论第一条的时间，格式：yyyy-MM-dd HH:mm:ss
                        try {
                            String currentDatetime = TimeUtil.currentDatetime();
                            SpUtils.saveTouristFirstCommentTime(currentDatetime);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }

            @Override
            public void _onError(String e) {
                ToastNightUtil.showShort(e);
            }
        });
    }

    /**
     * 删除评论
     *
     * @param commentId 要删除的评论id
     * @param targetId  删除评论所属内容id
     */
    public void delComment(String commentId, String targetId, String uuid, int freshPosition, ICommentDataNewListener mDataListener) {
        Observable<BaseResponse<String>> userInfo = CommonNetUtils.getInstance().createDelRequestData(commentId, targetId, uuid);
        request(userInfo, new BaseObserver<String>() {

            @Override
            protected void dealSpecialCode(int code, String message) {
                if (mDataListener != null) {
                    mDataListener.delCommentFail(message);
                }
            }

            @Override
            public void onSuccess(String success) {
                if (mDataListener != null) {
                    mDataListener.delCommentSuccess(freshPosition);
                }
            }

            @Override
            public void _onError(String e) {
                if (mDataListener != null) {
                    mDataListener.delCommentFail(e);
                }
            }
        });
    }


    /**
     * app启动通用配置接口
     * @param observer
     */
    public void getCommonConfig(BaseObserver<CommonConfigBean> observer) {
        Observable<BaseResponse<CommonConfigBean>> certRegisterObservable = getRetrofit().
                getCommonConfig();
        request(certRegisterObservable,observer);
    }

}