/**
 * Page数据获取管理及相关业务逻辑处理
 */
import { PageDTO } from '../bean/PageDTO';
import { LayoutService } from '../service/LayoutService';
import { PageListener } from './PageListener';
import { WDGroup } from './WDGroup';
import List from '@ohos.util.List';
import { LayoutCallback } from '../service/LayoutCallback';
import { GroupDTO } from '../bean/GroupDTO';
import { ItemBean } from '../bean/ItemBean';
import { ItemDTO } from '../bean/ItemDTO';
import { CompStyle } from '../enum/CompStyle';
import { WDComp } from './WDComp';
import { IGroupFilter } from './filter/IGroupFilter';

export class WDPage {
  private layoutService: LayoutService;
  private listener?: PageListener;
  private pageId: string;
  private pageDTO?: PageDTO;
  private groups: List<WDGroup> = new List();
  private initParams: Map<string, Object> = new Map<string, Object>();
  private groupFilters: IGroupFilter[] = [];
  /**
   * 标记是否在加载数据
   */
  private isLoading: boolean = false;
  /**
   * 页面顶部搜索提示文本
   */
  private searchText?: string;

  constructor(pageId: string, initParams: Map<string, Object>, groupFilters: IGroupFilter[]) {
    this.pageId = pageId;
    this.initParams = initParams;
    this.groupFilters = groupFilters;
    this.layoutService = new LayoutService();
  }

  public setListener(listener: PageListener): void {
    this.listener = listener;
  }

  /**
   * 请求Page数据
   * @param isRefresh 是否为刷新
   */
  public sendRequest(isRefresh: boolean) {
    // TODO: 由于PageID在构造函数中传入，所以这里的参数不需要PageID。
    // TODO: 通过LayoutService获取Page数据
    if (this.isLoading) {
      return;
    }
    this.isLoading = true;
    if (this.layoutService) {
      let callback: LayoutCallback<PageDTO> = {
        onSuccess: (pageDTO: PageDTO): void => {
          this.isLoading = false;
          this.parsePage(pageDTO);
          if (this.listener) {
            this.listener.onPageLoaded(this);
          }
          return
        },
        onFailed: (code: number, message: string): void => {
          // todo:
          this.isLoading = false;
          if (this.listener) {
            this.listener.onPageFailed(this)
          }
          return
        }
      };
      this.layoutService.getPage(this.pageId, isRefresh, callback);
    }
  }

  /**
   * 解析Page数据
   * @param pageDTO Page数据对象
   */
  private parsePage(pageDTO: PageDTO) {
    // TODO: 调用initGroup初始化Group对象
    this.pageDTO = pageDTO;
    if (pageDTO.groups) {
      this.initGroup(pageDTO.groups, this.initParams);
    }

    if (pageDTO.pageSearchText && pageDTO.pageSearchText.length > 0) {
      this.searchText = pageDTO.pageSearchText[0];
    } else {
      // 设置searchText为空字符串表示page接口已经返回
      this.searchText = "";
    }
  }

  public getPageDTO(): PageDTO {
    return this.pageDTO ?? {} as PageDTO;
  }

  public getSearchText(): string | undefined {
    return this.searchText;
  }

  /**
   * 初始化WDGroup对象
   * @param groupList Group数据对象列表
   */
  private initGroup(groupList: GroupDTO[], initParams: Map<string, Object>) {
    if (groupList == null || groupList.length == 0) {
      return;
    }
    // TODO：遍历初始化Group
    for (let num = 0; num < groupList.length; num++) {
      let groupBean: GroupDTO = groupList[num];
      if (!this.filterGroup(groupBean)) {
        continue;
      }
      let wdGroup: WDGroup = new WDGroup(this, groupBean, initParams);
      if (!this.filterGroupAfterFilterComp(wdGroup)) {
        continue;
      }
      this.groups.add(wdGroup);
    }
  }

  /**
   * 本楼层是否被过滤掉
   * @param groupBean 待过滤的GroupBean数据
   * @returns 保留此项数据:返回true;否则(舍弃此项数据),返回false;
   */
  private filterGroup(groupBean: GroupDTO): boolean {
    if (this.groupFilters == null || this.groupFilters.length <= 0) {
      return true;
    }

    for (let index = 0; index < this.groupFilters.length; index++) {
      let filter = this.groupFilters[index];
      if (!filter.filter(groupBean)) {
        return false;
      }
    }
    return true;
  }

  /**
   * 第二次过滤group/业务逻辑过滤/不合理过滤/本楼层是否被过滤掉
   * @param WDGroup 待过滤的WDGroup数据
   * @returns 保留此项数据:返回true;否则(舍弃此项数据),返回false;
   */
  private filterGroupAfterFilterComp(wdGroup: WDGroup): boolean {
    if (!wdGroup || wdGroup.getCompList().length == 0) {
      // 本楼层所有组件已被过滤掉
      return false
    }

    let wdComp: WDComp<ItemBean, ItemDTO> = wdGroup.getCompList().get(0)
    let compStyle: string = wdComp.getCompStyle()
    if (wdGroup.getCompList().length == 1) { // 楼层仅包含一个组件数据
      if (compStyle === CompStyle.LABEL_01) { // 即一个楼层仅包含LABEL_01,其他的都被过滤掉时，则这个LABEL_01也要过滤掉
        return false
      }
      if (compStyle === CompStyle.NAV_BAR_01) { //
        // http://display-sc.miguvideo.com/display/v4/static/965823946cac4bf3b78c7b99b76b728b
        // 目前会配置3个顶导楼层，取第2楼顶导
        if (wdGroup.getParent().getGroups().length > 1) { // 若配置了多个group顶导：则过滤掉max不等于-1的group
          if (wdGroup.getGroupDTO().androidVersion) {
            if (wdGroup.getGroupDTO().androidVersion?.max != '-1') { // 把限制版本的顶导过滤掉 // todo:
              //  if (WDComp.getCompDTO()?.androidVersion?.max != '-1') { // 把限制版本的顶导过滤掉 // todo:
              return false
            }
          }
        }
      }
    } else { // 楼层包含多个组件数据
      if (compStyle !== CompStyle.LABEL_01) {
        // 但本楼层第一个组件不是label
        // return false // 配置的可能是LABEL-04
      }
    }
    return true;
  }

  /**
   * 获取page中所有的group
   */
  public getGroups(): List<WDGroup> {
    return this.groups;
  }

  public getId(): string {
    return this.pageId ?? "";
  }

  public notifyPageLayoutLoaded(): void {
    if (this.listener) {
      this.listener.onPageLoaded(this);

    }
  }

  public notifyPageLayoutFailed(): void {
    if (this.listener) {
      this.listener.onPageFailed(this)
    }
  }

  public notifyGroupDataLoaded(group: WDGroup): void {
    if (this.listener) {
      this.listener.onGroupLoaded(this, group)
    }
  }

  public notifyGroupDataFailed(group: WDGroup): void {
    if (this.listener) {
      this.listener.onGroupFailed(this, group);
    }
  }

  public notifyCompDataLoaded(comp: WDComp<ItemBean, ItemDTO>): void {
    if (this.listener) {
      this.listener.onCompLoaded(this, comp.getParent(), comp)
    }
  }

  public notifyCompDataFailed(comp: WDComp<ItemBean, ItemDTO>): void {
    if (this.listener) {
      this.listener.onCompFailed(this, comp.getParent(), comp)
    }
  }

  /**
   * Desc: 加载count个未加载的group
   * @return 如果有加载未加载的group或者有正在加载数据的group则返回true，否则返回false
   */
  public loadNextGroups(count: number, isRefresh: boolean): boolean {
    let cnt: number = count;
    if (this.groups == null || this.groups.isEmpty()) {
      return false;
    }
    let hasLoading: boolean = false;
    let hasLongFeed: boolean = false;

    for (let index = 0; index < this.groups.length; index = index + 1) {
      let group = this.groups.get(index);
      if (count <= 0) {
        return true;
      }
      if (group.shouldLoadData()) {
        group.sendRequest(isRefresh);
        --count;
      } else if (!hasLoading && group.isGroupLoading()) {
        hasLoading = true;
      }

      group.loadMore();

      // hasLongFeed = group.getLongFeedComp() != null;
      hasLongFeed = false
    }
    return hasLoading || cnt != count || hasLongFeed;
  }
}