import {
  CompDTO,
  ContentBean,
  InteractDataDTO,
  InteractParam,
  LiveReviewDTO,
  MorningEveningPaperDTO,
  NavigationBodyDTO,
  PageDTO,
  PageInfoBean,
  PageInfoDTO,
  GoldenPositionExtraBean,
  NavigationDetailDTO,
  LiveRoomDataBean
} from 'wdBean';
import { CompStyle } from 'wdConstant/Index';

import { CollectionUtils, Logger, ResourcesUtils, StringUtils } from 'wdKit';
import { CacheData, ResponseDTO, } from 'wdNetwork';
import { PageUIReqBean } from '../components/page/bean/PageUIReqBean';
import { PageRepository } from '../repository/PageRepository';
import { BaseViewModel } from './BaseViewModel';

const TAG = 'PageViewModel';

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

  /**
   * 获取【早晚报】数据
   */
  async getMorningEveningPaperData(pageId: string): Promise<MorningEveningPaperDTO> {
    Logger.debug(TAG, 'getPageData pageId: ' + pageId);

    return new Promise<MorningEveningPaperDTO>((success, error) => {
      PageRepository.fetchMorningEveningPaperData(pageId)
        .then((resDTO: ResponseDTO<MorningEveningPaperDTO>) => {
          if (!resDTO || !resDTO.data) {
            Logger.error(TAG, 'getNavData then resDTO is empty');
            error('resDTO is empty');
            return
          }
          if (resDTO.code != 0) {
            Logger.error(TAG, `getNavData then code:${resDTO.code}, message:${resDTO.message}`);
            error('resDTO Response Code is failure');
            return
          }
          Logger.info(TAG, "getNavData then,resDTO.timestamp:" + resDTO.timestamp);
          success(resDTO.data);
        })
        .catch((err: Error) => {
          Logger.error(TAG, `getPageData catch, error.name : ${err.name},  error.message:${err.message}`);
          error(err);
        })
    })
  }

  /**
   * 获取页面楼层的组件信息
   * @param pageModel
   * @returns
   */
  async getPageGroupCompData(pageModel: PageUIReqBean): Promise<PageDTO> {
    Logger.debug(TAG, 'getPageData pageId: ' + pageModel.pageId);
    if (pageModel.isRecGroup) {
      return this.parseComp(PageRepository.fetchRecCompData(pageModel))
    } else {
      return this.parseComp(PageRepository.fetchCompData(pageModel))
    }
  }

  private parseComp(getData: Promise<ResponseDTO<PageDTO>>): Promise<PageDTO> {
    return new Promise<PageDTO>((success, error) => {
      getData
        .then((resDTO: ResponseDTO<PageDTO>) => {
          if (!resDTO || !resDTO.data) {
            Logger.error(TAG, 'getNavData then resDTO is empty');
            error('resDTO is empty');
            return
          }
          if (resDTO.code != 0) {
            Logger.error(TAG, `getNavData then code:${resDTO.code}, message:${resDTO.message}`);
            error('resDTO Response Code is failure');
            return
          }
          Logger.info(TAG, "getNavData then,resDTO.timestamp:" + resDTO.timestamp);
          resDTO.data.md5 = resDTO.meta?.md5 || ''
          success(resDTO.data);
        })
        .catch((err: Error) => {
          Logger.error(TAG, `getPageData catch, error.name : ${err.name},  error.message:${err.message}`);
          error(err);
        })
    })
  }

  async getPageUrlData(pageId: string): Promise<PageInfoBean> {
    Logger.debug(TAG, 'getPageUrlData pageId: ' + pageId);
    return new Promise<PageInfoBean>((success, error) => {
      PageRepository.fetchPageUrlData(pageId)
        .then((resDTO: ResponseDTO<PageInfoBean>) => {
          if (!resDTO || !resDTO.data) {
            Logger.error(TAG, 'fetchPageUrlData then resDTO is empty');
            error('resDTO is empty');
            return
          }
          if (resDTO.code != 0) {
            Logger.error(TAG, `fetchPageUrlData then code:${resDTO.code}, message:${resDTO.message}`);
            error('resDTO Response Code is failure');
            return
          }
          Logger.info(TAG, "fetchPageUrlData then,resDTO.timestamp:" + resDTO.timestamp);
          success(resDTO.data);
        })
        .catch((err: Error) => {
          Logger.error(TAG, `fetchPageUrlData 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: Array<Promise<InteractDataDTO[]>> = 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<InteractDataDTO[]>((success, error) => {
      Promise.all(promises).then((result) => {
        if (!CollectionUtils.isArray(result)) {
          success(new Array<InteractDataDTO>());
          return;
        }

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

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

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

    let param: InteractParam = {} as InteractParam;
    param.contentList = new Array<ContentBean>();
    compList.forEach((value) => {
      let contentList = value.operDataList;

      let letBatch = false
      // 只有稿件才能批查
      if (!Number.isNaN(Number(value.compStyle))) {
        letBatch = true
      }

      if (letBatch) {
        if (contentList != null && contentList.length == 1) { // 对只有一条数据的稿件参与批查
          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;
  }

  async getPageInfo(pageId: string): Promise<PageInfoDTO> {
    return new Promise<PageInfoDTO>((success, error) => {
      PageRepository.fetchPageData(pageId).then((resDTO: ResponseDTO<PageInfoDTO>) => {
        if (!resDTO || !resDTO.data) {
          Logger.error(TAG, 'getPageInfo then navResDTO is empty');
          error('navResDTO is empty');
          return
        }
        Logger.info(TAG, "getPageInfo then,resDTO.timeStamp:" + resDTO.timestamp);
        resDTO.data.md5 = resDTO.meta?.md5 || ''
        success(resDTO.data as PageInfoDTO);
      });
    });
  }

  async getLiveReviewUrl(pageNum: number, pageSize: number): Promise<LiveReviewDTO> {
    return new Promise<LiveReviewDTO>((success, error) => {
      Logger.info(TAG, `getLivePreviewUrl pageInfo start`);
      PageRepository.fetchLiveReviewUrl(pageNum, pageSize).then((resDTO: ResponseDTO<LiveReviewDTO>) => {
        if (!resDTO || !resDTO.data) {
          Logger.error(TAG, 'getLivePreviewUrl then navResDTO is empty');
          error('resDTO is empty');
          return
        }
        if (resDTO.code != 0) {
          Logger.error(TAG, `getLivePreviewUrl then code:${resDTO.code}, message:${resDTO.message}`);
          error('resDTO Response Code is failure');
          return
        }
        // let navResStr = JSON.stringify(navResDTO);
        Logger.info(TAG, "getLivePreviewUrl then,navResDTO.timestamp:" + resDTO.timestamp);
        success(resDTO.data);
      }).catch((err: Error) => {
        Logger.error(TAG, `getLivePreviewUrl catch, error.name : ${err.name},  error.message:${err.message}`);
        error(err);
      })
    })
  }

  /**
   *
   * @param type  1：正在直播，2：预告
   * @param pageNum
   * @param pageSize
   * @returns
   */
  async getLiveMoreUrl(type: number, pageNum: number, pageSize: number): Promise<LiveReviewDTO | null> {
    return new Promise<LiveReviewDTO| null>((success, error) => {
      Logger.info(TAG, `getLiveMoreUrl pageInfo start`);
      PageRepository.fetchLiveMoreUrl(type, pageNum, pageSize).then((resDTO: ResponseDTO<LiveReviewDTO>) => {
        if (!resDTO || !resDTO.data) {
          Logger.error(TAG, 'getLiveMoreUrl then navResDTO is empty');
          //error('resDTO is empty');
          success(null);
          return
        }
        if (resDTO.code != 0) {
          Logger.error(TAG, `getLiveMoreUrl then code:${resDTO.code}, message:${resDTO.message}`);
          //error('resDTO Response Code is failure');
          success(null);
          return
        }
        // let navResStr = JSON.stringify(navResDTO);
        Logger.info(TAG, "getLiveMoreUrl then,navResDTO.timestamp:" + resDTO.timestamp);
        success(resDTO.data);
      }).catch((err: Error) => {
        Logger.error(TAG, `getLiveMoreUrl catch, error.name : ${err.name},  error.message:${err.message}`);
        //error(err);
        success(null);
      })
    })
  }

  async postThemeList(pageNum: number, pageSize: number, extra: string): Promise<LiveReviewDTO> {
    let bean: GoldenPositionExtraBean = JSON.parse(extra)
    bean.pageNum = pageNum
    bean.pageSize = pageSize
    return new Promise<LiveReviewDTO>((success, error) => {
      Logger.info(TAG, `postThemeList pageInfo start`);
      PageRepository.postThemeList(bean).then((resDTO) => {
        if (!resDTO || !resDTO.data) {
          Logger.error(TAG, 'postThemeList then navResDTO is empty');
          error('resDTO is empty');
          return
        }
        if (resDTO.code != 0) {
          Logger.error(TAG, `postThemeList then code:${resDTO.code}, message:${resDTO.message}`);
          error('resDTO Response Code is failure');
          return
        }
        // let navResStr = JSON.stringify(navResDTO);
        Logger.info(TAG, "postThemeList then,navResDTO.timestamp:" + resDTO.timestamp, `${JSON.stringify(resDTO)}}`);
        success(resDTO.data);
      }).catch((err: Error) => {
        Logger.error(TAG, `postThemeList catch, error.name : ${err.name},  error.message:${err.message}`);
        error(err);
      })
    })
  }

  async getLiveRoomBatchInfo(ids: string): Promise<LiveRoomDataBean[]> {
    return new Promise<LiveRoomDataBean[]>((success, error) => {
      Logger.info(TAG, `getLiveRoomBatchInfo pageInfo start`);
      PageRepository.fetchLiveRoomBatchAllUrl(ids).then((resDTO: ResponseDTO<LiveRoomDataBean[]>) => {
        if (!resDTO || !resDTO.data) {
          Logger.error(TAG, 'getLiveRoomBatchInfo then navResDTO is empty');
          error('resDTO is empty');
          return
        }
        if (resDTO.code != 0) {
          Logger.error(TAG, `getLiveRoomBatchInfo then code:${resDTO.code}, message:${resDTO.message}`);
          error('resDTO Response Code is failure');
          return
        }
        // let navResStr = JSON.stringify(navResDTO);
        Logger.info(TAG, "getLiveRoomBatchInfo then,navResDTO.timestamp:" + resDTO.timestamp);
        success(resDTO.data);
      }).catch((err: Error) => {
        Logger.error(TAG, `getLiveRoomBatchInfo catch, error.name : ${err.name},  error.message:${err.message}`);
        error(err);
      })
    })
  }

  async getPageInfoCache(pageId: string): Promise<PageInfoDTO | null> {
    return new Promise<PageInfoDTO | null>((success) => {
      CacheData.getLocalCacheData(CacheData.comPageInfoCacheKey + pageId).then((data) => {
        // Logger.debug(TAG, 'getPageInfoCache 333 ' + JSON.stringify(data));
        if (data) {
          let navBean = JSON.parse(CacheData.getNetworkData(data)) as PageInfoDTO
          success(navBean)
        } else {
          success(null)
        }
      }).catch((err: object) => {
        Logger.error(TAG, 'getPageInfoCache catch err: ' + JSON.stringify(err));
        success(null)
      })
    });
  }

  /**
   * 获取页面楼层的组件信息
   * @param pageModel
   * @returns
   */
  async getPageGroupCacheData(pageModel: PageUIReqBean): Promise<PageDTO | null> {
    Logger.debug(TAG, 'getPageData pageId: ' + pageModel.pageId);
    return new Promise<PageDTO | null>((success) => {
      CacheData.getLocalCacheData(CacheData.compGroupInfoDataCacheKey + pageModel.pageId + pageModel.groupId)
        .then((data) => {
          // Logger.debug(TAG, 'getPageGroupCacheData 333 ' + JSON.stringify(data));
          if (data) {
            let navBean = JSON.parse(CacheData.getNetworkData(data)) as PageDTO
            success(navBean)
          } else {
            success(null)
          }
        })
        .catch((err: object) => {
          Logger.error(TAG, 'getPageGroupCacheData catch err: ' + JSON.stringify(err));
          success(null)
        })
    });
  }
}


let pageViewModel = new PageViewModel();

export default pageViewModel as PageViewModel;