import { SCHEDULE_TYPE_MAP } from '../config';

import { getBattleId, getFirstValidBattle, getRedSide } from './battle-id';
import { getGpBattleState } from './battle-status';
import { checkOneTeamEmpty } from './is-one-team-empty';

import { getMiddleButtonTitle } from './middle-button';
import { flattenTeamInfo, getTeamInfo } from './team-info';


let teamMap = {};


/**
 * 处理赛程列表的主要函数
 *
 * 淘汰赛和循环赛的 scheList 格式不同，淘汰赛为[[1轮1场，1轮2场],[2轮1场，2轮2场],]
 * 循环赛轮次为同一个，为[[x轮1组1场，x轮1组2场],[x轮2组1场,x轮2组2场]]
 */
export function handleScheList({
  treeRoundList,
  teamList,

  isPreview,
  isAdmin,
  isManualStart,
  openAILive,
}: {
  treeRoundList: Array<Record<string, any>>;
  teamList: Array<Record<string, any>>;

  myTeamId?: string;

  isPreview?: number;
  isAdmin?: boolean,
  isManualStart?: boolean;
  openAILive: boolean;
}) {
  let tempScheType: number;
  const res = treeRoundList.reduce((acc: Array<any>, treeRound: any) => {
    const {
      scheItem,
      curScheType,
    } = handleGpSchInfo({
      treeRound,
      teamList,

      isPreview,
      isAdmin,
      isManualStart,

      openAILive,
      scheType: tempScheType,
    });

    if (curScheType) {
      tempScheType = curScheType;
    }

    acc.push(scheItem);
    return acc;
  }, []);

  const obj = {
    scheList: res,
  };
  return obj;
}


// 处理赛程
function handleGpSchInfo({
  treeRound = {},
  teamList,

  isPreview,
  isAdmin,
  isManualStart,

  openAILive,
  scheType,
}: {
  treeRound: Record<string, any>,
  teamList: Array<Record<string, any>>;

  isPreview?: number;
  isManualStart?: boolean;
  isAdmin?: boolean;

  openAILive: boolean;
  scheType?: number;
}) {
  const res: any = [];
  const nodeList = (treeRound.node_list) || [];
  teamMap = flattenTeamInfo(teamList);
  const roundInfo = treeRound.round_info || {};

  let i = 0;
  let curScheType = scheType;

  while (i < nodeList.length) {
    const scheGroupList: any = [];
    scheGroupList.push(handleGpNodeItem({ nodeItem: nodeList[i],
      isPreview,
      isAdmin,
      isManualStart,
      openAILive,
    }));


    if (nodeList[i].sch_type) {
      curScheType = nodeList[i].sch_type;
    }

    const isEliminationType = curScheType == SCHEDULE_TYPE_MAP.DOUBLE_FAIL
      || curScheType == SCHEDULE_TYPE_MAP.KNOCK_OUT;

    // 只有淘汰赛的时候，才一定要找下一组
    if (isEliminationType && nodeList.length != 1) {
      i += 1;
      scheGroupList.push(handleGpNodeItem({
        nodeItem: nodeList[i],
        isPreview,
        isAdmin,
        isManualStart,
        openAILive,
      }));
    }

    res.push({
      battleList: scheGroupList,
      roundInfo,
      partitionId: nodeList[i]?.sch_rule?.partition_id,
      isChamp: isChamp(),
    });
    i += 1;
  }

  function isChamp() {
    return nodeList[i] && nodeList[i].sch_type == 4 && nodeList.length == 1;
  }
  return {
    scheItem: res,
    curScheType,
  };
}


// 处理节点项，即 node_list 的每一项，nodeItem 是两个队伍
function handleGpNodeItem({
  nodeItem,
  isPreview = 0,
  isAdmin,
  isManualStart,
  openAILive,
}: {
  nodeItem: Record<string, any>,
  isPreview?: number,
  isManualStart?: boolean,
  isAdmin?: boolean,
  openAILive: boolean,
}) {
  const upTeamInfo = getTeamInfo({
    nodeItem,
    pos: 'a',
    isPreview,
    teamMap,
  });
  const downTeamInfo = getTeamInfo({
    nodeItem,
    pos: 'b',
    isPreview,
    teamMap,
  });
  const curBattle = getBattleId(nodeItem);
  const firstValidBattle = getFirstValidBattle(nodeItem);
  const { battle_id: battleId } = curBattle;
  const boType = nodeItem.sch_score?.bo_type || 1;
  const curBo = nodeItem.sch_score?.cur_bo || 1;
  const roomType = nodeItem.sch_score?.room_type || 1;

  const {
    timeDesc,
    statusDesc,
    playingDesc,
    listViewStatusDesc,
    battleDesc,
  } = getGpBattleState({
    state: nodeItem.state,
    curBo: nodeItem.sch_score?.cur_bo,
    battleList: nodeItem.battle_list,

    isManualStart,
    time: nodeItem.battle_list?.[nodeItem.battle_list?.length - 1]?.ctime || nodeItem.utime,
  });

  const redSide = getRedSide(nodeItem);
  // 顶号相关,不区分用户类型
  const abnormalErr = nodeItem.sch_score?.err_flag === 9999;

  const isAtLeastOneTeamEmpty = checkOneTeamEmpty({
    teamAId: nodeItem?.sch_score?.teama_id,
    teamBId: nodeItem?.sch_score?.teamb_id,
  });
  const buttonInfo = getMiddleButtonTitle({
    isAdmin,
    isAtLeastOneTeamEmpty,
    state: nodeItem.state,
    curBattle,
    openAILive,
  });
  const scheGroup: any = {
    teamList: [
      upTeamInfo,
      downTeamInfo,
    ],
    upTeamInfo,
    downTeamInfo,
    battleid: battleId,
    battleId,
    boType,
    curBo,
    roomType,
    showVS: listViewStatusDesc === '未开始',

    timeDesc,
    statusDesc, // 出现在赛程树中，有 “待管理员开赛”
    playingDesc,
    listViewStatusDesc,
    battleDesc,

    redSide,
    schid: nodeItem.sch_id,
    sch_id: nodeItem.sch_id,
    state: nodeItem.state,

    schId: nodeItem.sch_id,
    status: nodeItem.status,
    realStatus: nodeItem.state,

    nodeItem,
    abnormalErr,

    middleButtonTitle: buttonInfo.title,
    middleButtonClass: buttonInfo.class,

    isAtLeastOneTeamEmpty,
    firstValidBattleId: firstValidBattle?.battle_id,
  };

  return scheGroup;
}