import { CollectionUtils, Logger, ResourcesUtils, StringUtils } from 'wdKit';
import { ResponseDTO, } from 'wdNetwork';
import { PageRepository } from '../repository/PageRepository';
import { NavigationBodyDTO } from '../repository/bean/NavigationBodyDTO';
import { PageDTO } from '../repository/bean/PageDTO';
import { BaseViewModel } from './BaseViewModel';
import { InteractDataDTO } from '../repository/bean/InteractDataDTO';
import { ContentBean, InteractParam } from '../repository/bean/InteractParam';
import { CompDTO } from '../repository/bean/CompDTO';
import { PageInfoDTO } from '../repository/bean/PageInfoDTO';
import PageModel from './PageModel';

const TAG = 'PageViewModel';
/**
 * mock数据开关，默认关。
 * mock数据是本地json数据，可自行修改内容（‘entry\src\main\resources\rawfile\’目录）
 */
const mock_switch = false;
/**
 * 互动数据获取开关开关，默认开。
 * TODO 后续需要优化掉，变为二次请求异步刷新
 */
const interact_sync_switch = true;

/**
 * 处理返回后的数据
 */
export class PageViewModel extends BaseViewModel {
  getLogTag() {
    return TAG;
  }

  /**
   * get Nav Data from Resource .
   *
   * @return BottomNavBean[] Nav Data List
   */
  async getBottomNavData(context?: Context): Promise<NavigationBodyDTO> {
    Logger.info(TAG, `getBottomNavData start`);
    if (mock_switch) {
      return this.getBottomNavDataMock(context);
    }
    return this.getNavData();
  }

  async getBottomNavDataMock(context?: Context): Promise<NavigationBodyDTO> {
    Logger.info(TAG, `getBottomNavDataMock start`);
    let compRes: ResponseDTO<NavigationBodyDTO> | null = await ResourcesUtils.getResourcesJson<ResponseDTO<NavigationBodyDTO>>('bottom_nav.json', context);
    if (!compRes || !compRes.data) {
      Logger.info(TAG, `getBottomNavDataMock compRes bottomNavList is empty`);
      return null
    }
    Logger.info(TAG, `getBottomNavDataMock getResourcesJsonSync compRes : ${JSON.stringify(compRes)}`);
    return compRes.data
  }

  private getNavData(): Promise<NavigationBodyDTO> {
    return new Promise<NavigationBodyDTO>((success, error) => {
      Logger.info(TAG, `getNavData start`);
      PageRepository.fetchNavigationDataApi().then((navResDTO: ResponseDTO<NavigationBodyDTO>) => {
        if (this.isRespondsInvalid(navResDTO, 'getNavData')) {
          error("page data invalid");
          return
        }
        Logger.info(TAG, "getNavData then,navResDTO.timeStamp:" + navResDTO.timestamp);
        let navigationBean = navResDTO.data
        success(navigationBean);
      }).catch((err: Error) => {
        Logger.error(TAG, `fetchNavigationDataApi catch, error.name : ${err.name},  error.message:${err.message}`);
        error(err);
      })
    })
  }

  /**
   * Get PageDTO data.
   *
   * @return {GroupDTO} compRes.data
   */
  private async getPageData1(currentPage: number, context?: Context): Promise<PageDTO> {
    if (currentPage > 1) {
      // 加载更多，返回无数据
      return {} as PageDTO
    }
    let compRes: ResponseDTO<PageDTO> | null = await ResourcesUtils.getResourcesJson<ResponseDTO<PageDTO>>('comp_list0.json', context);
    if (!compRes || !compRes.data) {
      Logger.info(TAG, `getCompList compRes is empty`);
      return {} as PageDTO
    }
    Logger.info(TAG, `getCompList getResourcesJson compRes : ${JSON.stringify(compRes)}`);
    return compRes.data
  }

  /**
   * Get Group data.
   *
   * @return {GroupDTO} compRes.data
   * @deprecated
   */
  private async getPageData2(context?: Context): Promise<PageDTO> {
    let compRes: ResponseDTO<PageDTO> | null = await ResourcesUtils.getResourcesJson<ResponseDTO<PageDTO>>('comp_list2.json');
    if (!compRes || !compRes.data) {
      Logger.info(TAG, `getCompList compRes is empty`);
      return {} as PageDTO
    }
    // router.push('')
    Logger.info(TAG, `getCompList getResourcesJson compRes : ${JSON.stringify(compRes)}`);
    return compRes.data
  }

  async getPageInfo(pageId: string): Promise<PageInfoDTO> {
    return new Promise<PageInfoDTO>((success, error) => {
      PageRepository.fetchPageData(pageId).then((resDTO: ResponseDTO<PageInfoDTO>) => {
        if (this.isRespondsInvalid(resDTO, 'getPageInfo')) {
          error("getPageInfo data invalid");
          return
        }
        Logger.info(TAG, "getPageInfo then,resDTO.timeStamp:" + resDTO.timestamp);
        success(resDTO.data);
      });
    });
  }

  async getPageData(pageModel: PageModel, context?: Context): Promise<PageDTO> {
    Logger.debug(TAG, 'getPageData pageId: ' + pageModel.pageId);
    if (mock_switch) {
      return this.getPageData1(pageModel.currentPage, context);
    }
    if (pageModel.isRecGroup) {
      return this.parseComp(PageRepository.fetchRecCompData(pageModel.pageId, pageModel.groupId, pageModel.channelId, pageModel.currentPage, pageModel.pageSize))
    } else {
      return this.parseComp(PageRepository.fetchCompData(pageModel.pageId, pageModel.groupId, pageModel.channelId, pageModel.currentPage, pageModel.pageSize))
    }
  }

  private parseComp(getData: Promise<ResponseDTO<PageDTO>>): Promise<PageDTO> {
    return new Promise<PageDTO>((success, error) => {
      getData
        .then((resDTO: ResponseDTO<PageDTO>) => {
          if (this.isRespondsInvalid(resDTO, 'getPageData')) {
            error("page data invalid");
            return
          }
          Logger.info(TAG, "getPageData then,resDTO.timeStamp:" + resDTO.timestamp);
          if (!interact_sync_switch) {
            success(resDTO.data);
            return;
          }
          success(resDTO.data);
          // TODO 打开同步请求互动数据，待优化为异步加载
          if (CollectionUtils.isEmpty(resDTO.data.compList)) {
            success(resDTO.data);
          } else {
            this.getInteractData(resDTO.data.compList).then(() => {
              success(resDTO.data);
            })
          }
        })
        .catch((err: Error) => {
          Logger.error(TAG, `getPageData catch, error.name : ${err.name},  error.message:${err.message}`);
          error(err);
        })
    })
  }

  async getInteractData(compList: CompDTO[]) {
    let param: InteractParam = this.getInteractParams(compList);
    const SIZE = 20;
    // 批查接口，参数size限制20，这里截断分批查询，0,20；20,40...
    let count = Math.ceil(param.contentList.length / SIZE);
    let promises = new Array;
    if (count == 1) {
      let promise: Promise<InteractDataDTO[]> = this.createInteractDataPromise(param);
      promises.push(promise);
    } else {
      for (let i = 1;i <= count; i++) {
        // 将查询参数截断（参数限制20个），分批请求接口
        let subList = new Array<ContentBean>();
        let start = 0;
        let end = 0;
        if (i == count) {
          start = (i - 1) * SIZE;
          end = param.contentList.length;
          subList = CollectionUtils.getSubElements(param.contentList, start, end)
        } else {
          start = (i - 1) * SIZE;
          end = start + SIZE;
          subList = CollectionUtils.getSubElements(param.contentList, start, end)
        }
        let subParam: InteractParam = {} as InteractParam;
        subParam.contentList = subList;
        let promise: Promise<InteractDataDTO[]> = this.createInteractDataPromise(subParam);
        promises.push(promise);
      }
    }

    return new Promise<CompDTO[]>((success, error) => {
      Promise.all(promises).then((result) => {
        if (!CollectionUtils.isArray(result)) {
          success(compList);
          return;
        }

        let allInteractDataList = new Array();
        result.forEach((value: InteractDataDTO[]) => {
          if (value != null && value.length > 0) {
            allInteractDataList.push(...value);
          }
        })
        // 批查全部完成，统一设置到comp里
        this.resetInteract(allInteractDataList, compList);
        success(compList);
      })
    })
  }

  private createInteractDataPromise(param: InteractParam) {
    return new Promise<InteractDataDTO[]>((success, error) => {
      PageRepository.fetchInteractData(param).then((resDTO: ResponseDTO<InteractDataDTO[]>) => {
        if (this.isRespondsInvalid(resDTO, 'getInteractData')) {
          Logger.info(TAG, "getInteractData then,resDTO.timeStamp:" + resDTO.timestamp);
          success(null);
          return;
        }
        success(resDTO.data);
      }).catch((err: Error) => {
        Logger.error(TAG, `getInteractData catch, error.name : ${err.name},  error.message:${err.message}`);
        // 无论是否成功（暂不做重试），都回调结果，通知刷新数据
        success(null);
      })
    });
  }

  private resetInteract(interact: InteractDataDTO[], compList: CompDTO[]) {
    if (interact == null || interact.length == 0) {
      return
    }
    interact.forEach((interactData) => {
      let id = interactData.contentId;
      outer: for (let i = 0;i < compList.length; i++) {
        let comp = compList[i];
        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;
            content.interactData.likeNum = 109;
            break outer;
          }
        }
      }
    })
  }

  private getInteractParams(compList: CompDTO[]): InteractParam {
    if (compList == null || compList.length == 0) {
      return null;
    }

    let param: InteractParam = {} as InteractParam;
    param.contentList = new Array<ContentBean>();
    compList.forEach((value) => {
      let contentList = value.operDataList;
      if (contentList != null && contentList.length > 0) {
        contentList.forEach((v) => {
          if (StringUtils.isNotEmpty(v.objectId)) {
            let bean = {} as ContentBean;
            bean.contentId = v.objectId;
            bean.contentType = v.objectType;
            param.contentList.push(bean);
          }
        })
      }
    })
    return param;
  }
}


let pageViewModel = new PageViewModel();

export default pageViewModel as PageViewModel;