package com.wd.layoutdataimpl.model;

import android.text.TextUtils;

import com.wd.capability.layout.comp.layoutdata.AbsGroup;
import com.wd.capability.layout.comp.layoutdata.Page;
import com.wd.capability.layout.page.model.CompLogicDataBean;
import com.wd.capability.layout.page.vm.IPageDataListener;
import com.wd.capability.layout.ui.follow.listener.BatchCallback;
import com.wd.capability.layout.uitls.CompentLogicUtil;
import com.wd.capability.network.BaseObserver;
import com.wd.capability.network.bean.MetaBean;
import com.wd.capability.network.cachedata.CacheData;
import com.wd.common.api.RequestApi;
import com.wd.capability.network.response.BaseResponse;
import com.wd.foundation.wdkitcore.tools.HostUtil;
import com.wd.foundation.wdkit.constant.GlobalAppCacheData;
import com.wd.capability.network.fetcher.BaseDataFetcher;
import com.wd.foundation.bean.adv.CompAdvBean;
import com.wd.foundation.bean.adv.CompAdvMatInfoBean;
import com.wd.foundation.bean.adv.CompAdvSlotInfoBean;
import com.wd.foundation.bean.custom.comp.ChannelInfoBean;
import com.wd.foundation.bean.custom.comp.CompBean;
import com.wd.foundation.bean.custom.comp.CompDataSourceBean;
import com.wd.foundation.bean.custom.comp.GroupBean;
import com.wd.foundation.bean.custom.comp.OperateBean;
import com.wd.foundation.bean.custom.comp.PageBean;
import com.wd.foundation.bean.custom.comp.TopicInfoBean;
import com.wd.foundation.bean.custom.content.ContentBean;
import com.wd.foundation.bean.custom.content.ContentTypeConstant;
import com.wd.foundation.bean.custom.content.PeopleMasterBean;
import com.wd.foundation.bean.response.ContentPageListBean;
import com.wd.foundation.bean.response.InteractResponseDataBean;
import com.wd.foundation.wdkit.json.GsonUtils;
import com.wd.foundation.wdkit.utils.SpUtils;
import com.wd.foundation.wdkit.utils.ToastNightUtil;
import com.wd.foundation.wdkitcore.tools.StringUtils;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import io.reactivex.Observable;

/**
 * @Description: 楼层组件工程类(辅助处理楼层组件 、 稿件 、 自定义view)
 * @Author: Li Yubing
 * @Email: liyubing@wondert.com.cn
 * @CreateDate: 2023/8/10 16:49
 * @Version: 1.0
 */
public class PageCompDataFactory<T> extends BaseDataFetcher<RequestApi> {

    protected Page mPage;

    protected PageBean pageData;

    protected IPageDataListener mListener;

    // 信息流页面帮助类
    protected CompLogicDataBean compLogicDataBean;

    // 多个楼层调用
    protected PageDataFinishTask mGetDataFinishTask;

    //多个批量接口
    private PageDataFinishTask batchGetDataFinishTask;

    /**
     * 稿件的type
     */
    protected String manuscriptType = "appStyle";

    /**
     * 一行两图卡
     */
    protected String OneRowTwoImageCompStyle = "Zh_Grid_Layout-02";
    protected String OneRowTwoImageCompType = "ZH_GRID_LAYOUT";

    /**
     * 正在直播大图卡
     */
    protected String OneLivingBigImageCompStyle = "Zh_Single_Column-03";//"Zh_Single_Row-01";//
    protected String OneLivingBigImageCompType = "ZH_SINGLE_COLUMN";//"ZH_SINGLE_ROW";//

    /**
     * 兴趣询问卡
     */
    protected String InterestCompStyle = "Zh_Single_Column-09";
    protected String InterestCompType = "ZH_SINGLE_COLUMN";

    /**
     * 精选评论卡
     */
    protected String CommentCompStyle = "Zh_Single_Row-06";
    protected String CommentCompType = "ZH_SINGLE_ROW";

    /**
     * 人民号入驻卡
     */
    protected String RrhRzCompStyle = "Zh_Single_Column-05";
    protected String RrhRzpCompType = "ZH_SINGLE_COLUMN";

    /**
     * 特殊组件提供早晚报专题数据
     */
    protected String SubjectZABSpCompStyle = "Zh_Single_Column-999";
    protected String SubjectZABSpCompType = "ZH_SINGLE_COLUMN";

    /**
     * 工程自定义item
     */
    // 工程内自定义组件和稿件的
    protected String compDefType = "customStyle";
    //早晚报专题 一键播放
    protected String NewsPageOnekeyStyle = "CompNewsPlayerView01";
    //早晚报专题 特殊稿件
    protected String NewsPageItemStyle = "CompNewsImageTxt01";
    // 组件标题
    protected String CompSubjectTile02 = "CompLabel02";
    // 组件线
    protected String CompSubjectLine01 = "CompLine01";

    /*
      信息流页面稿件信息内需要 评论、点赞、关注等信息，需要调用多个批查接口查询这些信息
     */
    //收集需要批查的稿件信息体
    protected List<ContentBean> collectContentList;
    // 总的批查次数
    protected int totalBatchCount;
    // 最后一次批查内容的数量
    protected int surplus;
    //记录批查次数，每次调用批查+1
    protected int batchTime = 1;
    // 批查最大量
    protected final int maxCount = 20;

    /**
     * 记录当前页面中涉及到的人民号对象，维护不同稿件使用的人民号是一个对象
     */
    private Map<String, PeopleMasterBean> compMasterMap = new HashMap<>();

    public Page getmPage() {
        return mPage;
    }

    public PageBean getPageData() {
        return pageData;
    }


    /**
     * 组件数据解析
     *
     * @param groupBean
     * @param group
     */
    protected void groupCompDataParse(GroupBean groupBean, AbsGroup group) {

        //处理compInfo中searchValue，请求下一页compInfo的时候，要把上一页返回的searchValue作为参数传给后端
        if(groupBean != null && group != null &&
                StringUtils.isNotEmpty(groupBean.getSearchValue())){
            group.setSearchValue(groupBean.getSearchValue());
        }
        List<CompBean> compList = groupBean.getComps();
        if (compList == null) {
            return;
        }
        // 常规直接走楼层组件数据解析
        boolean goNormal = true;
        // 当前楼层是不是页面的最后一个楼层（只有一个，算最后一个楼层）
        boolean isLastLayer = group.isLastLayer();
        if (isLastLayer) {
            //检测楼层最后一个组件业务数据是否需要通过访问接口获取
            int compSize = compList.size();
            if (compSize > 0) {
                CompBean compBean = compList.get(compSize - 1);
                boolean haveData = haveDataSize(compBean.getOperDataList()) > 0;

                //最后一个楼层，需要检测下配置的组件是否支持动态数据源
                String dataSourceType = compBean.getDataSourceType();
                // 组件直播回放数据
                if (CompDataSourceBean.LIVE_END.equals(dataSourceType) && !haveData) {
                    // 该组件需要通过接口获取业务数据
                    goNormal = false;
                    group.setPageNum(1);
                    group.setSupportLoadMoreDataComp(compBean);
                    group.setGroupBean(groupBean);
                    // 发起网络请求，获取该组件业务数据
                    accessCompRequest(group);
                }
            }

        }

        if (goNormal) {
            compStreamDataSourceLogic(groupBean, group);
        }
    }


    /**
     * 访问组件的接口数据
     *
     * @param group
     */
    public void accessCompRequest(AbsGroup group) {

        // 加载缓存
        if (pageData != null && pageData.isLocalCache) {
            mGetDataFinishTask.registerCondition(group.getSupportLoadMoreDataComp().getStartTimeStamp());
            loadLocalCompDataSourceCache(group.getSupportLoadMoreDataComp(), group.getGroupBean(), group);
            return;
        }
        if (compLogicDataBean.loadMore) {
            pageData.needRefresh = false;
            pageData.isLocalCache = false;
            pageData.pageInforRefresh = false;
            pageData.moreRefresh = false;
            //清理该楼层所有组件资源
            group.getGroupBean().getComps().clear();
            // 添加支持能加载更多数据的组件对象
            group.getGroupBean().getComps().add(group.getSupportLoadMoreDataComp());
        }
        // 访问直播回放数据
        getLiveChannelReviewList(group.getPageNum(), maxCount, group.getGroupBean(), group, group.getSupportLoadMoreDataComp());
    }

    /**
     * 获取直播回放数据
     */
    private void getLiveChannelReviewList(int pageNum, int pageSize, GroupBean groupBean, AbsGroup group, CompBean compBean) {


        mGetDataFinishTask.registerCondition(compBean.getStartTimeStamp());

        Map<String, Object> map = new HashMap<>();
        map.put("pageNum", pageNum);
        map.put("pageSize", pageSize);
        Observable<BaseResponse<ContentPageListBean>> codeData = getRetrofit().queryLiveChannelReviewList(map);
        request(codeData, new BaseObserver<ContentPageListBean>() {
            @Override
            protected void dealSpecialCode(int code, String message) {

                if (pageNum > 1) {
                    if (compLogicDataBean != null && compLogicDataBean.tipFlag) {
                        ToastNightUtil.showShort(message);
                    }
                    if (mListener != null) {
                        mListener.onPageDataFailed(0,"compInfo is error");
                    }
                } else {
                    mGetDataFinishTask.matchCondition(compBean.getStartTimeStamp());
                }
            }

            @Override
            public void onSuccess(ContentPageListBean list) {

            }

            @Override
            protected void onSuccess(ContentPageListBean contentPageListBean, MetaBean metaBean, String msg, int code) {
                super.onSuccess(contentPageListBean, metaBean, msg, code);

                if (contentPageListBean == null) {
                    if (compLogicDataBean.loadMore) {
                        pageData.totalCompSize = 0;
                    } else {
                        pageData.totalCompSize = pageData.totalCompSize + 0;
                    }
                } else {
                    int size = haveDataSize(contentPageListBean.getList());
                    if (!compLogicDataBean.loadMore) {
                        CacheData localCacheData = CacheData.getLocalCacheData(CacheData.dataSourceCacheKey + compLogicDataBean.pageId + group.getId());
                        // 新旧数据md5值对比
                        String dataMd5 = chacheDataAndNewDataContrastByMd5ToComp(localCacheData, metaBean, 0, false);
                        if (size > 0) {
                            // 缓存数据源-数据
                            CacheData.saveDataToPreference(CacheData.dataSourceCacheKey + compLogicDataBean.pageId + group.getId(), contentPageListBean, dataMd5);
                        }
                    }

                    if (size > 0) {
                        int reviewListTotalCount = contentPageListBean.getTotalCount();
                        compBean.reviewListTotalCount = reviewListTotalCount;
                        pageData.moreRefresh = compLogicDataBean.loadMore;
                        // 接口获取该组件业务数据
                        List<ContentBean> list = contentPageListBean.getList();
                        compBean.setOperDataList(list);
                        // 加工组件的运维数据
                        compStreamDataSourceLogic(groupBean, group);
                    }

                }


                mGetDataFinishTask.matchCondition(compBean.getStartTimeStamp());

            }

            @Override
            public void _onError(String e) {

                if (pageNum > 1) {
                    if (compLogicDataBean != null && compLogicDataBean.tipFlag) {
                        ToastNightUtil.showShort(e);
                    }
                    if (mListener != null) {
                        mListener.onPageDataFailed(1,"compInfo is error");
                    }
                } else {
                    mGetDataFinishTask.matchCondition(compBean.getStartTimeStamp());
                }

            }
        });
    }

    /**
     * 内部数据源缓存
     */
    private void loadLocalCompDataSourceCache(CompBean compBean,
                                              GroupBean groupBean, AbsGroup group) {
        CacheData dataSourceCache = CacheData.getLocalCacheData(CacheData.dataSourceCacheKey + compLogicDataBean.pageId + group.getId());
        if (dataSourceCache != null && !StringUtils.isBlank(dataSourceCache.getNetWorkData())) {
            // 缓存数据
            String netWorkData = dataSourceCache.getNetWorkData();
            ContentPageListBean bean = GsonUtils.fromJson(netWorkData, ContentPageListBean.class);
            if (bean == null) {
                handHttpNormalData(null, compBean, groupBean, group);
                mGetDataFinishTask.matchCondition(compBean.getStartTimeStamp());
                return;
            }
            handHttpNormalData(bean.getList(), compBean, groupBean, group);
            // 通知页面刷新
            mGetDataFinishTask.matchCondition(compBean.getStartTimeStamp());
        } else {
            handHttpNormalData(null, compBean, groupBean, group);
            mGetDataFinishTask.matchCondition(compBean.getStartTimeStamp());
        }
    }

    /**
     * 处理正常的接口请求数据 comp组件展示的业务数据 并处理了兜底数据
     *
     * @param serverSourceData 动态接口提供的业务数据
     * @param compBean         组件对象
     * @param groupBean
     * @param group
     */
    protected void handHttpNormalData(List<ContentBean> serverSourceData,
                                      CompBean compBean, GroupBean groupBean, AbsGroup group) {

        int serverSize = haveDataSize(serverSourceData);
        // 接口获取的业务数据量
        if (serverSize > 0) {
            // 接口获取该组件业务数据
            List<ContentBean> list = serverSourceData;
            compBean.setOperDataList(list);
            // 加工组件的运维数据
            compStreamDataSourceLogic(groupBean, group);
        } else {

            getLiveChannelReviewList(group.getPageNum(), maxCount, groupBean, group, compBean);

        }

    }

    /**
     * comp配对的数据源逻辑处理
     *
     * @param groupBean
     * @param group
     */
    protected void compStreamDataSourceLogic(GroupBean groupBean, AbsGroup group) {

        List<CompBean> compList = groupBean.getComps();
        if (compList == null) {
            return;
        }

        // 页面收集楼层组件数据
        if (compLogicDataBean.loadMore) {
            // 清理旧的获取到的组件数据
            pageData.clearRequestLayerCompList();
        }

        // 记录一次请求转换成展现的数据量
        int compListSize = compList.size();
        if (compLogicDataBean.loadMore) {
            pageData.pageCompNum = compListSize + pageData.pageCompNum;
            pageData.totalCompSize = compListSize;
        } else {

            pageData.pageCompNum = compListSize;
            // 多个楼层页面，首次绘制页面，需要统计出不同楼层组件数量
            pageData.totalCompSize = pageData.totalCompSize + compListSize;
        }
        //专题信息流页面
        //  if (compLogicDataBean.isSubjectPage()) {
        //resettleCustomCompToSubjectList(pageData.isNewsSubjectInfor(), compList, group);
        //  }
        // 加工楼层组件的数据
        processGroupCompList(compList, groupBean, group);
    }


    /**
     * 加工组件的运维数据
     *
     * @param compList
     * @param groupBean
     * @param group
     */
    private void processGroupCompList(List<CompBean> compList, GroupBean groupBean, AbsGroup group) {

        /*
           第一次 楼层compBean数据遍历，处理特殊组件转换，特殊页面用特定稿件展示的数据设定
         */
        // 收集组件信息
        List<CompBean> newCompList = new ArrayList<>();
        // 遍历组件对象，给组件对象添加页面信息和转换频道组合卡的业务数据,对特殊组件进行转换
        for (CompBean compBean : compList) {
            normalCompData(compBean, newCompList);
        }

        if (pageData.isNewsSubjectInfor()) {

        } else {
            // 检索广告
            resettleAdvToPosition(newCompList, groupBean.getCompAdList());
        }
        // 记录稿件业务数据
        pageData.addGroupCompList(newCompList);
        // 设置加工后的组件集合
        groupBean.setComps(newCompList);
        // 楼层组件数据加工
        groupCompDataProcess(groupBean, group);

    }


    /**
     * 安置广告信息到对应的位置
     *
     * @param newCompList 信息流
     * @param compAdList  广告资源
     */
    private void resettleAdvToPosition(List<CompBean> newCompList, List<CompAdvBean> compAdList) {

        // 统计一次请求，插入了多少个广告
        int layoutAdvIndex = 0;//稿件投放统计
        int bannerAdvIndex = 0;// banner组件展示数据投放

        if (compAdList != null && compAdList.size() > 0 && newCompList.size() > 0) {
            // 排序
            Collections.sort(compAdList, new Comparator<CompAdvBean>() {
                @Override
                public int compare(CompAdvBean p1, CompAdvBean p2) {
                    int p1P = p1.getSlotInfo().getPosition();
                    int p2P = p2.getSlotInfo().getPosition();
                    return p1P - p2P;
                }

            });

            // 档次请求的稿件/组件数量
            int requestCompSize = newCompList.size();
            // 页面组件和稿件数量
            int pageTotalCompNum = pageData.pageCompNum;
            long currentTime = HostUtil.serverTime;


            for (CompAdvBean advBean : compAdList) {

                // 有效投放时间
                long endTime = advBean.getEndTime();
                long startTime = advBean.getStartTime();

                // 满足投放时间
                if (currentTime >= startTime && endTime <= endTime) {
                    // 广告内容
                    CompAdvMatInfoBean matInfoBean = advBean.getMatInfo();
                    if (matInfoBean == null) {
                        continue;
                    }
                    //信息流广告位
                    CompAdvSlotInfoBean slotInfo = advBean.getSlotInfo();

                    int advSubType = matInfoBean.getAdvSubType();
                    //
                    if (slotInfo != null) {

                        // 插入轮播组件的广告
                        if (4 == advSubType) {
                            int position = slotInfo.getPosition() - 1;
                            // 检测newCompList 集合中是否有轮播组件资源
                            String adCompId = slotInfo.getCompId();
                            if (!TextUtils.isEmpty(adCompId)) {
                                for (CompBean compBean : newCompList) {
                                    String compId = compBean.getId();
                                    //匹配组件
                                    if (adCompId.equals(compId)) {
                                        // 运营位数据
                                        List<ContentBean> dataList = compBean.getOperDataList();
                                        if (dataList != null) {
                                            int dataListSize = dataList.size();
                                            ContentBean advContentBean = new ContentBean();
                                            advContentBean.compAdvBeanToBean(advBean);
                                            if (position < dataListSize) {
                                                dataList.add(position + bannerAdvIndex, advContentBean);
                                            } else {
                                                dataList.add(advContentBean);
                                            }
                                            bannerAdvIndex = bannerAdvIndex + 1;
                                        }
                                    }
                                }
                            }

                        } else {
                            // 插入稿件的广告
                            int position = slotInfo.getPosition();
                            // 页面的comp总数 - 这次请求的comp总数 = 剩余comp总数
                            int a = pageTotalCompNum - requestCompSize;
                            if (position - 1 <= pageTotalCompNum && position - 1 >= a) {
                                String style = obtainStyleFromAdvSubType(advSubType);
                                if (!TextUtils.isEmpty(style)) {
                                    // 投放位置 - 剩余comp总数 -1
                                    int b = position - a - 1;
                                    if (b <= requestCompSize && b >= 0) {
                                        CompBean adCompBean = new CompBean();
                                        if (advSubType >= 10 || advSubType == 7) {
                                            adCompBean.setCompType(compDefType);
                                            adCompBean.setCompStyle(style);
                                        } else {
                                            adCompBean.setCompType(manuscriptType);
                                            adCompBean.setCompStyle(style);
                                        }


                                        List<ContentBean> operDataListTemp = new ArrayList<>();
                                        ContentBean advContentBean = new ContentBean();
                                        advContentBean.compAdvBeanToBean(advBean);
                                        operDataListTemp.add(advContentBean);
                                        adCompBean.setOperDataList(operDataListTemp);

                                        if (position - 1 == requestCompSize) {
                                            newCompList.add(adCompBean);
                                        } else {
                                            newCompList.add(b + layoutAdvIndex, adCompBean);
                                        }

                                        layoutAdvIndex = layoutAdvIndex + 1;
                                    }

                                }

                            }

                        }
                    }
                }

            }

        }

    }

    /**
     * @param advSubType 4：轮播图     5：三图广告    6：小图广告    7：长通栏广告   8：大图广告    9：视频广告    10：展会广告    11：冠名广告    12：顶部长通栏广告
     * @return
     */
    private String obtainStyleFromAdvSubType(int advSubType) {


        if (advSubType == 5) {
            return String.valueOf(ContentTypeConstant.MANUSCRIPT_STYLE_FOUR);
        }

        if (advSubType == 6) {
            return String.valueOf(ContentTypeConstant.MANUSCRIPT_STYLE_THIRTEEN);
        }
        if (advSubType == 8 || advSubType == 9) {
            return String.valueOf(ContentTypeConstant.MANUSCRIPT_STYLE_TWO);
        }

        //视频展会广告
        if (advSubType == 10) {
            return "Comp_Ad_03";
        }
        //冠名广告
        if (advSubType == 11) {
            return "Comp_Ad_02";
        }
        // 通栏广告
        if (advSubType == 12 || advSubType == 7) {
            return "Comp_Ad_01";
        }

        return null;
    }

    /**
     * 普通组件和特殊组件携带业务数据，进行数据转换处理
     *
     * @param compBean
     * @param newCompList
     */
    private void normalCompData(CompBean compBean, List<CompBean> newCompList) {


        String style = compBean.getCompStyle();
        String type = compBean.getCompType();

        if (TextUtils.isEmpty(style) || TextUtils.isEmpty(type)) {
            return;
        }

        /*
          检测出特殊页面，需要对组件中的运维数据进行指定转换
         */
        if (pageData.isNewsSubjectInfor()) {
            // 早晚报专题页面，业务数据按指定样式展示,只有一个组件数据
            if (SubjectZABSpCompStyle.equals(style) && SubjectZABSpCompType.equals(type)) {

                // 检测audioDataList，判断是否有一键播放组件
                List<ContentBean> audioDataList = compBean.getAudioDataList();
                if (audioDataList != null && audioDataList.size() > 0) {
                    CompBean titleBean = new CompBean();
                    titleBean.setAudioDataList(audioDataList);
                    titleBean.setCompType(compDefType);
                    titleBean.setCompStyle(NewsPageOnekeyStyle);
                    newCompList.add(0, titleBean);
                }

                // 早晚报专题特殊组件的运营位数据，转换成指定稿件
                List<ContentBean> operDataList = compBean.getOperDataList();
                if (operDataList != null) {
                    int size = operDataList.size();
                    for (int i = 0; i < size; i++) {
                        ContentBean contentBean = operDataList.get(i);
                        CompBean scBean = new CompBean();
                        scBean.setCompType(compDefType);
                        scBean.setCompStyle(NewsPageItemStyle);
                        scBean.setSourceType(manuscriptType);
                        scBean.setSourceStyle(contentBean.getAppStyle());

                        List<ContentBean> operDataListTemp = new ArrayList<>();
                        operDataListTemp.add(contentBean);
                        scBean.setOperDataList(operDataListTemp);
                        // 早晚报专题
                        newCompList.add(scBean);
                    }
                }
                pageData.totalCompSize = newCompList.size();
            }

        } else {
            if (OneRowTwoImageCompStyle.equals(style) && OneRowTwoImageCompType.equals(type)) {
                List<ContentBean> operDataList = compBean.getOperDataList();

                //一行两图卡
                if (operDataList != null) {
                    int size = operDataList.size();
                    if (size > 0) {
                        // 添加个标题
                        if (compBean.isCompShowTitle()) {
                            compBean.setCompShowTitle(false);
                            CompBean titleCompBean = new CompBean();
                            titleCompBean.setObjectTitle(compBean.getObjectTitle());
                            //titleCompBean.setName(compBean.getName());
                            titleCompBean.setDataSourceType(compBean.getDataSourceType());
                            titleCompBean.setObjectType(compBean.getObjectType());

                            titleCompBean.setCompStyle(CompSubjectTile02);
                            titleCompBean.setCompType(compDefType);
                            titleCompBean.setSourceStyle(style);
                            titleCompBean.setSourceType(type);
                            newCompList.add(titleCompBean);
                        }

                        int oldSize = compBean.getContentBeanSize();// 已经展示的信息
                        for (int i = 0; i < size; i++) {
                            ContentBean contentBean = operDataList.get(i);
                            CompBean newCompBean = new CompBean();
                            newCompBean.setCompStyle(style);
                            newCompBean.setCompType(type);
                            newCompBean.setPosition(i + oldSize);
                            List<ContentBean> newCompListoperDataList = new ArrayList<>();
                            newCompListoperDataList.add(contentBean);
                            newCompBean.setOperDataList(newCompListoperDataList);
                            newCompList.add(newCompBean);
                        }
                        compBean.addContentBeanSize(size);
                        compBean.setOperDataList(null);
                        // 检测一行两图卡是否加载完毕
                        if (compBean.reviewListTotalCount == compBean.getContentBeanSize()) {
                            CompBean titleCompBean = new CompBean();
                            titleCompBean.setCompStyle(CompSubjectLine01);
                            titleCompBean.setCompType(compDefType);
                            titleCompBean.setSourceStyle(style);
                            titleCompBean.setSourceType(type);
                            newCompList.add(titleCompBean);
                        }

                    }
                }
            } else if (OneLivingBigImageCompStyle.equals(style) && OneLivingBigImageCompType.equals(type)) {
                //正在直播大图卡组件，转换成大图卡稿件
                List<ContentBean> operDataList = compBean.getOperDataList();
                if (operDataList != null) {
                    int size = operDataList.size();
                    if (size > 0) {
                        for (int i = 0; i < size; i++) {
                            ContentBean contentBean = operDataList.get(i);
                            CompBean newCompBean = new CompBean();
                            newCompBean.setCompStyle(style);
                            newCompBean.setCompType(type);
                            newCompBean.setPosition(i);
                            List<ContentBean> newCompListoperDataList = new ArrayList<>();
                            contentBean.setRmhInfo(null);
                            newCompListoperDataList.add(contentBean);
                            newCompBean.setOperDataList(newCompListoperDataList);
                            newCompList.add(newCompBean);
                        }
                        compBean.setOperDataList(null);
                    }
                }
            } else if (CommentCompStyle.equals(style) && CommentCompType.equals(type)) {
                // 精选评论卡，把评论对象转成展现对象
                List<ContentBean> operDataList = compBean.getOperDataList();
                if (operDataList != null && operDataList.size() > 0) {
                    ContentBean contentBean = operDataList.get(0);
                    contentBean.commentInforToContentInfor();
                    newCompList.add(compBean);
                }

            } else {

                boolean addCompFlag = true;
                // 兴趣询问卡，用户主动关闭，现生命周期内不展示
                if (InterestCompStyle.equals(style) && InterestCompType.equals(type)) {
                    addCompFlag = GlobalAppCacheData.IS_SHOW_CompSingleRow05;
                }
                // 人民号入驻卡,登录者是普通账号则可以显示
                if (RrhRzCompStyle.equals(style) && RrhRzpCompType.equals(type)) {
                    int userType = SpUtils.getUserType();
                    addCompFlag = (userType == 1 || userType == -1);
                }

                if (addCompFlag) {
                    // 无需处理 comp数据
                    newCompList.add(compBean);
                }
            }
        }

    }


    /**
     * 楼层组件数据加工
     *
     * @param groupBean
     * @param group
     */
    private void groupCompDataProcess(GroupBean groupBean, AbsGroup group) {

        // 组件需要页面信息，在此收集下
        String pageId = pageData.getId();
        String pageName = pageData.getName();
        String oneChannelId = compLogicDataBean.oneChannelId;// 设置一级频道id

        TopicInfoBean topicInfoBean = pageData.getTopicInfo();
        ChannelInfoBean channelInfoBean = pageData.getChannelInfo();

        List<CompBean> newCompList = groupBean.getComps();

        int compListSize = newCompList.size();
        // Log.e("DDDDSSS","groupCompDataProcess size="+compListSize);
        //第二次 楼层compBean遍历，给组件对象设置需要的辅助参数
        for (int i = 0; i < compListSize; i++) {

            CompBean compBean = newCompList.get(i);
            String compStyle = compBean.getCompStyle();
            String compType = compBean.getCompType();

            // 统计comp所在页面信息
            compBean.setPageName(pageName);
            compBean.setCompInforPageId(pageId);
            compBean.setTrackPageName(pageName);
            compBean.setOneChannelId(oneChannelId);
            // 收集专题 频道信息放入组件和稿件中
            compBean.setChannelInfoBean(channelInfoBean);
            compBean.setTopicInfoBean(topicInfoBean);
            compBean.setSourceInterfaceVal(groupBean.getSourceInterfaceVal());
            // comp 记录 groupId
            compBean.setGroupId(group.getId());

            // 组件所在的页面是否存在国殇模式
            if (compLogicDataBean.contryGrayFlag) {
                compBean.setPageGrayFlag(true);
            } else {
                compBean.setPageGrayFlag(false);
            }

            // 处理相关人民号系列的稿件号主对象,不同稿件内容相同人民号信息，用一个人民号对象
            if (manuscriptType.equals(compType) && CompentLogicUtil.isPeopleCompByStyle(compStyle)) {
                // 查出稿件的人民号对象
                List<ContentBean> operDataList = compBean.getOperDataList();
                if (operDataList != null && operDataList.size() > 0) {
                    ContentBean bean = operDataList.get(0);
                    PeopleMasterBean peopleMasterBean = bean.getRmhInfo();
                    if (peopleMasterBean != null) {
                        String rmhId = peopleMasterBean.getRmhId();
                        if (rmhId != null) {
                            if (compMasterMap.containsKey(rmhId)) {
                                // 存在就直接用
                                PeopleMasterBean value = compMasterMap.get(rmhId);
                                bean.setRmhInfo(value);
                            } else {
                                // 不存在，存储起来
                                compMasterMap.put(rmhId, peopleMasterBean);
                            }
                        }
                    }
                }
            }

            // 组件数据转换
            handlNeedCompData(compBean);
        }

        // 解析楼层中组件信息转换成框架信息
        group.parseGroupData(groupBean, compLogicDataBean.loadMore);

    }


    /**
     * 处理获取的 comp 数据
     *
     * @param currentCompBean
     */
    private void handlNeedCompData(CompBean currentCompBean) {

        // comp有对应的业务数据
        if (currentCompBean.getOperDataList() != null) {
            OperateBean operateBean = new OperateBean();
            operateBean.setDataList(currentCompBean.getOperDataList());
            currentCompBean.setOperateBean(operateBean);
        }

    }

    /**
     * 开启批查评论数量
     */
    private boolean openBatchDyNum = true;

    /**
     * 开启批查直播数据
     */
    private boolean openBatchLiveRoomData = false;

    /**
     * 开启批查用户操作行为产生的业务数据，如关注状态等
     */
    private boolean openBatchUserDy = true;

    /**
     * 批查稿件的相关信息
     *
     * @param compList
     */
    protected void betchQueryItemDy(List<CompBean> compList, PageDataFetcher pageDataFetcher) {

        // 收集需要批查的稿件信息体
        if (collectContentList == null) {
            collectContentList = new ArrayList<>();
        } else {
            collectContentList.clear();
        }

        for (CompBean compBean : compList) {

            String style = compBean.getCompStyle();
            String type = compBean.getCompType();
            boolean addFlag = false;
            if (manuscriptType.equals(type)) {
                //检测出是稿件
                addFlag = true;
                // 稿件中人民号大图卡和大图,需要批查直播
                if (String.valueOf(ContentTypeConstant.MANUSCRIPT_STYLE_TWO).equals(style) ||
                        String.valueOf(ContentTypeConstant.MANUSCRIPT_STYLE_FIFTEEN).equals(style)) {
                    openBatchLiveRoomData = true;
                }

            } else if (OneLivingBigImageCompStyle.equals(style) && OneLivingBigImageCompType.equals(type)) {
                // 正在直播大图卡组件
                addFlag = true;
                openBatchLiveRoomData = true;
            } else if (NewsPageItemStyle.equals(style) && compDefType.equals(type)) {
                // 早晚报专题特殊稿件
                addFlag = true;
            } else if (OneRowTwoImageCompStyle.equals(style) && OneRowTwoImageCompType.equals(type)) {
                // 一行两图卡
                addFlag = true;
                openBatchLiveRoomData = true;
            }

            if (addFlag) {
                List<ContentBean> operDataList = compBean.getOperDataList();
                if (operDataList != null && operDataList.size() > 0) {
                    if (NewsPageItemStyle.equals(style) && compDefType.equals(type)) {
                        collectContentList.add(operDataList.get(0));
                        openBatchUserDy = false;
                    } else {
                        collectContentList.add(operDataList.get(0));
                    }

                }
            }
        }

        int size = collectContentList.size();

        if (size > 0) {
            /*
             * 1、少于20条，做一个批次查询；
             * 2、多余20条，做多批次批量查询，第一个批次查询的结果，通知页面，刷新，其余批次查询的结果直接赋值，无需刷新页面
             */
            List<ContentBean> dataBeans = new ArrayList<>();
            if (size <= maxCount) {
                batchTime = 1;
                totalBatchCount = 1;
                surplus = 0;
                dataBeans.addAll(collectContentList);
            } else {
                // 总量是maxCount的多少份
                batchTime = 1;
                totalBatchCount = size / maxCount + 1;
                surplus = size % maxCount;
                dataBeans.addAll(collectContentList.subList(0, maxCount));
            }
            // 多个接口完成
            batchGetDataFinishTask = new PageDataFinishTask(2);
            batchGetDataFinishTask.setPageDataFetcher(pageDataFetcher);
            sendMoreBatchRequest(dataBeans);
        }

    }

    /**
     * 检测批次，并发送请求多个批量查询接口
     */
    protected void checkBatchTimeAndRequestDyData() {
        // 页码 = 总页相等 无需查询
        if (batchTime == totalBatchCount) {

            collectContentList.clear();
            collectContentList = null;

        } else if (batchTime < totalBatchCount) {
            // 页码 < 总页相等 无需查询
            List<ContentBean> tempData = new ArrayList<>();
            int startIndex = batchTime * maxCount;
            batchTime = batchTime + 1;
            int endIndex = batchTime * maxCount;
            if (batchTime == totalBatchCount) {
                endIndex = startIndex + surplus;
            }
            batchGetDataFinishTask.setPageType(3);
            tempData.addAll(collectContentList.subList(startIndex, endIndex));
            sendMoreBatchRequest(tempData);
        }
    }

    /**
     * 发送多个批查请求
     *
     * @param dataBeans
     */
    private void sendMoreBatchRequest(List<ContentBean> dataBeans) {


        /*
        每次批查20条
        多批次批查，第一次调用多个批查接口刷新信息流页面，其它调用只需赋值，无须刷页面
         */

        if (openBatchDyNum) {
            // 查询作品动态数据 评论数、点赞数、分享数、收藏数
            sendBatchDyNumRequest(dataBeans);

        }

        if (openBatchLiveRoomData) {
            //批量查C端查询直播信息
            sendBatchLiveRoomDataRequest(dataBeans);
        }

        if (openBatchUserDy) {
//            if (PDUtils.isLogin()) {
//                // 人民号相关稿件需要 点赞状态、收藏状态和关注状态
//                List<PeopleMasterBean> peopleMasterBeanList = CompentLogicUtil.getCreaterSet(dataBeans);
//                int masterListSize = peopleMasterBeanList.size();
//                if (masterListSize > 0 && masterListSize <= maxCount) {
//                    // 查询用户关注状态
//                    sendBatchUserFollowInfor(dataBeans, peopleMasterBeanList);
//                }
//                // 查询作品的点赞状态、收藏状态
//                sendBatchLikeAndCollectStatusRequest(dataBeans);
//
//                //        //查询直播间预约状态
////        List<String> liveInfoList = CompentLogicUtil.getLiveId(dataBeans);
////        int liveInfoSize = liveInfoList.size();
////        if (liveInfoSize > 0 && liveInfoSize <= maxCount) {
////            sendBatchLivePredict(dataBeans, liveInfoList);
////        }
//            }
        }


    }


    /**
     * 批量查询点赞和收藏状态
     *
     * @param list
     */
//    private void sendBatchLikeAndCollectStatusRequest(List<ContentBean> list) {
//
//        InteractionStatusDataFetcher dataFetcher = new InteractionStatusDataFetcher();
//        dataFetcher.sendBatchLikeAndCollectStatusRequest(list, new BatchCallback<List<DisplayWorkInfoBean>>() {
//
//            String requestStr;
//
//            @Override
//            public void parameter(String requestStr) {
//                this.requestStr = requestStr;
//                if (batchGetDataFinishTask != null) {
//                    batchGetDataFinishTask.registerCondition(requestStr);
//                }
//            }
//
//            @Override
//            public void success(List<DisplayWorkInfoBean> data) {
//                if (batchGetDataFinishTask != null) {
//                    batchGetDataFinishTask.matchCondition(requestStr);
//                }
//            }
//
//            @Override
//            public void error(String error) {
//                if (batchGetDataFinishTask != null) {
//                    batchGetDataFinishTask.matchCondition(requestStr);
//                }
//            }
//        });
//
//    }


    /**
     * 批量查C端查询直播信息（观看人次、点赞人数、评论数、订阅数）
     *
     * @param list
     */
    private void sendBatchLiveRoomDataRequest(List<ContentBean> list) {

//        InteractionStatusDataFetcher dataFetcher = new InteractionStatusDataFetcher();
//        dataFetcher.sendBatchLiveRoomDataRequest(list, new BatchCallback<List<RoomDataBean>>() {
//
//            String requestStr;
//
//            @Override
//            public void parameter(String requestStr) {
//                this.requestStr = requestStr;
//                if (batchGetDataFinishTask != null) {
//                    batchGetDataFinishTask.registerCondition(requestStr);
//                }
//            }
//
//            @Override
//            public void success(List<RoomDataBean> data) {
//                if (batchGetDataFinishTask != null) {
//                    batchGetDataFinishTask.matchCondition(requestStr);
//                }
//            }
//
//            @Override
//            public void error(String error) {
//                if (batchGetDataFinishTask != null) {
//                    batchGetDataFinishTask.matchCondition(requestStr);
//                }
//            }
//        });

    }

    /**
     * 批量查询用户关注状态
     *
     * @param contentBeanList
     * @param peopleMasterBeanList
     */
//    private void sendBatchUserFollowInfor(List<ContentBean> contentBeanList, List<PeopleMasterBean> peopleMasterBeanList) {
//
//        CompentLogicUtil.sendBatchUserFollowInfor(contentBeanList, peopleMasterBeanList, new BatchCallback<List<MasterFollowsStatusBean>>() {
//            String requestStr;
//
//            @Override
//            public void parameter(String requestStr) {
//                this.requestStr = requestStr;
//                if (batchGetDataFinishTask != null && requestStr != null) {
//                    batchGetDataFinishTask.registerCondition(requestStr);
//                }
//            }
//
//            @Override
//            public void success(List<MasterFollowsStatusBean> data) {
//                if (batchGetDataFinishTask != null && requestStr != null) {
//                    batchGetDataFinishTask.matchCondition(requestStr);
//                }
//            }
//
//            @Override
//            public void error(String error) {
//                if (batchGetDataFinishTask != null && requestStr != null) {
//                    batchGetDataFinishTask.matchCondition(requestStr);
//                }
//            }
//        });
//
//    }


    /**
     * 查询内容点赞、评论状态
     *
     * @param contentBeanList
     */
    private void sendBatchDyNumRequest(List<ContentBean> contentBeanList) {

        CompentLogicUtil.sendBatchDyNumRequest(contentBeanList, new BatchCallback<List<InteractResponseDataBean>>() {
            String requestStr;

            @Override
            public void parameter(String requestStr) {
                this.requestStr = requestStr;
                if (batchGetDataFinishTask != null && requestStr != null) {
                    batchGetDataFinishTask.registerCondition(requestStr);
                }
            }

            @Override
            public void success(List<InteractResponseDataBean> data) {

                if (batchGetDataFinishTask != null && requestStr != null) {
                    batchGetDataFinishTask.matchCondition(requestStr);
                }
            }

            @Override
            public void error(String error) {
                if (batchGetDataFinishTask != null && requestStr != null) {
                    batchGetDataFinishTask.matchCondition(requestStr);
                }
            }
        });

    }

    /**
     * 缓存数据与新数据依据md5值对比，决定是否需要刷界面,只对聚合页面 楼层、组件等信息处理
     *
     * @param localCacheData
     * @param metaBean
     * @param md5Type        0：取正常的md5字段值；1：取fmd5字段值
     * @return
     */
    protected String chacheDataAndNewDataContrastByMd5ToComp(CacheData localCacheData, MetaBean metaBean, int md5Type, boolean pageInforFlag) {

        boolean needRefresh = false;
        if (null == localCacheData) {
            needRefresh = true;
        }
        String dataMd5 = "";
        if (metaBean != null) {
            if (md5Type == 0) {
                dataMd5 = metaBean.getMd5();
            } else if (md5Type == 1) {
                // type = 内容推荐  刷新策略 = 1 才会有fmd5值
                dataMd5 = metaBean.getFmd5();
            }

        }

        //代码规范提示if里不要有复杂计算
        if (localCacheData != null && localCacheData.needRefreshByMd5(dataMd5)) {
            needRefresh = true;

        }

        if (localCacheData != null) {
       //     Log.e("DDDDSSS", "缓存数据：" + localCacheData.md5 + "---------------------新数据=" + dataMd5 + "   needRefresh=" + needRefresh);
        }

        // 其它情况必刷
        if (needRefresh) {
            if (pageData != null) {
                pageData.needRefresh = true;

                if (pageInforFlag) {
                    pageData.pageInforRefresh = true;
                }

            }
        }

        if (pageData != null) {
            pageData.isLocalCache = false;
        }
        return dataMd5;

    }

    /**
     * 检测数据
     *
     * @param list
     * @return
     */
    protected int haveDataSize(List<ContentBean> list) {

        if (list == null) {
            return 0;
        } else {
            return list.size();
        }
    }
}