/*
 * Copyright (c) People Technologies Co., Ltd. 2019-2022. All rights reserved.
 */

package com.wd.layoutdataimpl.model;

import android.text.TextUtils;

import androidx.annotation.NonNull;


import com.wd.capability.layout.R;
import com.wd.capability.layout.comp.layoutdata.AbsGroup;
import com.wd.capability.layout.comp.layoutdata.AbsSection;
import com.wd.capability.layout.comp.layoutdata.Page;
import com.wd.capability.layout.comp.parser.ChannelSectionParser;
import com.wd.capability.layout.page.model.CompLogicDataBean;
import com.wd.capability.layout.page.vm.IPageDataListener;
import com.wd.capability.network.BaseObserver;
import com.wd.capability.network.bean.MetaBean;
import com.wd.capability.network.cachedata.CacheData;
import com.wd.capability.network.response.BaseResponse;
import com.wd.common.api.RequestApi;
import com.wd.foundation.bean.custom.comp.ChannelInfoBean;
import com.wd.foundation.bean.custom.comp.CompBean;
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.wdkit.json.GsonUtils;
import com.wd.foundation.wdkit.utils.SpUtils;
import com.wd.foundation.wdkit.utils.ToastNightUtil;
import com.wd.foundation.wdkitcore.tools.ArrayUtils;
import com.wd.foundation.wdkitcore.tools.ResUtils;
import com.wd.foundation.wdkitcore.tools.StringUtils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import io.reactivex.Observable;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.schedulers.Schedulers;

/**
 * 信息流页面
 * 频道数据的抓取器<BR>
 * 对接新的接口，结构调整了，较之前的改动大<BR>
 * 结果回调统一走onPageDataSuccess，不走onPartialDataSuccess了。只有page接口和group接口都回来才能刷UI
 *
 * @author zhangbo
 * @version [V1.0.0, 2022/4/12]
 * @since V1.0.0
 */
public class PageDataFetcher extends PageCompDataFactory<RequestApi> {
    private static final String TAG = "PageDataFetcherNews";
    private boolean isCanceled = false;

    /**
     * 页面已经展示的第一页数据
     */
    private List<CompBean> firstPageCompList;

    /**
     * 构造器
     *
     * @param listener 监听回调
     */
    public PageDataFetcher(IPageDataListener listener) {
        mListener = listener;
        initPage();
    }

    public IPageDataListener getmListener() {
        return mListener;
    }

    /**
     * 获取当前页面楼层排序信息
     *
     * @param useCache          缓存标记
     * @param compLogicDataBean
     */
    public void getPageData(boolean useCache, CompLogicDataBean compLogicDataBean) {

        this.compLogicDataBean = compLogicDataBean;

        // 已经获取到了 pageinfor对象，无需使用接口重新获取
        if (compLogicDataBean.pageInforBean != null) {

            PageBean pageInfoBean = compLogicDataBean.pageInforBean;
            pageInfoBean.isLocalCache = useCache;

            if (mListener != null) {
                mListener.onPageInforSuccess(pageInfoBean);
            }
            if (useCache) {
                // 楼层数据
                callback(pageInfoBean, useCache);
            } else {
                //专题页面
                if (compLogicDataBean.isSubjectPage() && pageData != null) {
                    pageData.voteShowFlag = true;
                }
                //使用多楼层处理模式
                useMoreLayerModel(useCache);
            }

        } else {
            // 缓存组件的数据
            if (useCache) {
                loadLocalPageCacheData(compLogicDataBean.pageId);
                return;
            }
            //页面上的pageInfo 接口，特殊的接口使用合并接口pageInfo/v2
            Map<String, Object> map = new HashMap<>();
            map.put("pageId", compLogicDataBean.pageId);
            Observable<BaseResponse<PageBean>> pageDataObservable;
            //我是判断 如果首页启动默认选中的那个频道 是时间线频道 就掉v2接口
            if (compLogicDataBean.useV2){
                pageDataObservable = getRetrofit().getPageDataV2(map);
            }else {
                pageDataObservable = getRetrofit().getPageData(map);
            }
            request(pageDataObservable, new BaseObserver<PageBean>() {

                @Override
                protected void dealSpecialCode(int code, String message) {
                    mListener.onPageDataFailed(0,message);
                }

                @Override
                protected void onSuccess(PageBean pageBean) {

                }

                @Override
                protected void onSuccess(PageBean pageBean, MetaBean metaBean, String msg, int code) {
                    if (pageBean == null) {
                        mListener.onPageDataFailed(0,msg);
                        return;
                    }else  {
                        //在这里处理,如果使用v2,compInfo为空或者compList是空不用进行下去了
                        if (compLogicDataBean.useV2){
                            GroupBean compInfo = pageBean.getCompInfo();
                            if (null == compInfo || ArrayUtils.isEmpty(compInfo.getComps())){
                                mListener.onPageDataFailed(0,msg);
                                return;
                            }
                        }
                    }
                    mListener.onPageInforSuccess(pageBean);
                    if (ArrayUtils.isEmpty(pageBean.getGroups())) {
                        mListener.onPageDataSuccess(null, pageBean);
                        return;
                    }
                    pageData = pageBean;

                    CacheData localCacheData = CacheData.getLocalCacheData(CacheData.comPageInfoCacheKey + compLogicDataBean.pageId);
                    // 新旧数据md5值对比
                    String dataMd5 = chacheDataAndNewDataContrastByMd5ToComp(localCacheData, metaBean, 0, true);
                    // 保存缓存
                    CacheData.saveDataToPreference(CacheData.comPageInfoCacheKey + compLogicDataBean.pageId, pageBean, dataMd5);
                    // 楼层数据
                    callback(pageBean, false);
                }

                @Override
                protected void _onError(String e) {
                    // 专题和频道二级页面无需提示，会在页面中提示
                    if (compLogicDataBean != null && compLogicDataBean.tipFlag) {
                        ToastNightUtil.showShort(e);
                    }
                    if(pageData != null){
                        pageData.isLocalCache = useCache;
                    }

                    mListener.onPageDataFailed(1,e);
                }
            });

        }

    }


    /**
     * 初始化页面数据
     */
    private void initPage() {
        mPage = new Page();
        mPage.setSectionParser(new ChannelSectionParser());
    }

    /**
     * @param pageBean
     */
    private void callback(PageBean pageBean, boolean useCache) {
        if (isCanceled) {
            return;
        }
        pageData = pageBean;
        compLogicDataBean.setRefreshTime(pageBean.getRefreshTime());
        // 解析page数据，转换为group列表
        mPage.createGroup(pageBean);
        mPage.setPage(pageBean);
        parseData(useCache);
    }

    /**
     * 取消任务
     */
    public void cancel() {
        isCanceled = true;
    }

    public boolean isCanceled() {
        return isCanceled;
    }

    /**
     * 解析数据，并发二次请求去获取楼层组件数据
     */
    public void parseData(boolean useCache) {
        if (mPage == null) {
            return;
        }
        // 检查页面数据可收集了 楼层信息
        if (ArrayUtils.isEmpty(mPage.getGroups())) {
            return;
        }
        // 设置频道参数
        ChannelInfoBean channelInfoBean = pageData.getChannelInfo();
        if (channelInfoBean != null) {
            compLogicDataBean.channelId = channelInfoBean.getChannelId();
            compLogicDataBean.channelType = channelInfoBean.getChannelType();
        }
        // 设置专题参数
        TopicInfoBean topicInfoBean = pageData.getTopicInfo();
        if (topicInfoBean != null) {
            compLogicDataBean.topicId = topicInfoBean.getTopicId();
            compLogicDataBean.topicType = topicInfoBean.getTopicType();
            if (compLogicDataBean.isSubjectPage() && pageData.isNewsSubjectInfor()) {
                pageData.setBaselineShow("1");
                pageData.setBaselineCopywriting(ResUtils.getString(R.string.res_show_end));
                pageData.setBaselineColor("#FFFFFF");
            }
        }

        //使用多楼层处理模式
        useMoreLayerModel(useCache);

    }


    /**
     * 使用多楼层处理模式 （含一个楼层）
     * 多个楼层，第一次完成获取所有楼层的第一笔业务数据，再完成ui绘制
     *
     * @param useCache
     */
    private void useMoreLayerModel(boolean useCache) {
        // 初始化监听器
        initRequestConditionTask();

        // 楼层支持翻页，单个楼层翻页
        List<AbsGroup> groupsList = mPage.getGroups();
        int groupSize = groupsList.size();
        if (groupSize > 0) {
            // 清理页面的请求得到的楼层组件数据
            pageData.clearRequestLayerCompList();
            // 刷新时，清理页面已展示稿件信息
            pageData.clearPageAllShowCompList();

            // 收集楼层信息
            for (int i = 0; i < groupSize; i++) {
                AbsGroup group = groupsList.get(i);
                if (group == null) {
                    continue;
                }
                group.setLayerIndex(i);
                group.setPageNum(1);
                group.setShowBlock(true);
                // 记录最后一个楼层
                if (i == groupSize - 1) {
                    compLogicDataBean.groupId = group.getId();
                    compLogicDataBean.group = group;
                    mPage.setGroupIndex(i);
                    group.setLastLayer(true);
                } else {
                    group.setLastLayer(false);
                }
                // 解析group数据，并进行二次请求
                loadGroupData(group, useCache);
            }
        }
    }

    /**
     * 加载更多组件数据
     *
     * @param group
     */
    public void loadMoreCompData(@NonNull AbsGroup group) {

        // 楼层组件可加载更多数据
        initRequestConditionTask();
        // 普通楼层支持加载更多数据
        if (group.getSupportLoadMoreDataComp() == null) {
            //加载更多
            loadGroupData(group, false);
        } else {
            // 添加页数
            group.setPageNum(compLogicDataBean.requestTime);
            accessCompRequest(group);
        }
    }

    /**
     * 请求compInfo需要的参数
     * @param group
     * @return
     */
    private Map<String, Object> getCompParams(@NonNull AbsGroup group){
        //不使用缓存
        Map<String, Object> map = new HashMap<>();

        if(compLogicDataBean.requestTime == 1){
            group.setSearchValue("");
        }else {
            //请求下一页compInfo的时候，要把上一页返回的searchValue作为参数传给后端
            if(group != null && StringUtils.isNotEmpty(group.getSearchValue())){
                map.put("searchValue",group.getSearchValue());
            }
        }

        // 必须参数
        map.put("groupId", compLogicDataBean.loadMore ? compLogicDataBean.groupId : group.getId());

        map.put("pageNum", compLogicDataBean.requestTime);

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

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

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

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

        if (!TextUtils.isEmpty(compLogicDataBean.channelType)) {
            map.put("channelType", compLogicDataBean.channelType);
        }

        if (!TextUtils.isEmpty(group.getGroupStrategy())) {
            map.put("channelStrategy", group.getGroupStrategy());
            if ("1".equals(group.getGroupStrategy())) {
                map.put("pageSize", 10);
            } else {
                map.put("pageSize", 20);
            }

        } else {
            map.put("pageSize", 20);
        }

        if (!TextUtils.isEmpty(compLogicDataBean.topicId)) {
            map.put("topicId", compLogicDataBean.topicId);
            map.put("topicType", compLogicDataBean.topicType);
        }

        // 本地问政频道地理信息特殊处理
        if ("2062".equals(compLogicDataBean.channelId)) {

            String areaCode = SpUtils.getWenZhenChannelAreaCode();

            if (TextUtils.isEmpty(areaCode)) {
                if (!TextUtils.isEmpty(SpUtils.getProvinceCode())) {
                    map.put("provinceCode", SpUtils.getProvinceCode());
                }

                if (!TextUtils.isEmpty(SpUtils.getCityCode())) {
                    map.put("cityCode", SpUtils.getCityCode());
                }
                if (!TextUtils.isEmpty(SpUtils.getDistrictCode())) {
                    map.put("districtCode", SpUtils.getDistrictCode());
                }
            } else {

                String[] areaArray = areaCode.split("#");
                if (areaArray != null) {
                    String provinceCode = "";
                    String cityCode = "";
                    String districtCode = "";
                    int size = areaArray.length;
                    if (size > 0) {
                        provinceCode = areaArray[0];
                    }
                    if (size > 1) {
                        cityCode = areaArray[1];
                    }
                    if (size > 2) {
                        districtCode = areaArray[2];
                    }
                    if (!TextUtils.isEmpty(provinceCode)) {
                        map.put("provinceCode", provinceCode);
                    }

                    if (!TextUtils.isEmpty(cityCode)) {
                        map.put("cityCode", cityCode);
                    }
                    if (!TextUtils.isEmpty(districtCode)) {
                        map.put("districtCode", districtCode);
                    }
                }

            }
        } else {
            if (!TextUtils.isEmpty(SpUtils.getProvinceCode())) {
                map.put("provinceCode", SpUtils.getProvinceCode());
            } else {
//                  map.put("provinceCode", 340000);
            }

            if (!TextUtils.isEmpty(SpUtils.getCityCode())) {
                map.put("cityCode", SpUtils.getCityCode());
            } else {
//                 map.put("cityCode", 340100);
            }
            if (!TextUtils.isEmpty(SpUtils.getDistrictCode())) {
                map.put("districtCode", SpUtils.getDistrictCode());
            } else {
//                map.put("districtCode", 340103);
            }
        }
        return map;
    }


    /**
     * 获取页面楼层信息和关于楼层的信息流
     *
     * @param group
     */
    private void loadGroupData(@NonNull AbsGroup group, boolean useCache) {

        //使用缓存
        if (useCache) {
            loadLocalCompCacheData(group, group.getId());
            return;
        }
        if (compLogicDataBean.loadMore) {
            pageData.needRefresh = false;
            pageData.isLocalCache = false;
            pageData.pageInforRefresh = false;
        }
        mGetDataFinishTask.registerCondition(group);

        Map<String, Object> compParams = getCompParams(group);
        // 0:默认非推荐数据源；1：推荐楼层数据源
        int sourceInterfaceVale = 0;
        Observable<BaseResponse<GroupBean>> groupDataObservable;
        if (!TextUtils.isEmpty(group.getGroupStrategy()) && "1".equals(group.getGroupStrategy())) {
            //推荐
            sourceInterfaceVale = 1;
            groupDataObservable = getRetrofit().getRecGroupData(compParams);
        } else {
            //时间线
            groupDataObservable = getRetrofit().getGroupData(compParams);
        }
        // 0:默认非推荐数据源；1：推荐楼层数据源
        int finalSourceInterfaceVale = sourceInterfaceVale;
        //如果是v2接口已经合并了compInfo
        if (compLogicDataBean.useV2 ){
            if (null != pageData){
                GroupBean compInfo = pageData.getCompInfo();
                String md5 = pageData.getMd5();
                String fmd5 = pageData.getFmd5();
                MetaBean metaBean = new MetaBean();
                metaBean.setMd5(md5);
                metaBean.setFmd5(fmd5);
                /**
                 * 处理compInfo接口数据
                 */
                dealCompInfoDataSuccess(group, compInfo, metaBean, finalSourceInterfaceVale);
            }else {
                if (mListener != null) {
                    mListener.onPageDataFailed(0,"pageInfo is error");
                }
            }
            return;
        }
        request(groupDataObservable, new BaseObserver<GroupBean>() {

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

                if (mListener != null) {
                    mListener.onPageDataFailed(0,"compInfo is error");
                }

            }

            @Override
            protected void onSuccess(GroupBean groupBean) {

            }

            @Override
            protected void onSuccess(GroupBean groupBean, MetaBean metaBean, String msg, int code) {
                /**
                 * 处理compInfo接口数据
                 */
                dealCompInfoDataSuccess(group,groupBean,metaBean,finalSourceInterfaceVale);
            }


            @Override
            protected void _onError(String e) {

                dealCompInfoDataFail(e);
            }
        });
    }


    /**
     *处理compInfo接口数据
     */
    private void dealCompInfoDataSuccess(@NonNull AbsGroup group, GroupBean groupBean, MetaBean metaBean,int sourceInterfaceVale) {
        if (groupBean == null) {
            if (compLogicDataBean.loadMore) {
                pageData.totalCompSize = 0;
            } else {
                pageData.totalCompSize = pageData.totalCompSize + 0;
            }
            // 通知页面刷新
            if (group != null) {
                mGetDataFinishTask.onGetPartialDataFinish(group);
            }
            return;
        }
        //不是加载更多，首次，下拉，做降级处理
        if (!compLogicDataBean.loadMore){
            if (ArrayUtils.isEmpty(groupBean.getComps())){
                pageData.totalCompSize = pageData.totalCompSize + 0;
                // 通知页面刷新
                if (group != null) {
                    mGetDataFinishTask.onGetPartialDataFinish(group);
                }
                return;
            }
        }
        // 设置楼层接口来自哪个接口
        groupBean.setSourceInterfaceVal(sourceInterfaceVale);
        if (!compLogicDataBean.loadMore) {
            CacheData localCacheData = CacheData.getLocalCacheData(CacheData.compGroupInfoDataCacheKey + compLogicDataBean.pageId + group.getId());
            // 新旧数据md5值对比
            String dataMd5 = chacheDataAndNewDataContrastByMd5ToComp(localCacheData, metaBean, 0, false);
            // 保存缓存
            CacheData.saveDataToPreference(CacheData.compGroupInfoDataCacheKey + compLogicDataBean.pageId + group.getId(), groupBean, dataMd5);
        }

        if (group != null) {

            pageData.moreRefresh = compLogicDataBean.loadMore;
            // 整合comp对象
            groupCompDataParse(groupBean, group);
            // 通知完成数据请求
            mGetDataFinishTask.onGetPartialDataFinish(group);

        } else {
            mGetDataFinishTask.onGetPartialDataFinish(group);
        }
    }
    /**
     *处理compInfo接口数据失败的
     */
    private void dealCompInfoDataFail(String msg){
        // 专题和频道二级页面无需提示，会在页面中提示
        if (compLogicDataBean != null && compLogicDataBean.tipFlag) {
            ToastNightUtil.showShort(msg);
        }
        if (mListener != null) {
            mListener.onPageDataFailed(1,"compInfo is error");
        }
    }


    /**
     * 读取页面组件缓存数据-页面数据
     */
    public void loadLocalPageCacheData(String pageId) {
        CacheData pageCacheData = CacheData.getLocalCacheData(CacheData.comPageInfoCacheKey + pageId);
        if (pageCacheData != null && !StringUtils.isBlank(pageCacheData.getNetWorkData())) {
            String netWorkData = pageCacheData.getNetWorkData();
            PageBean pageBean = GsonUtils.fromJson(netWorkData, PageBean.class);
            if (pageBean == null || ArrayUtils.isEmpty(pageBean.getGroups())) {
                //没有缓存请求新数据
                getPageData(false, compLogicDataBean);
                return;
            }
            if (mListener != null) {
                mListener.onPageInforSuccess(pageBean);
            }
            pageBean.isLocalCache = true;
            callback(pageBean, true);
        } else {
            //没有缓存请求新数据
            getPageData(false, compLogicDataBean);
        }
    }


    /**
     * 楼层的组件卡缓存数据-卡片数据
     * compInfo 缓存数据
     */
    private void loadLocalCompCacheData(AbsGroup group, String groupId) {

        CacheData groupCacheData = CacheData.getLocalCacheData(CacheData.compGroupInfoDataCacheKey + compLogicDataBean.pageId + groupId);
        if (groupCacheData != null && !StringUtils.isBlank(groupCacheData.getNetWorkData())) {
            String netWorkData = groupCacheData.getNetWorkData();
            GroupBean groupBean = GsonUtils.fromJson(netWorkData, GroupBean.class);
            if (groupBean == null) {
                // 无缓存 compinfor信息直接调用接口
                loadGroupData(group, false);
                return;
            }
            mGetDataFinishTask.registerCondition(group);
            List<AbsGroup> groupsList = mPage.getGroups();
            int groupSize = groupsList.size();
            if (groupSize > 1) {
                // 读取缓存数据（组件可能配置动态接口，没有延迟机制无法获取到组件中存储的数据）
                Observable.timer(10, TimeUnit.MILLISECONDS)
                        .subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread())
                        .subscribe(a -> {

                            groupCompDataParse(groupBean, group);
                            // 通知页面刷新
                            mGetDataFinishTask.onGetPartialDataFinish(group);
                        });
            } else {

                groupCompDataParse(groupBean, group);
                // 通知页面刷新
                mGetDataFinishTask.onGetPartialDataFinish(group);
            }

        } else {
            // 无缓存 compinfor信息直接调用接口
            loadGroupData(group, false);
        }

    }


    /**
     * 初始化二次请求完成的监听器
     */
    private void initRequestConditionTask() {
        // 这里直接new
        mGetDataFinishTask = new PageDataFinishTask(1);
        mGetDataFinishTask.setPageDataFetcher(this);
    }

    /**
     * 检索所有一次页面请求获取的所有楼层的稿件和组件
     */
    public void retrieveAllGroupOfComp() {

        // 收集所有稿件compbean
        List<CompBean> compList = pageData.getRequestLayerCompList();
        if (ArrayUtils.isNotEmpty(compList)){
            int size = compList.size();
            if (size > 0) {

                CompBean preCompBean = null;// 上一个数据
                CompBean lastCompBean = pageData.getLastCompBean();// 上一次请求的最后一个组件或者稿件数据
                preCompBean = lastCompBean;

                for (int a = 0; a < size; a++) {
                    CompBean compBean = compList.get(a);
                    compBean.preCompBean = preCompBean;
                    int b = a + 1;
                    if (b < size) {
                        compBean.nextCompBean = compList.get(b);
                    }
                    preCompBean = compBean;
                }
                //Log.e("DDDDSSS", "retrieveAllGroupOfComp size=" + size);
                //记录页面已经展示的稿件和组件信息
                pageData.addNewPageCompData(compList);
            }
        }
    }

    /**
     * 处理所有楼层中compbean数据用来批查
     */
    protected void handlerAllCompDataBetchData() {
        if(pageData == null){
            return;
        }
        //1、第一次使用缓存进行批查;2、需要刷新进行批查
        if (pageData.moreRefresh || pageData.needRefresh || pageData.isLocalCache) {
            // 收集所有稿件compbean
            List<CompBean> compList = pageData.getRequestLayerCompList();
            if(ArrayUtils.isEmpty(compList)){
                return;
            }
            if(pageData.needRefresh || pageData.isLocalCache){
                setFirstPageCompList(compList);
            }
            if (compList != null && compList.size() > 0) {
                // 批查稿件相关参数
                betchQueryItemDy(compList, PageDataFetcher.this);
            }
        }else if(CompLogicDataBean.PULL_DOWN.equals(compLogicDataBean.loadStrategy)){
            List<CompBean> compList = getFirstPageCompList();
            if (compList != null && compList.size() > 0) {
                // 批查稿件相关参数
                betchQueryItemDy(compList, PageDataFetcher.this);
            }
        }

    }

    /**
     * 重置Page数据
     */
    protected void resetPage() {
        if (mPage == null) {
            return;
        }
        int groupIndex = -1;
        int sectionIndex = -1;
        for (int i = 0; i < mPage.getGroups().size(); i++) {
            AbsGroup group = mPage.getGroups().get(i);
            if (group == null) {
                continue;
            }
            for (int j = 0; j < group.getSections().size(); j++) {
                AbsSection section = group.getSections().get(j);
                if (section == null) {
                    continue;
                }
                // 专题tab分栏 PROGRAM_TAB_COL & Program_Tab_Col-01
                if (StringUtils.isEqual("Program_Tab_Col-01", section.getCompStyle())) {
                    groupIndex = i;
                    sectionIndex = j;
                    break;
                }
            }
        }
        if (sectionIndex == -1) {
            // 没有特殊样式
            return;
        }
        List<AbsGroup> tempGroups = mPage.getGroups();
        mPage.setGroups(new ArrayList<>());
        for (int i = 0; i < groupIndex; i++) {
            mPage.getGroups().add(tempGroups.get(i));
        }
        AbsGroup specialGroup = tempGroups.get(groupIndex);
        AbsSection specialSection = specialGroup.getSections().get(sectionIndex);
        for (int i = 0; i < sectionIndex; i++) {
            AbsGroup lastGroup = ArrayUtils.getListElement(mPage.getGroups(), groupIndex - 1);
            if (lastGroup == null) {
                break;
            }
            // 将同一个group里，特殊样式前面的样式，添加到前一个group里
            lastGroup.getSections().add(specialGroup.getSections().get(i));
        }
        // 特殊样式group里，只保留特殊样式，并塞值给特殊楼层字段
        specialGroup.getSections().clear();
        specialGroup.getSections().add(specialSection);
        mPage.setSpecialGroup(specialGroup);
    }

    private List<CompBean> getFirstPageCompList() {
        return firstPageCompList;
    }

    private void setFirstPageCompList(List<CompBean> firstPageCompList) {
        if(ArrayUtils.isEmpty(this.firstPageCompList)){
            this.firstPageCompList = new ArrayList<>();
        }else {
            this.firstPageCompList.clear();
        }
        this.firstPageCompList.addAll(firstPageCompList);
    }
}