import { CompDTO, ContentDTO, InteractDataDTO, LiveReviewDTO, LiveRoomDataBean, PageDTO, PageInfoDTO } from 'wdBean';
import { CompStyle, ContentConstants, ViewType } from 'wdConstant/Index';
import { CollectionUtils, DateTimeUtils, LazyDataSource, Logger, NetworkUtil, StringUtils, ToastUtils } from 'wdKit';
import { closeRefresh } from '../utils/PullDownRefresh';
import PageModel from './PageModel';
import PageViewModel from './PageViewModel';
import { promptAction } from '@kit.ArkUI';
import { CompAdvBean } from 'wdBean/src/main/ets/bean/adv/AdvsRuleBean';
import PageAdModel from './PageAdvModel';
import { ArrayList } from '@kit.ArkTS';
import { WDViewDefaultType } from '../components/view/EmptyComponent';
import { CompAdvMatInfoBean } from 'wdBean/src/main/ets/bean/adv/CompAdvInfoBean';
import { BaseDTO } from 'wdBean/src/main/ets/bean/component/BaseDTO';
import { viewBlogInsightIntentShare, ActionMode } from '../utils/InsightIntentShare'
import { common } from '@kit.AbilityKit';
import { CacheData } from 'wdNetwork/Index';
import { closeLoadMore } from '../utils/PullUpLoadMore';
import { webview } from '@kit.ArkWeb';
import { onlyWifiLoadImg } from '../utils/lazyloadImg';

const TAG = 'PageHelper';

// 本地的一行两图卡 style值
const OneRowDoubleColumnStyle = CompStyle.Card_Comp_Zh_Grid_Layout_02

const Normal_Page_Size = 20 // 常规每页数量

const Rec_Page_Size = 10 // 推荐每页数量

const SpecialComp: string[] = [CompStyle.Zh_Single_Column_03.toString()]

/**
 * 处理返回后的数据
 */
export class PageHelper {
  /**
   * 刷新数据
   */
  async refreshUI(pageModel: PageModel, pageAdvModel: PageAdModel) {
    let netStatus = NetworkUtil.isNetConnected()
    if (!netStatus) {
      ToastUtils.showToast('网络出小差了，请检查网络后重试', 1000)
      setTimeout(() => {
        this.refreshUIEnd(pageModel, false)
      }, 500)
      return
    }
    pageModel.loadStrategy = 2
    pageModel.pageTotalCompSize = 0;
    this.getPageInfo(pageModel, pageAdvModel)
  }

  private refreshUIEnd(pageModel: PageModel, isRefreshSuccess: boolean) {
    if (pageModel.loadStrategy != 2) {
      return
    }
    closeRefresh(pageModel, isRefreshSuccess)
  }

  /**
   * 分页加载
   */
  async loadMore(pageModel: PageModel) {
    let netStatus = NetworkUtil.isNetConnected()
    if (!netStatus) {
      ToastUtils.showToast('网络出小差了，请检查网络后重试', 1000)
      return
    }
    pageModel.loadStrategy = 3
    // 暂只支持comp分页加载，节目分页加载的得完善框架（如直播回看节目数据分页）
    this.compLoadMore(pageModel)
  }

  private loadMoreEnd(pageModel: PageModel) {
    closeLoadMore(pageModel)
  }

  /**
   * 进页面请求数据
   */
  async getInitCacheData(pageModel: PageModel, pageAdvModel: PageAdModel) {
   // Logger.debug(TAG, 'getInitCacheData')
    PageViewModel.getPageInfoCache(pageModel.pageId).then(pageInfo => {
     // Logger.debug(TAG, 'getInitCacheData back: ' + pageInfo)
      if (pageInfo == null) {
        return;
      }
      pageModel.pageInfo = pageInfo;
      pageModel.displayPageInfoMd5 = pageInfo.md5
      //解析页面挂角广告资源
      pageAdvModel.analysisAdvSource(pageInfo);
      this.parseGroup(pageModel, true, true)
    })
  }

  /**
   * 进页面请求数据
   */
  async getInitData(pageModel: PageModel, pageAdvModel: PageAdModel) {
    pageModel.loadStrategy = 1
    let netStatus = NetworkUtil.isNetConnected()
    if (netStatus) {
      this.getPageInfo(pageModel, pageAdvModel)
    } else if (pageModel.compList.size() > 0) {
      // 加载缓存数据了，不用无网络提示
    } else {
      pageModel.viewType = ViewType.EMPTY;
      pageModel.emptyType = WDViewDefaultType.WDViewDefaultType_NoNetwork;
    }
  }

  async getPageInfo(pageModel: PageModel, pageAdvModel: PageAdModel) {
    let adHasChanged = false;
    pageModel.currentPage = 1;
    pageModel.loadImg = await onlyWifiLoadImg();
    if (pageModel.pageType == 1) {
      PageViewModel.postThemeList(pageModel.currentPage, pageModel.pageSize, pageModel.extra).then((liveReviewDTO) => {
        if (liveReviewDTO == null || liveReviewDTO.list == null || liveReviewDTO.list.length == 0) {
          pageModel.viewType = ViewType.EMPTY;
          pageModel.emptyType = WDViewDefaultType.WDViewDefaultType_NoContent1;
          return;
        } else {
          pageModel.emptyType = WDViewDefaultType.WDViewDefaultType_Default
          //更新数据
          pageModel.compList.addItems(liveReviewDTO.list);
          this.refreshUIEnd(pageModel, true);
        }
      }).catch((err: string | Resource) => {
        promptAction.showToast({ message: err });
        this.refreshUIEnd(pageModel, false)
      })
    } else {
     // Logger.debug(TAG, 'getPageInfo')
      PageViewModel.getPageInfo(pageModel.pageId).then(pageInfo => {
      //  Logger.debug(TAG, 'getPageInfo back: ' + JSON.stringify(pageInfo))
        if (pageInfo == null) {
          pageModel.viewType = ViewType.EMPTY;
          pageModel.emptyType = WDViewDefaultType.WDViewDefaultType_NoContent1;
          this.refreshUIEnd(pageModel, false)
          return;
        }
        pageModel.emptyType = WDViewDefaultType.WDViewDefaultType_Default
        pageModel.pageInfo = pageInfo;
        if (pageInfo.md5 == pageModel.displayPageInfoMd5) {
          // 缓存一致，不解析
        //  Logger.debug(TAG, 'getPageInfo 与缓存一致，不解析广告。。。')
          adHasChanged = true;
        } else {
        //  Logger.debug(TAG, 'getPageInfo 要解析广告')
          if (pageModel.currentPage == 1) {
            // 保存缓存
            CacheData.saveCacheData(CacheData.comPageInfoCacheKey + pageModel.pageId, pageInfo, pageInfo.md5)
          }
          pageModel.displayPageInfoMd5 = pageInfo.md5
          //解析页面挂角广告资源
          pageAdvModel.analysisAdvSource(pageInfo);
          adHasChanged = false;
        }
       // Logger.debug(TAG, 'getPageInfo go on')
        this.parseGroup(pageModel, false, adHasChanged)
      }).catch((err:Error) => {
        this.refreshUIEnd(pageModel, false)
        if (this.isPageLoaded(pageModel)) {
          return
        }
        pageModel.viewType = ViewType.EMPTY;
        pageModel.emptyType = WDViewDefaultType.WDViewDefaultType_ContentFailed;
      })
    }
  }

  private isPageLoaded(pageModel: PageModel) {
    if (pageModel.compList.size() > 0) {
      return true
    }
    return false
  }

  /**
   * 解析信息流页面楼层数据
   * @param pageModel
   */
  async parseGroup(pageModel: PageModel, isCache: boolean, adHasChagned: boolean) {
    let pageInfo: PageInfoDTO = pageModel.pageInfo
    pageModel.groupList = []
    pageInfo.pageAdList = []
    pageInfo.oneRequestPageGroupCompList = new ArrayList()
    pageModel.groupList.push(...pageInfo.groups)
    for (const group of pageInfo.groups) {
      pageModel.isRecGroup = group.groupStrategy === 1;
      pageModel.groupId = group.id;
      if (pageModel.isRecGroup) {
        pageModel.pageSize = Rec_Page_Size
      } else {
        pageModel.pageSize = Normal_Page_Size
      }
      pageModel.groupData = group

      //Logger.error("ZZZXXXXX", '楼层id-start--》' + pageModel.groupId);
      let pageDto: PageDTO
      //Logger.debug(TAG, 'parseGroup isCache: ' + isCache)
      if (isCache) {
        pageDto = await PageViewModel.getPageGroupCacheData(pageModel.bizCopy()) as PageDTO
        pageModel.displayGroupInfoMd5 = pageDto.md5
        // pageModel.currentPage = 2
      } else {
        pageDto = await PageViewModel.getPageGroupCompData(pageModel.bizCopy()) as PageDTO
        //增加楼层数据异常判断条件
        if (pageDto.md5 == pageModel.displayGroupInfoMd5 || pageDto.compList == null || pageDto.compList.length === 0 ) {
         // Logger.debug(TAG, 'parseGroup cache load, return: ' + pageDto.md5)
          // 下拉刷新场景，数据没变，拦截刷新UI，重置相关参数
          if (pageModel.loadStrategy === 2) {
            // 缓存数据一致，不再刷新
            this.refreshUIEnd(pageModel, true)
            // 第一页不刷新，分页数据清除
            pageModel.hasMore = true
            this.deleteMorePage(pageModel)
            pageModel.pageTotalCompSize = pageModel.compList.size()
          }
          pageModel.currentPage++
          return
        }
        pageModel.displayGroupInfoMd5 = pageDto.md5
       // Logger.debug(TAG, 'parseGroup cache load, save: ' + pageDto.md5)
        // 保存缓存
        CacheData.saveCacheData(CacheData.compGroupInfoDataCacheKey + pageModel.pageId + pageModel.groupId, pageDto,
          pageDto.md5)
      }
     // Logger.debug(TAG, 'parseGroup go on')
      // await，确保groups接口顺序执行
      // let pageDto = page
      let index = pageInfo.groups.indexOf(group)

     // Logger.debug(TAG, 'yyyy parseGroup print')
      this.printComp(pageDto)
      // 解析楼层组件
      this.analysisPageGroupCompData(pageDto, pageInfo)

      // 最后一个楼层，特殊处理
      if (index == pageInfo.groups.length - 1) {
        // 检测楼层最后一个组件业务数据是否需要通过访问接口获取
        let comp: CompDTO = pageDto.compList[pageDto.compList.length - 1]
        // 直播回放，需要二次请求数据
        if (comp.compStyle == CompStyle.Zh_Grid_Layout_02) {
          pageInfo.lastCompSourceType = 1
          let listReviewDtoBean = await PageViewModel.getLiveReviewUrl(1, Normal_Page_Size) as LiveReviewDTO
          // 创建一行两图卡组件
          this.createDoubleColumComp(listReviewDtoBean, pageInfo)
        } else {
          pageInfo.lastCompSourceType = 0
        }
      }
    }

    /*
         收集页面所有楼层的组件信息，同步完成广告投放计算，异步完成稿件批查,
     */
    pageModel.pageTotalCompSize = pageInfo.oneRequestPageGroupCompList.length + pageModel.pageTotalCompSize
    // 处理页面广告数据，投放到页面的位置
    this.handlePageCompAdvPostion(pageInfo.oneRequestPageGroupCompList, pageModel, pageInfo.pageAdList);

    // 清空comp列表
    pageModel.compList.clear()
    //遍历所有组件和稿件数据 push到页面
    for (let element of pageInfo.oneRequestPageGroupCompList) {
      pageModel.compList.push(element)
    }

    // 批查互动数据
    this.allCompBatchRequest(pageInfo.oneRequestPageGroupCompList.convertToArray(), pageModel)
    // 提前预加载H5专题
    this.preloadH5Topic(pageInfo.oneRequestPageGroupCompList.convertToArray())
    // 记录第一页数量
    this.saveFirstPageEndIndex(pageModel)
    if (!isCache) {
      pageModel.currentPage++
    }
    pageModel.viewType = ViewType.LOADED
    this.refreshUIEnd(pageModel, true)

    if (pageModel.compList.isEmpty()) {
      // 没数据，展示空页面
      //Logger.debug(TAG, 'aboutToAppear, data response page ' + pageModel.pageId + ', comp list is empty.');
      pageModel.viewType = ViewType.EMPTY;
      pageModel.emptyType = WDViewDefaultType.WDViewDefaultType_NoContent1;

    }
  }

  /**
   *  解析页面的楼层数据
   * @param pageDto  楼层的组件信息
   * @param pageInfo 信息流页面信息
   * @param isLastGroup  pageDto信息是不是最后一个楼层
   */
  private async analysisPageGroupCompData(pageDto: PageDTO, pageInfo: PageInfoDTO) {

    if (pageDto && pageDto.compList && pageDto.compList.length > 0) {

      let pageCompList = this.factoryCompArray(pageDto.compList)
      // pageInfor 记录
      pageCompList.forEach((comp: CompDTO) => {
        pageInfo.oneRequestPageGroupCompList.add(comp)
      })

      // pageInfor 记录广告
      if (pageDto.compAdList != null) {
        pageInfo.pageAdList.push(...pageDto.compAdList)
      }
      // TODO 待删除
    //  Logger.debug(TAG, 'yyyy analysisPageGroupCompData size, '+pageInfo?.oneRequestPageGroupCompList?.length)
    }

  }


  /**
   * comp加载更多，分页加载
   */
  private compLoadMore(pageModel: PageModel) {
    //聚合页
    if (pageModel.pageType == 1) {
      PageViewModel.postThemeList(pageModel.currentPage, pageModel.pageSize, pageModel.extra).then((liveReviewDTO) => {
        this.loadMoreEnd(pageModel)
        if (liveReviewDTO == null || liveReviewDTO.list == null || liveReviewDTO.list.length == 0) {
          pageModel.hasMore = false;
          return;
        } else {
          //更新数据
          pageModel.compList.addItems(liveReviewDTO.list);
          // 直接认为有分页，一直加载分页。直到没有数据，再停止
          pageModel.currentPage++;
          pageModel.hasMore = true;
          pageModel.pageTotalCompSize = liveReviewDTO.list.length + pageModel.pageTotalCompSize
        }
      }).catch((err: string | Resource) => {
        promptAction.showToast({ message: err });
        this.loadMoreEnd(pageModel)
      })
    } else {

      if (pageModel.pageInfo.lastCompSourceType == 1) {
        // 加载更多 走  直播回看接口
        this.getLiveReviewData(pageModel, pageModel.pageInfo)

      } else {
        // 默认加载更多走 楼层接口
        PageViewModel.getPageGroupCompData(pageModel.bizCopy())
          .then((data: PageDTO) => {
            this.loadMoreEnd(pageModel)
            if (data == null || data.compList == null || data.compList.length == 0) {
              pageModel.hasMore = false;
            } else {
              // 直接认为有分页，一直加载分页。直到没有数据，再停止
              pageModel.currentPage++;
              pageModel.hasMore = true;

             // Logger.debug(TAG, 'yyyy compLoadMore print')
              this.printComp(data)
              //移除音频 和 活动
              this.loadMorePageComp(pageModel, data)
              // 参与批查
              this.allCompBatchRequest(data.compList, pageModel)
              // 提前预加载H5专题
              this.preloadH5Topic(data.compList)
            }
          }).catch((err: string | Resource) => {
          promptAction.showToast({ message: err });
          this.loadMoreEnd(pageModel)
        })
      }
    }
  }


  /**
   * 加载更多页面组件和稿件信息
   */
  private loadMorePageComp(pageModel: PageModel, pageDto: PageDTO) {

    let pageCompList = this.factoryCompArray(pageDto.compList) // 收集页面组件、稿件和本地组件容器

    // pageInfor 记录
    pageModel.pageInfo.oneRequestPageGroupCompList.clear()
    pageCompList.forEach((comp: CompDTO) => {
      pageModel.pageInfo.oneRequestPageGroupCompList.add(comp)
    })
    // TODO 待删除
   // Logger.debug(TAG, 'yyyy loadMorePageComp size, ' + pageModel.pageInfo.oneRequestPageGroupCompList?.length)

    // 记录
    pageModel.pageTotalCompSize = pageCompList.length + pageModel.pageTotalCompSize
    // 处理页面广告数据，投放到页面的位置
    this.handlePageCompAdvPostion(pageCompList, pageModel, pageDto.compAdList);

    //遍历所有组件和稿件数据 push到页面
    for (let element of pageCompList) {
      pageModel.compList.push(element)
    }

  }

  /**
   *  加工 组件数组信息
   * @param compList
   * @returns
   */
  private factoryCompArray(compList: CompDTO[]): ArrayList<CompDTO> {
    let pageCompList: ArrayList<CompDTO> = new ArrayList() // 收集页面组件、稿件和本地组件容器
    let newCompList = this.createSpecialComp(compList)
    newCompList.forEach((element: CompDTO) => {
      let contentInfo: ContentDTO = CollectionUtils.getElement(element.operDataList, 0);
      //移除音频 和 活动
      if (contentInfo && (contentInfo.objectType === '13' || contentInfo.objectType === '3')) {
        //Logger.debug(TAG, 'getGroupData 移除音频 和 活动');
      } else {
        // 暂时屏蔽活动和音频详情入口
        if (element.operDataList[0]?.objectType === '3' || element.operDataList[0]?.objectType === '13') {
        } else {
          if (element.name == "月度排行卡") {

          } else {
            pageCompList.add(CompDTO.createNewsBean(element))
          }
        }
      }

    })

    return pageCompList
  }

  /**
   * 竖直方向list，将数据拆出来，组装成comp
   */
  private createSpecialComp(compList: CompDTO[]): CompDTO[] {
    if (!compList) {
      return compList
    }
    let tmpList: CompDTO[] = []
    compList.forEach((value, index) => {
      if (SpecialComp.includes(value.compStyle)) {
        let list = value.operDataList
        if (list) {
          if (list.length == 1) {
            tmpList.push(value)
          } else {
            list.forEach((content) => {
              let newComp = CompDTO.createNewsBean(value)
              newComp.operDataList = []
              // 特殊样式，comp只保留一个content，多余的一一拆成新的comp
              newComp.operDataList.push(content)
              tmpList.push(newComp)
            })
          }
        } else {
          tmpList.push(value)
        }
      } else {
        tmpList.push(value)
      }
    })

    // 重新赋值，将contentList拆出来了。
    return tmpList
  }

  /**
   *  信息流页面，所有稿件需要参与批查，如 批查评论、批查关注状态等接口
   * @param compList
   * @param pageModel
   */
  private allCompBatchRequest(compList: CompDTO[], pageModel: PageModel) {

    // 批查人数
    PageViewModel.getInteractData(compList).then((data: InteractDataDTO[]) => {
      // 刷新，替换所有数据
      this.resetInteract(data, pageModel.compList)
      if (pageModel?.channelId === '2001' || pageModel?.channelId === '2002') {
        //首页节目将来时意图上报，只上报热点和推荐频道下的节目
        let context = getContext(this) as common.UIAbilityContext;
        viewBlogInsightIntentShare(context, pageModel?.channelId, compList, ActionMode.EXPECTED)
      }
    })

    // 批查直播观看人数
    this.getLiveRoomDataInfo(compList)
    //


    // 测试数据
    // setTimeout(() => {
    //   let index = 1
    //   let comp = pageModel.compList.getData(index) as CompDTO
    //   comp.hasMore = 0
    //   //comp.operDataList[0].newsTitle = '测试111'
    //   let con :InteractDataDTO = new InteractDataDTO;
    //   con.commentNum=1000
    //   comp.operDataList[0].interactData = con
    //   Logger.debug("ZZZXXXXX",
    //     "-----setTimeout--------->"  + comp.hasMore)
    // }, 4 * 1000)
  }

  /**
   *  预加载H5专题
   * @param compList
   */
  private preloadH5Topic(compList: CompDTO[]) {

    compList.forEach((comp) => {
      comp.operDataList.forEach((program) => {
        if (program.objectType != ContentConstants.TYPE_SPECIAL_TOPIC) {
          return
        }
        if (program.objectLevel == "22" || program.objectLevel == "25") {  // 音频专题 和 早晚报专题
          return
        }
        if (program.linkUrl.length > 0) {
          Logger.debug(TAG, "预加载H5专题link: " + program.linkUrl)
          webview.WebviewController.prepareForPageLoad(program.linkUrl, true, 2)
        }
      })
    })
  }

  /**
   *  直播回看的批查数据
   * @param list
   * @param compList
   */
  private getLiveRoomDataInfo(compList: CompDTO[]) {

    let list: ContentDTO[] = []
    compList.forEach((comp: CompDTO) => {
      if (comp.compStyle == OneRowDoubleColumnStyle) {
        list.push(...comp.operDataList)
      }
    })
    let time = DateTimeUtils.getTimeStamp().toString()

    let reserveIds = this.getLiveDetailIds(list)

    PageViewModel.getLiveRoomBatchInfo(reserveIds).then((result) => {
      if (result && result.length > 0) {
        result.forEach((bean: LiveRoomDataBean) => {
          for (let item of list) {
            if (item.objectId == bean.liveId.toString()) {
              item.liveRoomDataBean = bean
              outer: for (let compBean of compList) {
                for (let contentBean of compBean.operDataList) {
                  if (contentBean === item) {
                    compBean.timestamp = time
                    break outer
                  }
                }
              }
              break
            }
          }
        })
      }
    }).catch(() => {
    })
  }

  /**
   * 获取直播详情id入参
   * @param list
   * @returns
   */
  private getLiveDetailIds(list: ContentDTO[]): string {
    let idList: string[] = []
    list.forEach(item => {
      idList.push(item.objectId)
    });
    return idList.join(',')
  }

  /**
   * 刷新互动数据到compList
   * @param interact 批查互动数据结果
   * @param compList comp list
   */
  private resetInteract(interact: InteractDataDTO[], compList: LazyDataSource<BaseDTO>) {
    if (interact == null || interact.length == 0) {
      return
    }
    let time = DateTimeUtils.getTimeStamp().toString()
    interact.forEach((interactData) => {
      let id = interactData.contentId;
      outer: for (let i = 0; i < compList.totalCount(); i++) {
        let comp = compList.getData(i) as CompDTO;
        if (comp == null || comp.operDataList == null || comp.operDataList.length == 0) {
          continue;
        }
        for (let j = 0; j < comp.operDataList.length; j++) {
          let content = comp.operDataList[j];
          if (content == null) {
            continue;
          }
          if (id == content.objectId) {
            content.interactData = interactData;
            comp.timestamp = time
            break outer;
          }
        }
      }
    })
  }


  /**
   *   处理页面中的广告组件信息
   * @param pageDto
   */
  private handlePageCompAdvPostion(pageCompList: ArrayList<CompDTO>, pageModel: PageModel, compAdList: CompAdvBean[]) {

    let compAdvList = compAdList

    let flag = true;
    if (compAdvList == null) {
      flag = false
    }
    if (compAdvList.length == 0) {
      flag = false
    }

    let pageCompSize = pageCompList.length // 信息流组件业务数量
    //  console.error("ZZZXXXXX", " start--->" + pageCompSize);
    if (pageCompSize == 0) {
      flag = false
    }

    if (flag) {
      let bannerAdvIndex = 0; // banner组件展示数据投放
      let layoutAdvIndex = 0; //稿件投放统计
      // 升序排序
      compAdvList.sort((a: CompAdvBean, b: CompAdvBean) => a.slotInfo.position - b.slotInfo.position)
      //  console.error("ZZZXXXXX", " 排序后的广告--->" + JSON.stringify(compAdvList));
      //当前日期
      let serverTimeLong: number = DateTimeUtils.getTimeStamp();
      for (let advBean of compAdvList) {
        let slotInfo = advBean.slotInfo

        if (slotInfo != null) {
          // 广告有效日期
          let startLong = advBean.startTime;
          let endLong = advBean.endTime;
          //符合开始时间和结束时间要求
          if (serverTimeLong >= startLong && serverTimeLong <= endLong) {

            let matInfo = advBean.matInfo
            if (matInfo == null) {
              continue
            }

            let advSubType = matInfo.advSubType

            // 插入轮播组件的广告
            if (4 == advSubType) {

              let position = slotInfo.position - 1;
              // 检测newCompList 集合中是否有轮播组件资源
              let adCompId = slotInfo.compId;
              if (!StringUtils.isEmpty(adCompId)) {
                for (let compBean of pageCompList) {
                  if (StringUtils.isEmpty(compBean.id)) {
                    continue
                  }
                  let compId = compBean.id.toString();
                  //匹配组件
                  if (adCompId == compId) {
                    // 运营位数据
                    let dataList = compBean.operDataList;
                    if (dataList != null) {

                      // 数组转成 ArrayList
                      let changeArrayList = (dataList: ContentDTO[]) => {
                        let compOperData: ArrayList<ContentDTO> = new ArrayList()
                        for (let dataListBean of dataList) {
                          compOperData.add(dataListBean)
                        }
                        return compOperData
                      }

                      let compOperData = changeArrayList(dataList)

                      // 轮播组件广告数据转 业务信息
                      let changeContentDTO = (matInfo: CompAdvMatInfoBean) => {
                        let advContentBean: ContentDTO = new ContentDTO();
                        advContentBean.newsTitle = matInfo.advTitle
                        advContentBean.objectType = matInfo.advType == "0" ? matInfo.advType.toString() : "4"
                        advContentBean.coverUrl = matInfo.matImageUrl[0]
                        advContentBean.linkUrl = matInfo.linkUrl
                        advContentBean.openType = matInfo.linkType
                        advContentBean.corner = ''
                        return advContentBean
                      }
                      let advContentBean = changeContentDTO(matInfo)

                      let dataListSize = dataList.length;
                      if (position < dataListSize) {
                        //dataList.add(position + bannerAdvIndex, advContentBean);
                        compOperData.insert(advContentBean, position + bannerAdvIndex)
                      } else {
                        compOperData.add(advContentBean);
                      }
                      bannerAdvIndex = bannerAdvIndex + 1;

                      // ArrayList转成 数组
                      compBean.operDataList = compOperData.convertToArray()
                    }
                  }
                }
              }

            } else {


              let advPosition = slotInfo.position //广告位置,从1开始
              // 页面的comp总数 - 这次请求的comp总数 = 剩余comp总数
              advPosition = advPosition - 1

              let a = pageModel.pageTotalCompSize - pageCompSize
              if (advPosition <= pageModel.pageTotalCompSize && advPosition >= a) {

                let b = advPosition - a;
                //  console.error('ZZZXXXXX', matInfo.advSubType + '-------------' + matInfo.advTitle + "  " + advPosition + "  " + a + "  " + b)
                if (b <= pageCompSize && b >= 0) {
                  // 创建广告稿件
                  let advComp: CompDTO = new CompDTO;
                  advComp.compStyle = CompStyle.Card_Comp_Adv
                  advComp.matInfo = matInfo

                  if (pageCompSize == slotInfo.position) {
                    pageCompList.add(advComp)
                  } else {
                    pageCompList.insert(advComp, b + layoutAdvIndex)
                  }
                  matInfo.originalPostion = pageCompList.getIndexOf(advComp)

                  layoutAdvIndex = layoutAdvIndex + 1;

                }
              }
            }
          }
        }
      }

    }
    // console.error("ZZZXXXXX", " end--->" + pageCompList.length);
  }


  /**
   * 获取直播回看数据
   */
  private async getLiveReviewData(pageModel: PageModel, pageInfo: PageInfoDTO) {

    let currentPage = pageModel.currentPage
    let pageSize = Normal_Page_Size

    PageViewModel.getLiveReviewUrl(currentPage, pageSize).then((liveReviewDTO) => {
      this.loadMoreEnd(pageModel)
      if (liveReviewDTO == null || liveReviewDTO.list == null || liveReviewDTO.list.length == 0) {
        pageModel.hasMore = false;
      } else {

        pageInfo.oneRequestPageGroupCompList.clear()
        // 直接认为有分页，一直加载分页。直到没有数据，再停止
        pageModel.currentPage++;
        pageModel.hasMore = true;

        let haveMoveContent = false
        //获取当前页面最后一个组件
        let lastIndex = pageModel.compList.totalCount() - 1
        let lastComp = pageModel.compList.getData(lastIndex) as CompDTO
        // 一行两图卡，需要从奇数 补齐成偶数内容
        if (lastComp.compStyle == OneRowDoubleColumnStyle) {

          let operLength = lastComp.operDataList.length
          // 页面的最后一个组件的业务数据是奇数，需要从获取更多的业务数据中补一个数据
          if (operLength === 1) {
            haveMoveContent = true
            lastComp.operDataList.push(liveReviewDTO.list[0])
            // 更新某个组件
            pageModel.compList.updateItem(lastComp, lastIndex)
            // 移走新获取的数据中第一条数据
            liveReviewDTO.list.splice(0, 1)
          }
        }
        // 创建本地一行两图卡
        this.createDoubleColumComp(liveReviewDTO, pageInfo)
        // 统计页面的总的组件和稿件数量
        pageModel.pageTotalCompSize = pageInfo.oneRequestPageGroupCompList.length + pageModel.pageTotalCompSize
        //遍历所有组件和稿件数据 push到页面
        for (let element of pageInfo.oneRequestPageGroupCompList) {
          pageModel.compList.push(element)
        }

        // 批查直播观看人数
        if (haveMoveContent) {
          // 把当前获取到的直播回看数据
          pageInfo.oneRequestPageGroupCompList.add(lastComp)
        }

        this.getLiveRoomDataInfo(pageInfo.oneRequestPageGroupCompList.convertToArray())

      }
    }).catch((err: string | Resource) => {
      if(err != "resDTO is empty"){
        promptAction.showToast({ message: err });
      }
      this.loadMoreEnd(pageModel)
    })
  }

  /**
   * 创建一行两图卡 自定义的业务稿件
   * @param listReviewDtoBean
   * @param pageInfo
   */
  private createDoubleColumComp(listReviewDtoBean: LiveReviewDTO, pageInfo: PageInfoDTO, test?: boolean) {
    /*
       两个业务 内容  配置一个comp
     */
    let length = listReviewDtoBean.list.length

    // if (test) {
    //   // 偶数变成奇数
    //   if (length % 2 === 0) {
    //     listReviewDtoBean.list.splice(length - 1, 1)
    //     length = listReviewDtoBean.list.length
    //   }
    // }

    for (let i = 0; i < length; i = i + 2) {
      let sliceArray: ContentDTO[]
      let j = i + 2

      if (j < length) {
        sliceArray = listReviewDtoBean.list.slice(i, j)
      } else {
        sliceArray = listReviewDtoBean.list.slice(i)
      }
      // 创建一行两图卡 自定义的业务稿件
      let doubleColumnLiveReviewComp = new CompDTO()
      doubleColumnLiveReviewComp.compStyle = OneRowDoubleColumnStyle
      let operDataList: ContentDTO[] = sliceArray
      doubleColumnLiveReviewComp.operDataList = operDataList
      pageInfo.oneRequestPageGroupCompList.add(doubleColumnLiveReviewComp)
    }

  }

  saveFirstPageEndIndex(pageModel: PageModel) {
    pageModel.firstPageEndIndex = pageModel.compList.size() - 1
  }

  static updateFirstPageEndIndex(pageModel: PageModel, isDel: boolean, index: number) {
    if (index > pageModel.firstPageEndIndex) {
      return
    }
    // 这里默认删除、添加都是一条一条处理
    let count = 1
    let endIndex = pageModel.firstPageEndIndex
    if (isDel) {
      // 第一页里删除
      let offset = Math.min(endIndex - index, count)
      endIndex = endIndex - offset
    } else {
      // 第一页里添加
      endIndex = endIndex + count
    }
    pageModel.firstPageEndIndex = endIndex
  }

  /**
   * 删除分页数据，保留第一页的数据。（下拉刷新场景用到）
   */
  deleteMorePage(pageModel: PageModel) {
    //Logger.debug(TAG, 'deleteMorePage endindex: ' + pageModel.firstPageEndIndex)
    if (pageModel.firstPageEndIndex < 0) {
      return
    }
    // 从第二页开始删
    pageModel.compList.deleteItems(pageModel.firstPageEndIndex + 1)
  }

  /**
   * 临时打印comp相关信息，用于问题定位。TODO 待删除
   */
  private printComp(pageDto: PageDTO) {
    //Logger.debug(TAG, 'yyyy printComp pageDto.compList.size: ' + pageDto?.compList?.length)
    new Promise<void>(() => {
      let tmpCompList: CompDTO[] = Array.from(pageDto.compList)
      tmpCompList.forEach((v, k) => {
        if (v && v.operDataList) {
          Logger.warn(TAG, 'yyyy printComp comp forEach, ' + v.compStyle)
          v.operDataList.forEach((cv, ci) => {
            if (cv) {
            //  Logger.debug(TAG, 'yyyy printComp ContentDTO print, ' + v.compStyle)
             // Logger.debug(TAG, 'yyyy printComp ContentDTO xxxx newsTitle, ' + cv.newsTitle)
            } else {
             // Logger.warn(TAG, 'yyyy printComp ContentDTO is null, ' + v.compStyle)
            }
          })
        } else {
          Logger.warn(TAG, 'yyyy printComp comp is null or operDataList is empty, ' + v?.compStyle)
        }
      })
    })
  }
}


let pageHelper = new PageHelper();

export default pageHelper as PageHelper;