/**
 * 同步管理器，用于同步一个MGGroup中所有MGComp的数据响应。
 * 当全部MGComp数据都请求完毕后，一次性返回所有数据。
 */
import { WDGroup } from '../layout/WDGroup';
import List from '@ohos.util.List';
import { Timeout } from './TimeoutManager';
import { WDPage } from '../layout/WDPage';
import { WDComp } from '../layout/WDComp';
import { ItemBean } from '../bean/ItemBean';
import { ItemDTO } from '../bean/ItemDTO';
import { LegoUtil } from '../utils/LegoUtil';
import { Lego } from './LegoService';

export class Synchronizer {
  /**
   * 正在处理中的MGGroup列表，用于记录和按顺序回调给调用者。
   */
  private workingList: List<WDGroup> = new List();
  /**
   * 已经返回的MGGroup列表
   */
  private completedList: List<WDGroup> = new List();
  private failedList: List<WDGroup> = new List();
  /**
   * 任务超时管理器
   */
  private timeoutManager: Timeout.TimeoutManager;

  /**
   * 构造函数：Lego数据请求统筹对象
   * @param page 目标MGPage对象
   */
  constructor() {
    let callback: Timeout.Callback = {
      onTimeout: (group: WDGroup, callback: Lego.Callback) => {
        this.onTimeout(group, callback);
      }
    }
    this.timeoutManager = new Timeout.TimeoutManager(callback)
  }

  /**
   * 记录正在进行中的任务
   * @param group 正在进行数据请求的MGGroup对象
   * @param callback 回调
   */
  public addGroup(group: WDGroup, legoCallback: Lego.Callback) {
    // TODO: 记录Group
    this.workingList.add(group);

    this.timeoutManager.addTask(group, legoCallback);
  }

  /**
   * 同步按顺序控制回调
   * @param callback 回调
   */
  private syncCallback(callback: Lego.Callback) {
    // TODO: 判断是否可以回调与遍历可回调Group
    while (this.workingList.length > 0) {
      // 严格按照任务顺序返回，若出现未完成任务，则等待下次处理。
      let tempGroup: WDGroup = this.workingList.get(0)
      if (this.completedList.has(tempGroup)) {
        this.workingList.remove(tempGroup);
        this.completedList.remove(tempGroup);
        // todo
        // callback.onLoaded(tempGroup);
      } else if (this.failedList.has(tempGroup)) {
        this.workingList.remove(tempGroup);
        this.failedList.remove(tempGroup);
        // todo
        // callback.onFailed(tempGroup, "");
      } else {
        break;
      }
    }
  }

  public onTimeout(group: WDGroup, callback: Lego.Callback): void {
    // 目前简单的处理成超时则不显示该Group
    this.onFailed("Timeout", group, callback);
  }

  /**
   * MGGroup数据加载完毕，按照顺序回调。
   *
   * @param group 数据请求完毕的MGGroup对象
   * @param callback 回调对象
   */
  public onLoaded(group: WDGroup, callback: Lego.Callback): void {
    this.timeoutManager.removeTask(group);
    this.completedList.add(group);

    this.syncCallback(callback);
  }

  /**
   * MGGroup数据加载失败，按照顺序回调。
   *
   * @param msg 携带的描述信息，主要用于调试。
   * @param group 数据请求完毕的MGGroup对象
   * @param callback 回调对象
   */
  public onFailed(msg: string, group: WDGroup, callback: Lego.Callback): void {
    this.timeoutManager.removeTask(group);
    this.failedList.add(group);

    this.syncCallback(callback);
  }


  /**
   * MGPage级别的错误，无法恢复。
   *
   * @param msg 携带的描述信息，主要用于调试。
   * @param callback 回调对象
   */
  public onError(page: WDPage, msg: string, callback: Lego.Callback) {
    callback.onError(page, msg);
  }


  /**
   * MGGroup数据更新
   *
   * @param group 数据更新的MGGroup对象
   * @param callback 回调对象
   */
  public onGroupUpdate(group: WDGroup, callback: Lego.Callback) {
    if (!this.workingList.has(group)) {
      callback.onGroupUpdate(group);
    }
  }

  /**
   * MGComp数据更新
   *
   * @param comp 数据更新的MGComp对象
   * @param callback 回调对象
   */
  public onCompUpdate(comp: WDComp<ItemBean, ItemDTO>, callback: Lego.Callback): void {
    if (!this.workingList.has(comp.getParent())) {
      callback.onCompUpdate(comp);
    }
  }

  /**
   * 检查MGGroup中的所有MGComp的数据是否加载完毕
   *
   * @param group MGGroup实例
   * @param callback 请求的回调对象
   */
  public checkStatus(msg: string, group: WDGroup, callback: Lego.Callback): void {
    if (group) {
      // 如果没有主动请求这个Group，而这个Group的comp数据返回，则不处理回调判断。
      if (!this.workingList.has(group)) {
        return;
      }

      let compList: List<WDComp<ItemBean, ItemDTO>> = group.getCompList();
      if (compList && !compList.isEmpty()) {
        let isCompleted: boolean = true;
        for (let i = 0; i < compList.length; i++) {
          let comp: WDComp<ItemBean, ItemDTO> = compList.get(i);
          // 检查是否有未加载完毕的Comp
          // if (comp instanceof FlowComp) {
          //   let itemCount: number = comp.getItemCount()
          //   // let itemCount:number = ((FlowComp) comp).getItemCount();
          //   if (itemCount <= 0) {
          //     isCompleted = false;
          //     break;
          //   }
          // } else
          if (comp && comp.separateLoad() && !comp.isLoaded()) {
            isCompleted = false;
            break;
          }
        }
        if (isCompleted) {
          // this.onLoaded(group, callback);
          callback.onLoaded(group)
        }
      } else {
        msg = "checkStatus: comp list is empty -- > PageID = " + LegoUtil.getPageId(group.getParent()) + ", GroupID = " + LegoUtil.getGroupId(group);
        // this.onFailed(msg, group, callback);
        callback.onFailed(group, msg)
      }
    }
  }
}