import { GroupDTO } from '../bean/GroupDTO';
import { LayoutService } from '../service/LayoutService';
import List from '@ohos.util.List';
import { ItemBean } from '../bean/ItemBean';
import { ItemDTO } from '../bean/ItemDTO';
import { WDComp } from './WDComp';
import { WDPage } from './WDPage';
import { NetDataStatusType } from '../enum/NetDataStatusType';
import { LayoutCallback } from '../service/LayoutCallback';
import { GroupDataDTO } from '../bean/GroupDataDTO';
import { CompDataDTO } from '../bean/CompDataDTO';
import { CompDTO } from '../bean/CompDTO';
import { LabelComp } from './LabelComp';
import { CompType } from '../enum/CompType';
import { CompFilterUtil } from '../utils/CompFilterUtil';
import { ButtonComp } from './ButtonComp';
import { CompStyle } from '../enum/CompStyle';
import { TabBar01Comp } from './TabBar01Comp';
import { TabBar22Comp } from './TabBar22Comp';
import { ProgrammeComp } from './ProgrammeComp';
import { FlowComp } from './FlowComp';

const TAG = 'WDGroup';

/**
 * Group数据获取管理及相关业务逻辑处理
 */
export class WDGroup {
  private layoutService: LayoutService;
  /**
   * group配置定义实体
   */
  private groupDTO: GroupDTO;
  protected parent: WDPage;
  private initParams: Map<string, Object> = new Map<string, Object>();
  /**
   * 所有的comp列表
   */
  private comps: List<WDComp<ItemBean, ItemDTO>> = new List();
  /**
   * 需要合并请求的comp列表
   */
  private teamworkCompList: List<WDComp<ItemBean, ItemDTO>>;
  /**
   * 标记是否包含需要合并请求Comp的Group
   */
  private isTeamwork: boolean = false;
  /**
   * 标记是否需要加载数据，当所有comp都是独立加载数据则group无需再加载数据
   */
  private needLoadData: boolean = false;
  // /**
  //  * 标记是否已加载数据
  //  */
  // private isLoaded: boolean = false;
  // /**
  //  * 标记是否在加载数据
  //  */
  // private isLoading: boolean = false;
  // 当前group数据加载状态
  protected status: number = NetDataStatusType.INITIAL;
  // private IWDCompParser parser;
  // private isLongFeed: boolean = false;
  // private WDComp feedWDComp;
  // private WDComp longWDComp;
  private displayCount: number = 0;
  private hasMoreGroupData: boolean = false;
  // private isLongFeedLoaded: boolean = false;
  // private isLongFeedLoading: boolean = false;
  /**
   * 标记是否为黑白化
   */
  private isGrayMode: boolean = false;

  /**
   * 构造函数
   *
   * @param group 发出请求的WDGroup实例
   */
  constructor(page: WDPage, groupDTO: GroupDTO, initParams: Map<string, Object>) {
    this.parent = page;
    this.groupDTO = groupDTO;
    this.initParams = initParams;
    this.layoutService = new LayoutService();
    this.comps = new List();
    this.teamworkCompList = new List();

    if (groupDTO) {
      // if (page != null && page.getTeamworkGroupIds() != null) {
      //   isTeamwork = page.getTeamworkGroupIds().contains(group.id);
      // }
      // setId(group.id);
      this.initComp(groupDTO.components, initParams);
    }
  }

  public getParent(): WDPage {
    return this.parent;
  }

  public getGroupDTO(): GroupDTO {
    return this.groupDTO;
  }

  /**
   * 获取group中的所有Comp
   */
  public getCompList(): List<WDComp<ItemBean, ItemDTO>> {
    return this.comps;
  }

  /**
   * 请求Group数据
   * @param isRefresh 是否为刷新
   */
  public sendRequest(isRefresh: boolean) {
    // TODO: 通过LayoutService获取Group数据
    if (this.status == NetDataStatusType.LOADING) {
      return;
    }

    // 当group需要请求网络加载数据时
    if (this.needLoadData) {
      if (this.layoutService) {
        let callback: LayoutCallback<GroupDataDTO> = {
          onSuccess: (groupDataDTO: GroupDataDTO): void => {
            // 包含分众数据，请求分众页面
            if (groupDataDTO.branchMark) {
              // this.loadDynamicGroup(pageId, bean, isRefresh, layoutCallback);
            } else {
              this.status = NetDataStatusType.LOADED
              this.parseGroup(groupDataDTO)
              this.parent.notifyGroupDataLoaded(this)
            }
            return
          },
          onFailed: (code: number, message: string): void => {
            // todo:
            this.status = NetDataStatusType.FAILED
            this.parent.notifyGroupDataFailed(this)
            return
          }
        };
        this.status = NetDataStatusType.LOADING;
        this.layoutService.getGroup(this.getPageId(), this.getId(), isRefresh, callback);
      } else {
        // "Layout service not initialed
        this.status = NetDataStatusType.FAILED;
        this.parent.notifyGroupDataFailed(this)
      }
      //return;
    }
    this.loadCompData();

    this.loadDynamicData();
  }

  public getPageId(): string {
    if (this.getParent() == null) {
      return "";
    }
    return this.getParent().getId();
  }

  /**
   * 解析Group数据
   * @param groupBean Group数据对象
   */
  private parseGroup(groupDataDTO: GroupDataDTO) {
    // TODO: 调用initGroup初始化Group对象
    if (groupDataDTO.components) {
      groupDataDTO.components.forEach((compDataDTO: CompDataDTO) => {
        let wdComp: WDComp<ItemBean, ItemDTO> | null = this.getCompById(compDataDTO.id);
        if (wdComp && !wdComp.separateLoad()) {
          wdComp.setData(compDataDTO);
        }
      })
    }
  }

  /**
   * 初始化WDComp对象
   * @param compList Comp数据对象列表
   */
  private initComp(compList: CompDTO[], initParams: Map<string, Object>) {
    // TODO：遍历初始化Comp
    if (compList == null || compList.length == 0) {
      return;
    }
    this.needLoadData = false;
    for (let num = 0; num < compList.length; num++) {
      let compDTO: CompDTO = compList[num];
      let wdComp: WDComp<ItemBean, ItemDTO>;
      if (!CompFilterUtil.filter(compDTO)) {
        continue
      }

      if (compDTO.compType == CompType.LABEL) {
        wdComp = new LabelComp(this, compDTO, initParams);
      } else if (compDTO.compType == CompType.BUTTON) {
        wdComp = new ButtonComp(this, compDTO, initParams);
      } else if (compDTO.compType == CompType.NAV_BAR) {
        if (compDTO.compStyle == CompStyle.NAV_BAR_01) {
          wdComp = new TabBar01Comp(this, compDTO, initParams);
        } else if (compDTO.compStyle == CompStyle.NAV_BAR_22) {
          wdComp = new TabBar22Comp(this, compDTO, initParams);
        } else if (compDTO.compStyle == CompStyle.NAV_BAR_03) {
          wdComp = new ProgrammeComp(this, compDTO, initParams);
        } else {
          // todo:不同的comp，临时用FlowComp
          wdComp = new FlowComp(this, compDTO, initParams);
        }
      } else if (compDTO.compType == CompType.BIG_STATIC_IMG
        || compDTO.compType == CompType.BIG_CAROUSEL_IMG
        || compDTO.compType == CompType.BIG_PLAY_IMG
        || compDTO.compType == CompType.TOP_IMG_BOTTOM_TXT
        || compDTO.compType == CompType.BINGE_WATCHING
        || compDTO.compType == CompType.SLIDER_IMG) {
        wdComp = new ProgrammeComp(this, compDTO, initParams);
      }else {
        // todo:不同的comp，临时用FlowComp
        wdComp = new FlowComp(this, compDTO, initParams);
      }
      if (!wdComp.separateLoad() && wdComp.loadWithGroupData()) {
        // todo:临时把走获取group本身数据的逻辑屏蔽，否则逐层获取gourp数据流程会中断。
        // this.needLoadData = true;
      }
      this.comps.add(wdComp);
      if (wdComp.isTeamWork()) {
        this.teamworkCompList.add(wdComp);
      }
    }
  }

  /**
   * Group是否需要加载数据
   * @returns
   */
  public shouldLoadData(): boolean {
    // TODO: 当所有comp都是独立加载数据则group无需再加载数据
    if (this.needLoadData) {
      return this.hasMoreData() || this.status == NetDataStatusType.INITIAL;
    }

    let loaded = true;
    // 若group无需请求网络加载数据时，则判断所有独立加载数据的comp是否都以完成加载
    for (let num = 0; num < this.comps.length; num++) {
      let wdComp: WDComp<ItemBean, ItemDTO> = this.comps[num];
      if (wdComp.separateLoad() && (!wdComp.isLoaded() || wdComp.hasMoreData())) {
        loaded = false;
        break;
      }
    }
    return !loaded;
  }

  /**
   * 是否正在加载中
   * @returns
   */
  public isGroupLoading(): boolean {
    // TODO: 遍历所有Comp是否正在加载中
    if (this.status == NetDataStatusType.LOADING) {
      return true;
    }
    for (let index = 0; index < this.comps.length; index = index + 1) {
      let comp = this.comps.get(index);
      if (!comp.separateLoad()) {
        continue;
      }

      if (comp.getIsLoading()) {
        return true;
      }
    }

    return false;
  }

  private loadCompData(): void {
    for (let index = 0; index < this.comps.length; index++) {
      let wdComp: WDComp<ItemBean, ItemDTO> = this.comps[index];
      if (!wdComp.separateLoad()) {
        continue;
      }
      if (!wdComp.isLoaded() || wdComp.hasMoreData()) {
        wdComp.loadMore();
      }
    }
  }

  /**
   * Group中所有的Comp是否都已加载完毕
   * @returns
   */
  public hasDataLoaded(): boolean {
    // TODO: 所有Comp是否都已经加载完数据
    if (this.needLoadData) {
      return this.status == NetDataStatusType.LOADED || this.status == NetDataStatusType.FAILED;
    } else {
      // 若group无需请求网络加载数据时，则判断所有独立加载数据的Comp是否都以完成加载
      for (let index = 0; index < this.comps.length; index = index + 1) {
        let comp = this.comps.get(index);
        if (comp.separateLoad() && !comp.isLoaded()) {
          return false;
        }
      }
      return true;
    }
  }

  /**
   * Group中所有的Comp是否都已(成功)加载完毕
   * @returns
   */
  public hasAllCompLoadedSuccess(): boolean {
    if (this.needLoadData) {
      return this.status == NetDataStatusType.LOADED;
    } else {
      // 若group无需请求网络加载数据时，则判断所有独立加载数据的Comp是否都以完成加载
      for (let index = 0; index < this.comps.length; index = index + 1) {
        let comp = this.comps.get(index);
        if (comp.separateLoad() && !comp.isLoadedSuccess()) {
          return false;
        }
      }
      return true;
    }
  }
  /**
   * 是否还有更多数据待加载
   */
  public hasMoreData(): boolean {
    // TODO: 判断是否有加载更多数据的Comp并且存在更多数据
    if (this.comps == null) {
      return false;
    }

    for (let index = 0; index < this.comps.length; index = index + 1) {
      let comp = this.comps.get(index);
      if (comp.hasMoreData()) {
        return true;
      }
    }

    return false;
  }

  public loadMore(): void {
    let hasMoreCompData: boolean = false;
    if (this.comps && !this.comps.isEmpty()) {
      for (let index = this.comps.length - 1; index >= 0; index = index - 1) {
        let comp = this.comps.get(index);
        if (comp) {
          hasMoreCompData = comp.hasMoreData();
          if (hasMoreCompData) {
            break;
          }
        }
      }
    }

    if (!hasMoreCompData && this.hasMoreGroupData) {
      // LogUtil.d("WDGroup[" + this.toString() + "]: loadMore");

      // requestLongFeed(false);
    }
  }

  /**
   * 是否需要加载动态数据
   * @returns
   */
  public needLoadDynamicData(): boolean {
    // TODO: 遍历所有Comp，判断数据源的dataSourceType是否为“POMS_NODE”，是则需要加载动态数据。
    return false;
  }

  /**
   * 加载动态数据
   */
  public loadDynamicData() {
    // TODO: 通过LayoutService加载动态数据，通过WDComp#replaceStaticData替换静态数据。
  }

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

  /**
   * 通过Comp id查找相应的comp实例
   *
   * @param id comp id
   */
  public getCompById(id: string): WDComp<ItemBean, ItemDTO> | null {
    for (let index = 0; index < this.comps.length; index++) {
      let wdComp: WDComp<ItemBean, ItemDTO> = this.comps[index];
      if (wdComp.getId() == id) {
        return wdComp;
      }
    }
    return null;
  }

  public getIsTeamWork(): boolean {
    return this.isTeamwork;
  }

  public getIsGrayMode(): boolean {
    return this.isGrayMode;
  }

  /**
   * 获取comp在Group中的位置
   *
   * @param comp WDComp实例
   */
  public indexOfComp(comp: WDComp<ItemBean, ItemDTO>): number {
    if (comp == null || this.comps == null) {
      return -1;
    }

    return this.comps.getIndexOf(comp);
  }
}