export const JOIN_STATUS_MAP = {
  JOINED_CAN_CANCEL: 'JOINED_CAN_CANCEL', // 1 已报名 可取消
  JOINED_CAN_NOT_CANCEL: 'JOINED_CAN_NOT_CANCEL', // 3 已报名 不可取消

  NOT_JOIN_CAN_JOIN: 'NOT_JOIN_CAN_JOIN', // 2 未报名 可报名
  NOT_JOIN_AND_JOIN_ENDED: 'NOT_JOIN_AND_JOIN_ENDED', // 4 未报名 报名已截止，或者已报名但人数不够

  NOT_JOIN_START: 'NOT_JOIN_START', // 6 未到报名时间
  NOT_SET_JOIN: 'NOT_SET_JOIN', // 7 不设置报名
};


export const JOIN_STATUS_NUMBER_MAP = {
  [JOIN_STATUS_MAP.JOINED_CAN_CANCEL]: 1,
  [JOIN_STATUS_MAP.JOINED_CAN_NOT_CANCEL]: 3,

  [JOIN_STATUS_MAP.NOT_JOIN_CAN_JOIN]: 2,
  [JOIN_STATUS_MAP.NOT_JOIN_AND_JOIN_ENDED]: 4,

  [JOIN_STATUS_MAP.NOT_JOIN_START]: 6,
  [JOIN_STATUS_MAP.NOT_SET_JOIN]: 7,
};


export function getNowBySecond() {
  return Math.floor(Date.now() / 1000);
}


export function getJoinStatus({
  isJoined,
  isTeamMatch,
  isFullTeam,

  gameDispStatus, // 1报名中 2待比赛 3比赛中 4已结束

  canJoin, // 是否需要报名

  // 是否可以在比赛中取消报名
  // 有参与对局（进入房间准备并成功分组）：不可取消
  // 未参与对局：固定分组，第一局开赛前可取消；随机分组，最后一局开赛前可取消；之后不可取消
  canCancelInPlaying,
}: {
  isJoined: boolean;
  isTeamMatch: boolean;
  isFullTeam: boolean;

  gameDispStatus: number;

  canJoin: boolean;
  canCancelInPlaying: boolean;
}) {
  console.log('[canCancelInPlaying]', canCancelInPlaying);

  if (!canJoin) {
    // 不设置报名
    return JOIN_STATUS_MAP.NOT_SET_JOIN;
  }
  if (!gameDispStatus) {
    // 未到报名时间
    return JOIN_STATUS_MAP.NOT_JOIN_START;
  }

  if (gameDispStatus === 1) {
    if (isJoined) {
      // 已报名 可取消
      return JOIN_STATUS_MAP.JOINED_CAN_CANCEL;
    }
    // 未报名 可报名
    return JOIN_STATUS_MAP.NOT_JOIN_CAN_JOIN;
  }

  if (gameDispStatus == 3
    && canCancelInPlaying
    && isJoined
  ) {
    // 已报名 可取消
    return JOIN_STATUS_MAP.JOINED_CAN_CANCEL;
  }

  if (!isJoined) {
    // 未报名 报名已截止，或者已报名但人数不够
    return JOIN_STATUS_MAP.NOT_JOIN_AND_JOIN_ENDED;
  }

  if (!isTeamMatch) {
    // 已报名 不可取消
    // 个人赛
    return JOIN_STATUS_MAP.JOINED_CAN_NOT_CANCEL;
  }

  if (isFullTeam) {
    // 已报名 不可取消
    // 团体赛满人
    return JOIN_STATUS_MAP.JOINED_CAN_NOT_CANCEL;
  }

  return JOIN_STATUS_MAP.NOT_JOIN_AND_JOIN_ENDED;
}

export function getLastGroupBattle({
  battleList,
  isVirtualGameAndAutoStartAndRandomGroup,
  isVirtualGameAndAutoStartAndFixedGroup,
}: {
  battleList: any[];
  isVirtualGameAndAutoStartAndRandomGroup?: boolean;
  isVirtualGameAndAutoStartAndFixedGroup?: boolean;
}) {
  if (isVirtualGameAndAutoStartAndRandomGroup) {
    return battleList[battleList.length - 1];
  }

  if (isVirtualGameAndAutoStartAndFixedGroup) {
    return battleList[0];
  }
  return null;
}


// 最后可分组的一局是否已开赛
// 固定分组，第一局；随机分组，最后一局
export function checkLastGroupBattleNotStart({
  battleList,
  isVirtualGameAndAutoStartAndRandomGroup,
  isVirtualGameAndAutoStartAndFixedGroup,
}: {
  battleList: any[];
  isVirtualGameAndAutoStartAndRandomGroup?: boolean;
  isVirtualGameAndAutoStartAndFixedGroup?: boolean;
}) {
  const battle = getLastGroupBattle({
    battleList,
    isVirtualGameAndAutoStartAndRandomGroup,
    isVirtualGameAndAutoStartAndFixedGroup,
  });

  return (battle?.battle_status || 0) < 200;
}

// 是否可以在比赛中取消报名
// 有参与对局（进入房间准备并成功分组）：不可取消
// 未参与对局：固定分组，第一局开赛前可取消；随机分组，最后一局开赛前可取消；之后不可取消
export function checkCanCancelInPlaying({
  lastGroupBattleNotStart,
  battleList,
  isNotQualified,
  isJoined,
  lastBattleStarted,
}: {
  lastGroupBattleNotStart: boolean;
  battleList: Array<any>;

  isNotQualified?: boolean;
  isJoined?: boolean;
  lastBattleStarted?: boolean;
}) {
  // 最后一场比赛开赛，未满资格
  if (isNotQualified && isJoined && lastBattleStarted) {
    return false;
  }

  const hasJoinedGame = !!battleList.find(item => item.battle_id);
  if (hasJoinedGame) return false;

  if (lastGroupBattleNotStart) {
    return lastGroupBattleNotStart;
  }

  return false;
}


export function checkIsPlayingAndCanSignup({
  timCfgList = [],
  isVirtualGameAndAutoStartAndRandomGroup,
  isVirtualGameAndAutoStartAndFixedGroup,
  isJoined,
  joinEnd = 0,
}: {
  timCfgList: any[];
  isVirtualGameAndAutoStartAndRandomGroup?: boolean;
  isVirtualGameAndAutoStartAndFixedGroup?: boolean;
  isJoined?: boolean;
  joinEnd?: number;
}) {
  const battle = getLastGroupBattle({
    battleList: timCfgList,
    isVirtualGameAndAutoStartAndRandomGroup,
    isVirtualGameAndAutoStartAndFixedGroup,
  });

  const now = getNowBySecond();
  const res = !isJoined
   && joinEnd < now
   && now < battle?.stime;
  return res;
}


export function checkIsPlayingAndNotSatisfied({
  isVirtualGameAndAutoStart,
  isTeamMatch,
  isJoined,

  lastGroupBattleNotStart,
  isFullTeam,
  joinEnd = 0,
}: {
  isVirtualGameAndAutoStart: boolean;
  isTeamMatch: boolean;
  isJoined: boolean;

  lastGroupBattleNotStart: boolean;
  isFullTeam: boolean;
  joinEnd?: number;
}) {
  const now = getNowBySecond();

  const res = isVirtualGameAndAutoStart
     && isTeamMatch
     && isJoined
     && lastGroupBattleNotStart
     && !isFullTeam
     && now > joinEnd;
  return res;
}


export function checkIsSatisfiedAndCanInvite({
  canCancelInPlaying,
  isJoined,
  isTeamMatch,

  isFullTeam,
  isVirtualGameAndAutoStart,
  joinEnd = 0,
}: {
  canCancelInPlaying: boolean;
  isJoined: boolean;
  isTeamMatch: boolean;
  isFullTeam: boolean;
  isVirtualGameAndAutoStart: boolean;
  joinEnd?: number;
}) {
  const now = getNowBySecond();

  const res = canCancelInPlaying
     && isJoined
     && isTeamMatch
     && isFullTeam
     && isVirtualGameAndAutoStart
     && now > joinEnd;

  return res;
}


export function checkIsSatisfiedAndCannotInvite({
  battleList = [],
  curBattleSeq = 1,

  canCancelInPlaying,
  isJoined,
  isTeamMatch,

  isFullTeam,
  isVirtualGameAndAutoStart,
  joinEnd = 0,
}: {
  battleList: any[];
  curBattleSeq: number;

  canCancelInPlaying: boolean;
  isJoined: boolean;
  isTeamMatch: boolean;

  isFullTeam: boolean;
  isVirtualGameAndAutoStart: boolean;
  joinEnd?: number;
}) {
  const lastBattleEnd = curBattleSeq === battleList.length
    && (battleList[battleList.length - 1]?.battle_status || 0) >= 300;
  const now = getNowBySecond();

  // 这里个人赛没有 battle_user_list，所以还是展示旧样式
  const res = isVirtualGameAndAutoStart
     && isJoined
     && isTeamMatch
     && isFullTeam
     && !canCancelInPlaying
     && !lastBattleEnd
     && now > joinEnd;
  return res;
}