(common: StackInputSourceCommon, stage: GameStage | null, playerID: string[], currentRound: number, winMap: IPlayerMap<number>): IPlayerMap<Array<IDropdownSource<number>>> => {
    if (common) {
      return common
    }
    const defaultSrc = createSource(range(currentRound + 1))
    const winSum: number = sum(values(winMap))

    // Short circuit.
    // No-op when there is excess win
    // Or stage is not at waitingWin
    if (stage !== GameStage.waitingWin || winSum > currentRound) {
      return fillObj({}, playerID, defaultSrc)
    }

    // Surgery on win options
    // Cannot choose a win that exceed currentRound
    const delta = currentRound - winSum
    const head = createSource(range(delta + 1))
    const tail = range(delta + 1, currentRound + 1)
      .map(i => ({value: i, label: i + '', disabled: true}))
    const restSrc = head.concat(tail)

    const pairs = playerID
      .map(ID => {
        const selectedWin = winMap[ID]
        const src = (selectedWin <= 0 || selectedWin == null)
          ? restSrc
          : defaultSrc
        return [ID, src]
      })

    return fromPairs(pairs)
  }

 (playerLength: number, selectedRounds: number): IEntrySource => {
   const maxRounds = Math.floor(52 / playerLength)
   const rounds = playerLength > 0
     ? createSource(range(1, maxRounds + 1))
     : defaultRounds
   const startingRound = playerLength > 0
     ? createSource(range(1, selectedRounds + 1))
     : defaultRounds
   return {
     rounds,
     startingRound
   }
 }

  (common: StackInputSourceCommon, playerID: string[], currentRound: number, bidMap: IPlayerMap<number>, playerOrder: string[]): IPlayerMap<Array<IDropdownSource<number>>> => {
    if (common) {
      return common
    }
    const defaultSrc = createSource(range(currentRound + 1))
    const bid = fillObj({}, playerID, defaultSrc)
    const bidSum: number = sum(values(bidMap))

    // Surgery on bid options
    // Rules for bridge game. Last player cannot select the one that will cause sum == currentRound
    if (bidSum <= currentRound) {
      const lastPlayerID: string = last(playerOrder)!
      const delta = currentRound - bidSum
      const option = {value: delta, label: delta + '', disabled: true}

      // All bid in the map points to the same object. A clone on the map is needed before mutating it.
      const clonedOptions = bid[lastPlayerID].slice()
      clonedOptions[delta] = option
      bid[lastPlayerID] = clonedOptions
    }
    return bid
  }

export function changePlayersHandler(rawState: IWaitingBidState | IWaitingWinState, {newNames, rounds, maker, time}: IChangePlayersAction): IWaitingBidState | IEndedState {
  // Short circuit. When action.rounds is less than current round
  if (rounds < rawState.currentRound) {
    // Tslint false positive on shallowed variable -- Shallowed variable on the else branch
    // tslint:disable-next-line: no-shadowed-variable
    const state = toEndedState(rawState, time)
    state.names = newNames
    state.rounds = rounds
    state.scores = mapValues(state.scores, (score: number[]) => score.slice(0, rounds))
    return state
  }

  const state = toWaitingBidState(rawState)
  state.rounds = rounds

  // Set currentPlayerOrder
  const newPlayerIDList = Object.keys(newNames)
  state.currentPlayerOrder = toFront(newPlayerIDList, newPlayerIDList.indexOf(maker))

  // Change scores
  const oldScores = state.scores
  const freshScores = range(state.currentRound - 1).fill(0) // Score for new players. I am terrible at naming.
  state.scores = mapValues(newNames, (_: string, ID: string): number[] => (
    (ID in oldScores)
      ? oldScores[ID]
      : freshScores
  ))

  // Change bid
  const oldBid = state.bid
  state.bid = mapValues(newNames, (_: string, ID: string): number => (
    (ID in oldBid)
      ? oldBid[ID]
      : 0
  ))

  // Change names field lastly
  state.names = newNames

  return state
}

/**
 * Get number of rounds in forms of array that has ended.
 * Like range(endedRounds - 1).
 * For example, if currentRound is 1, then this will return [].
 * If currentRound is 2, then this will return [1].
 * If game has ended at round 13, the this will return [1..13].
 * Null state will return []
 */
function getEndedRounds(entry: NonNullable<GameState>): number[] {
  if (entry.stage === GameStage.ended) {
    return range(1, entry.rounds + 1)
  }
  return range(1, entry.currentRound)
}