import { useEffect, useMemo, useRef, useState } from 'react'
import { useGameAction } from '../../input'
import { getGameMode } from '../../gameRepository'
import { startPvpQueueWithCpuFallback } from '../../pvpQueueLifecycle'
import { summarizeChoiceStacks } from '../../combat/roguelikeUpgrades'
import {
  useDualScreen,
  useDualScreenSetupPublisher,
  useDualScreenWorkshopPublisher,
  type DualScreenSetupState,
  type DualScreenWorkshopState,
} from '../../dualScreen'
import { BossArenaScreen } from './screens/BossArenaScreen'
import {
  Iwt2CloudSaveScreen,
  Iwt2CustomizeCharacterScreen,
  Iwt2DungeonsScreen,
  Iwt2GearUpgradeScreen,
  Iwt2HunterProfileScreen,
  Iwt2ModeScreen,
  Iwt2RoguelikeScreen,
  Iwt2RoguelikeUpgradeScreen,
  Iwt2SettingsScreen,
} from './screens/Iwt2ShellScreens'
import {
  loadIwt2Save,
  writeIwt2Save,
  type Iwt2Save,
} from './save/iwt2Repository'
import { IWT2_BOSS_METADATA, type Iwt2BossId } from './content/bosses'
import { iwt2BossCoinRewardFor } from './content/bossRewards'
import {
  findIwt2Difficulty,
  IWT2_DUNGEON_DIFFICULTIES,
  IWT2_RAID_DIFFICULTIES,
  type Iwt2Difficulty,
} from './content/difficulties'
import { abilitiesForHealer, IWT2_HEALER_METADATA } from './content/healerAbilities'
import {
  buildIwt2OpponentDebuffChoices,
  buildIwt2SelfBuffChoices,
  IWT2_REVIVE_PARTY_CHOICE,
  type Iwt2RoguelikeChoice,
  type Iwt2RoguelikeContentType,
  type Iwt2RoguelikeOpponentDebuffId,
  type Iwt2RoguelikeSelfBuffId,
  type Iwt2RoguelikeVariant,
} from './content/roguelike'
import {
  createIwt2WeightedRoguelikeBossPair,
  createUniformIwt2RoguelikeBossPair,
  enabledIwt2RoguelikeBossPool,
  IWT2_PVP_ROGUELIKE_BOSS_ROSTER_LIMIT_ENABLED,
  IWT2_PVP_ROGUELIKE_ENABLED_BOSS_IDS,
  IWT2_PVP_STADIUM_BOSS_ROSTER_LIMIT_ENABLED,
  IWT2_PVP_STADIUM_ENABLED_BOSS_IDS,
  IWT2_PVE_ROGUELIKE_WEIGHTED_BOSS_PROGRESSION_ENABLED,
  IWT2_PVP_ROGUELIKE_WEIGHTED_BOSS_PROGRESSION_ENABLED,
  IWT2_PVP_STADIUM_WEIGHTED_BOSS_PROGRESSION_ENABLED,
} from './content/roguelikeBossProgression'

type Iwt2Screen =
  | 'menu'
  | 'arena'
  | 'cloud-save'
  | 'dungeons'
  | 'raids'
  | 'roguelike'
  | 'roguelike-arena'
  | 'roguelike-upgrade'
  | 'gear-upgrade'
  | 'hunter-profile'
  | 'customize-character'
  | 'settings'

const IWT2_MENU_COLUMNS = 2
const IWT2_ROGUELIKE_CHOICE_COUNT = 3
const IWT2_PVP_FIRST_BUFF_EXTRA_TARGET_CHANCE = 0.65
const IWT2_ROGUELIKE_GREEN_COIN_BOSS_THRESHOLD = 5

type Iwt2RoguelikeRunState = {
  bossIds: Iwt2BossId[]
  bossesDefeated: number
  buffs: Iwt2RoguelikeSelfBuffId[]
  contentType: Iwt2RoguelikeContentType
  debuffs: Iwt2RoguelikeOpponentDebuffId[]
  debuffChoices: Array<Iwt2RoguelikeChoice<Iwt2RoguelikeOpponentDebuffId>>
  selfChoices: Array<Iwt2RoguelikeChoice<Iwt2RoguelikeSelfBuffId>>
  stage: number
  variant: Iwt2RoguelikeVariant
}

const MENU_ITEMS: Array<{
  screen: Iwt2Screen
  title: string
  description: string
  glyph: string
}> = [
  {
    screen: 'dungeons',
    title: 'Dungeons',
    description: 'Queue into seven modular IWT2 boss arenas.',
    glyph: 'D',
  },
  {
    screen: 'raids',
    title: 'Raids',
    description: 'Open raid assignments built from active IWT2 boss mechanics.',
    glyph: 'R',
  },
  {
    screen: 'roguelike',
    title: 'Roguelike',
    description: 'Draft upgrades through escalating random encounters.',
    glyph: 'L',
  },
  {
    screen: 'roguelike',
    title: 'PvP',
    description: 'Race another healer through roguelike encounters with buffs and sabotage.',
    glyph: 'P',
  },
  {
    screen: 'gear-upgrade',
    title: 'Gear Upgrade',
    description: 'Spend boss coins on class gear slots and infusion abilities.',
    glyph: 'G',
  },
  {
    screen: 'hunter-profile',
    title: 'Hunter Profile',
    description: 'IWT2 level, inventory summary, and collection log.',
    glyph: 'H',
  },
  {
    screen: 'customize-character',
    title: 'Customize Character',
    description: 'Choose healer kit, armor palette, and IWT2 hunter callsign.',
    glyph: 'K',
  },
  {
    screen: 'cloud-save',
    title: 'Backup Slot',
    description: 'Choose local, online, or fresh IWT2 progress.',
    glyph: 'C',
  },
  {
    screen: 'settings',
    title: 'Settings',
    description: 'IWT2 targeting preference and controller icon style.',
    glyph: 'S',
  },
]

export function IWantToHeal2App({
  onlineBackupsAvailable,
  onBackToGameSelect,
}: {
  onlineBackupsAvailable: boolean
  onBackToGameSelect: () => void
}) {
  const { enabled: dualScreenEnabled } = useDualScreen()
  const [screen, setScreen] = useState<Iwt2Screen>('menu')
  const [save, setSave] = useState<Iwt2Save>(loadIwt2Save)
  const [selectedIndex, setSelectedIndex] = useState(0)
  const [selectedBossId, setSelectedBossId] = useState<Iwt2BossId>('bulldrome')
  const [arenaModeLabel, setArenaModeLabel] = useState('Dungeon')
  const [arenaDifficulty, setArenaDifficulty] = useState<Iwt2Difficulty>(IWT2_DUNGEON_DIFFICULTIES[0])
  const [selectedDungeonDifficultySlug, setSelectedDungeonDifficultySlug] = useState(IWT2_DUNGEON_DIFFICULTIES[0].slug)
  const [selectedRaidDifficultySlug, setSelectedRaidDifficultySlug] = useState(IWT2_RAID_DIFFICULTIES[0].slug)
  const [roguelikeVariant, setRoguelikeVariant] = useState<Iwt2RoguelikeVariant>('pve')
  const [roguelikeContentType, setRoguelikeContentType] = useState<Iwt2RoguelikeContentType>('dungeon')
  const [roguelikeRun, setRoguelikeRun] = useState<Iwt2RoguelikeRunState | null>(null)
  const [pvpQueueMessage, setPvpQueueMessage] = useState('')
  const [pvpQueueing, setPvpQueueing] = useState(false)
  const cancelPvpQueueRef = useRef<(() => void) | null>(null)

  useEffect(() => {
    writeIwt2Save(save)
  }, [save])

  useEffect(() => () => {
    cancelPvpQueueRef.current?.()
  }, [])

  function cancelIwt2PvpQueue() {
    cancelPvpQueueRef.current?.()
    cancelPvpQueueRef.current = null
    setPvpQueueing(false)
    setPvpQueueMessage('')
  }

  const setupDualScreenState = useMemo<DualScreenSetupState | null>(
    () => buildIwt2SetupDualScreenState(screen, selectedBossId, save, currentSetupDifficulty(screen, selectedDungeonDifficultySlug, selectedRaidDifficultySlug)),
    [save, screen, selectedBossId, selectedDungeonDifficultySlug, selectedRaidDifficultySlug],
  )
  const workshopDualScreenState = useMemo<DualScreenWorkshopState | null>(
    () => buildIwt2WorkshopDualScreenState(screen, save),
    [save, screen],
  )

  useDualScreenSetupPublisher(setupDualScreenState, dualScreenEnabled)
  useDualScreenWorkshopPublisher(workshopDualScreenState, dualScreenEnabled)

  useGameAction((action, device) => {
    if (screen !== 'menu' || device !== 'controller') return
    if (action === 'back') {
      onBackToGameSelect()
      return
    }
    if (action === 'confirm') {
      openMenuItem(MENU_ITEMS[selectedIndex])
      return
    }
    if (action === 'navigateUp' || action === 'navigateLeft') {
      const offset = action === 'navigateUp' ? IWT2_MENU_COLUMNS : 1
      setSelectedIndex((current) => Math.max(0, current - offset))
    } else if (action === 'navigateDown' || action === 'navigateRight') {
      const offset = action === 'navigateDown' ? IWT2_MENU_COLUMNS : 1
      setSelectedIndex((current) => Math.min(MENU_ITEMS.length - 1, current + offset))
    }
  })

  function openMenuItem(item: (typeof MENU_ITEMS)[number]) {
    if (item.title === 'PvP') {
      setRoguelikeVariant('pvp')
      setScreen('roguelike')
      return
    }
    if (item.title === 'Roguelike') {
      setRoguelikeVariant('pve')
      setRoguelikeContentType((current) => current === 'stadium' ? 'dungeon' : current)
    }
    setScreen(item.screen)
  }

  if (screen === 'arena') {
    return (
      <BossArenaScreen
        bossId={selectedBossId}
        difficulty={arenaDifficulty}
        key={`arena-${selectedBossId}-${arenaModeLabel}-${arenaDifficulty.slug}`}
        modeLabel={arenaModeLabel}
        save={save}
        onBack={() => setScreen('menu')}
        onSaveUpdated={setSave}
      />
    )
  }

  if (screen === 'roguelike-arena' && roguelikeRun) {
    return (
      <BossArenaScreen
        bossIds={roguelikeRun.bossIds}
        bossId={selectedBossId}
        key={`roguelike-${roguelikeRun.variant}-${roguelikeRun.contentType}-${roguelikeRun.stage}-${roguelikeRun.bossIds.join('-')}`}
        roguelikeRun={{
          buffs: roguelikeRun.buffs,
          contentType: roguelikeRun.contentType,
          debuffs: roguelikeRun.debuffs,
          greenCoinThreshold: IWT2_ROGUELIKE_GREEN_COIN_BOSS_THRESHOLD,
          bossesDefeated: roguelikeRun.bossesDefeated,
          onVictory: () => {
            setRoguelikeRun((current) => current
              ? {
                  ...current,
                  bossesDefeated: current.bossesDefeated + current.bossIds.length,
                  ...buildRoguelikeChoices(save, current.variant),
                }
              : current)
            setScreen('roguelike-upgrade')
          },
          stage: roguelikeRun.stage,
          variant: roguelikeRun.variant,
        }}
        save={save}
        onBack={() => setScreen('roguelike')}
        onMainMenu={() => setScreen('menu')}
        onPvpRequeue={() => {
          setScreen('roguelike')
          startIwt2RoguelikeRun()
        }}
        onSaveUpdated={setSave}
      />
    )
  }

  if (screen === 'roguelike-upgrade' && roguelikeRun) {
    return (
      <main className="game-shell iwt2-shell">
        <Iwt2Header save={save} onBackToGameSelect={onBackToGameSelect} />
        <Iwt2RoguelikeUpgradeScreen
          activeBuffSummary={summarizeIwt2Buffs(save, roguelikeRun.buffs)}
          activeDebuffSummary={summarizeIwt2Debuffs(save, roguelikeRun.debuffs)}
          contentType={roguelikeRun.contentType}
          debuffChoices={roguelikeRun.debuffChoices}
          selfChoices={roguelikeRun.selfChoices}
          stage={roguelikeRun.stage}
          variant={roguelikeRun.variant}
          onBack={() => setScreen('roguelike')}
          onChoose={(buffId, debuffId) => {
            const nextRun = applyRoguelikeChoice(roguelikeRun, buffId, debuffId, save)
            setRoguelikeRun(nextRun)
            setSelectedBossId(nextRun.bossIds[0] ?? 'bulldrome')
            setScreen('roguelike-arena')
          }}
        />
      </main>
    )
  }

  if (screen === 'dungeons') {
    return (
      <main className="game-shell iwt2-shell">
        <Iwt2Header save={save} onBackToGameSelect={onBackToGameSelect} />
        <Iwt2DungeonsScreen
          difficultySlug={selectedDungeonDifficultySlug}
          save={save}
          onBack={() => setScreen('menu')}
          onDifficultyChange={setSelectedDungeonDifficultySlug}
          onOpenBoss={(bossId, difficulty) => {
            setArenaModeLabel(`${difficulty.name} Dungeon`)
            setArenaDifficulty(difficulty)
            setSelectedBossId(bossId)
            setScreen('arena')
          }}
          onPreviewBoss={setSelectedBossId}
        />
      </main>
    )
  }

  if (screen === 'roguelike') {
    return (
      <main className="game-shell iwt2-shell">
        <Iwt2Header save={save} onBackToGameSelect={onBackToGameSelect} />
        <Iwt2RoguelikeScreen
          contentType={roguelikeContentType}
          variant={roguelikeVariant}
          onBack={() => {
            cancelIwt2PvpQueue()
            setScreen('menu')
          }}
          onCancelQueue={cancelIwt2PvpQueue}
          onContentTypeChange={setRoguelikeContentType}
          onStart={() => {
            startIwt2RoguelikeRun()
          }}
          onVariantChange={(nextVariant) => {
            cancelIwt2PvpQueue()
            setRoguelikeVariant(nextVariant)
            if (nextVariant === 'pve' && roguelikeContentType === 'stadium') {
              setRoguelikeContentType('dungeon')
            }
          }}
          queueing={pvpQueueing}
          queueMessage={pvpQueueMessage}
        />
      </main>
    )
  }

  if (screen === 'raids') {
    return (
      <main className="game-shell iwt2-shell">
        <Iwt2Header save={save} onBackToGameSelect={onBackToGameSelect} />
        <Iwt2ModeScreen
          difficultySlug={selectedRaidDifficultySlug}
          mode="Raids"
          save={save}
          onBack={() => setScreen('menu')}
          onDifficultyChange={setSelectedRaidDifficultySlug}
          onOpenBoss={(bossId, difficulty) => {
            setArenaModeLabel(`${difficulty.name} Raid`)
            setArenaDifficulty(difficulty)
            setSelectedBossId(bossId)
            setScreen('arena')
          }}
          onPreviewBoss={setSelectedBossId}
        />
      </main>
    )
  }

  if (screen === 'hunter-profile') {
    return (
      <main className="game-shell iwt2-shell">
        <Iwt2HunterProfileScreen save={save} onBack={() => setScreen('menu')} />
      </main>
    )
  }

  if (screen === 'gear-upgrade') {
    return (
      <main className="game-shell iwt2-shell">
        <Iwt2Header
          save={save}
          title="Gear Upgrade"
          onBack={() => setScreen('menu')}
          onBackToGameSelect={onBackToGameSelect}
        />
        <Iwt2GearUpgradeScreen
          save={save}
          onBack={() => setScreen('menu')}
          onSaveUpdated={setSave}
        />
      </main>
    )
  }

  if (screen === 'customize-character') {
    return (
      <main className="game-shell iwt2-shell">
        <Iwt2Header save={save} onBackToGameSelect={onBackToGameSelect} />
        <Iwt2CustomizeCharacterScreen
          save={save}
          onBack={() => setScreen('menu')}
          onSaveUpdated={setSave}
        />
      </main>
    )
  }

  if (screen === 'cloud-save') {
    return (
      <main className="game-shell iwt2-shell">
        <Iwt2Header save={save} onBackToGameSelect={onBackToGameSelect} />
        <Iwt2CloudSaveScreen
          save={save}
          onlineBackupsAvailable={onlineBackupsAvailable}
          onBack={() => setScreen('menu')}
          onSaveUpdated={setSave}
        />
      </main>
    )
  }

  if (screen === 'settings') {
    return (
      <main className="game-shell iwt2-shell">
        <Iwt2Header save={save} onBackToGameSelect={onBackToGameSelect} />
        <Iwt2SettingsScreen onBack={() => setScreen('menu')} />
      </main>
    )
  }

  return (
    <main className="game-shell iwt2-shell">
      <Iwt2Header save={save} onBackToGameSelect={onBackToGameSelect} />

      {screen === 'menu' && (
        <section className="iwt2-menu-screen" data-game-nav-active="true">
          <div className="iwt2-menu-grid">
            {MENU_ITEMS.map((item, index) => (
              <button
                className={`iwt2-menu-card ${selectedIndex === index ? 'game-selected' : ''}`}
                aria-label={`${item.title}. ${item.description}`}
                data-controller-nav="skip"
                data-game-selected={selectedIndex === index ? 'true' : undefined}
                key={`${item.screen}-${item.title}`}
                onClick={() => openMenuItem(item)}
                onPointerDown={() => setSelectedIndex(index)}
                type="button"
              >
                <span>{item.glyph}</span>
                <div>
                  <strong>{item.title}</strong>
                  <small>{item.description}</small>
                </div>
              </button>
            ))}
          </div>
        </section>
      )}
    </main>
  )

  function startIwt2RoguelikeRun() {
    cancelIwt2PvpQueue()
    if (roguelikeVariant !== 'pvp') {
      beginIwt2RoguelikeArena(roguelikeVariant, roguelikeContentType)
      return
    }
    const startStage = 1
    setPvpQueueing(true)
    setPvpQueueMessage('Queuing for PvP...')
    cancelPvpQueueRef.current = startPvpQueueWithCpuFallback<unknown>({
      contentType: roguelikeContentType,
      startStage,
      gameMode: getGameMode(),
      liveMatchActive: () => false,
      onSearching: (message) => {
        setPvpQueueing(true)
        setPvpQueueMessage(message)
      },
      onCpuMatch: (_difficulty, message) => {
        cancelPvpQueueRef.current = null
        setPvpQueueing(false)
        setPvpQueueMessage(message)
        beginIwt2RoguelikeArena('pvp', roguelikeContentType)
      },
      onLiveMatch: (...liveMatchArgs) => {
        const message = liveMatchArgs[2]
        cancelPvpQueueRef.current = null
        setPvpQueueing(false)
        setPvpQueueMessage(message)
        beginIwt2RoguelikeArena('pvp', roguelikeContentType)
      },
      messages: {
        offline: (difficulty) => `Offline mode. CPU ${difficulty} enters IWT2 ${formatRoguelikeContentType(roguelikeContentType)}.`,
        searching: `Searching IWT2 ${formatRoguelikeContentType(roguelikeContentType)} queue for 5s.`,
        notFound: (difficulty) => `No IWT2 opponent found after 5s. CPU ${difficulty} steps in.`,
        unavailable: (difficulty) => `PvP server unavailable. CPU ${difficulty} steps in.`,
        liveFound: () => `Opponent found. Starting IWT2 ${formatRoguelikeContentType(roguelikeContentType)} race.`,
      },
    })
  }

  function beginIwt2RoguelikeArena(
    variant: Iwt2RoguelikeVariant,
    contentType: Iwt2RoguelikeContentType,
  ) {
    const nextRun = createRoguelikeRun(save, variant, contentType)
    setRoguelikeRun(nextRun)
    setSelectedBossId(nextRun.bossIds[0] ?? 'bulldrome')
    setScreen('roguelike-arena')
  }
}

function formatRoguelikeContentType(contentType: Iwt2RoguelikeContentType) {
  if (contentType === 'raid') return 'Raid'
  if (contentType === 'stadium') return 'Stadium'
  return 'Dungeon'
}

function createRoguelikeRun(
  save: Iwt2Save,
  variant: Iwt2RoguelikeVariant,
  contentType: Iwt2RoguelikeContentType,
): Iwt2RoguelikeRunState {
  return {
    bossIds: createRoguelikeBossPair(variant, contentType, 1, 0),
    bossesDefeated: 0,
    buffs: [],
    contentType,
    debuffs: [],
    ...buildRoguelikeChoices(save, variant),
    stage: 1,
    variant,
  }
}

function buildRoguelikeChoices(save: Iwt2Save, variant: Iwt2RoguelikeVariant) {
  const abilities = abilitiesForHealer(save.character.healerStyle)
  const selfCatalog = [IWT2_REVIVE_PARTY_CHOICE, ...buildIwt2SelfBuffChoices(abilities)]
  const debuffCatalog = buildIwt2OpponentDebuffChoices(abilities)
  return {
    selfChoices: variant === 'pvp'
      ? chooseRunChoicesWithPreferredFirst(
          selfCatalog,
          IWT2_ROGUELIKE_CHOICE_COUNT,
          isExtraTargetBuff,
          IWT2_PVP_FIRST_BUFF_EXTRA_TARGET_CHANCE,
        )
      : chooseRunChoices(selfCatalog, IWT2_ROGUELIKE_CHOICE_COUNT),
    debuffChoices: variant === 'pvp'
      ? chooseRunChoices(debuffCatalog, IWT2_ROGUELIKE_CHOICE_COUNT)
      : [],
  }
}

function summarizeIwt2Buffs(save: Iwt2Save, buffs: Iwt2RoguelikeSelfBuffId[]) {
  if (buffs.length === 0) return ''
  const abilities = abilitiesForHealer(save.character.healerStyle)
  return summarizeChoiceStacks(
    buffs,
    [IWT2_REVIVE_PARTY_CHOICE, ...buildIwt2SelfBuffChoices(abilities)],
    'None',
  )
}

function summarizeIwt2Debuffs(save: Iwt2Save, debuffs: Iwt2RoguelikeOpponentDebuffId[]) {
  if (debuffs.length === 0) return ''
  const abilities = abilitiesForHealer(save.character.healerStyle)
  return summarizeChoiceStacks(
    debuffs,
    buildIwt2OpponentDebuffChoices(abilities),
    'None',
  )
}

function applyRoguelikeChoice(
  run: Iwt2RoguelikeRunState,
  buffId: Iwt2RoguelikeSelfBuffId,
  debuffId: Iwt2RoguelikeOpponentDebuffId | undefined,
  save: Iwt2Save,
): Iwt2RoguelikeRunState {
  const nextDebuffs = debuffId ? [...run.debuffs, debuffId] : run.debuffs
  const nextBase = buffId === IWT2_REVIVE_PARTY_CHOICE.id
    ? {
        buffs: run.buffs,
        debuffs: nextDebuffs.slice(1),
      }
    : {
        buffs: [...run.buffs, buffId],
        debuffs: nextDebuffs,
      }
  return {
    ...run,
    ...nextBase,
    bossIds: createRoguelikeBossPair(run.variant, run.contentType, run.stage + 1, run.bossesDefeated),
    ...buildRoguelikeChoices(save, run.variant),
    stage: run.stage + 1,
  }
}

function createRoguelikeBossPair(
  variant: Iwt2RoguelikeVariant,
  contentType: Iwt2RoguelikeContentType,
  stage: number,
  bossesDefeated: number,
): Iwt2BossId[] {
  const weightedProgressionEnabled = variant === 'pve'
    ? IWT2_PVE_ROGUELIKE_WEIGHTED_BOSS_PROGRESSION_ENABLED
    : contentType === 'stadium'
      ? IWT2_PVP_STADIUM_WEIGHTED_BOSS_PROGRESSION_ENABLED
      : IWT2_PVP_ROGUELIKE_WEIGHTED_BOSS_PROGRESSION_ENABLED
  const bossPool = roguelikeBossPoolFor(variant, contentType)
  const count = bossesDefeated >= IWT2_ROGUELIKE_GREEN_COIN_BOSS_THRESHOLD ? 3 : 2

  if (weightedProgressionEnabled) {
    return createIwt2WeightedRoguelikeBossPair(stage, Math.random, { bossPool, count })
  }
  return createUniformIwt2RoguelikeBossPair(Math.random, { bossPool, count })
}

function roguelikeBossPoolFor(
  variant: Iwt2RoguelikeVariant,
  contentType: Iwt2RoguelikeContentType,
): Iwt2BossId[] | undefined {
  if (variant !== 'pvp') return undefined
  if (contentType === 'stadium') {
    return IWT2_PVP_STADIUM_BOSS_ROSTER_LIMIT_ENABLED
      ? enabledIwt2RoguelikeBossPool(IWT2_PVP_STADIUM_ENABLED_BOSS_IDS)
      : undefined
  }
  return IWT2_PVP_ROGUELIKE_BOSS_ROSTER_LIMIT_ENABLED
    ? enabledIwt2RoguelikeBossPool(IWT2_PVP_ROGUELIKE_ENABLED_BOSS_IDS)
    : undefined
}

function chooseRunChoices<T>(items: readonly T[], count: number): T[] {
  const pool = [...items]
  const choices: T[] = []
  while (pool.length > 0 && choices.length < count) {
    const index = Math.floor(Math.random() * pool.length)
    const [choice] = pool.splice(index, 1)
    if (choice) choices.push(choice)
  }
  return choices
}

function chooseRunChoicesWithPreferredFirst<T>(
  items: readonly T[],
  count: number,
  preferred: (item: T) => boolean,
  preferredChance: number,
): T[] {
  if (count <= 0) return []
  const pool = [...items]
  const choices: T[] = []
  const preferredPool = pool.filter(preferred)
  if (preferredPool.length > 0 && Math.random() < preferredChance) {
    const preferredChoice = preferredPool[Math.floor(Math.random() * preferredPool.length)]
    const preferredIndex = pool.indexOf(preferredChoice)
    if (preferredIndex >= 0) {
      const [choice] = pool.splice(preferredIndex, 1)
      if (choice) choices.push(choice)
    }
  }
  while (pool.length > 0 && choices.length < count) {
    const index = Math.floor(Math.random() * pool.length)
    const [choice] = pool.splice(index, 1)
    if (choice) choices.push(choice)
  }
  return choices
}

function isExtraTargetBuff(choice: Iwt2RoguelikeChoice<Iwt2RoguelikeSelfBuffId>) {
  return choice.id.endsWith('-extra-target')
}

function Iwt2Header({
  onBack,
  onBackToGameSelect,
  save,
  title,
}: {
  onBack?: () => void
  onBackToGameSelect: () => void
  save: Iwt2Save
  title?: string
}) {
  return (
    <header className="topbar app-header">
      <button className="brand-button" onClick={onBackToGameSelect} type="button">
        <strong>Games</strong>
      </button>
      {title && <strong className="iwt2-header-title">{title}</strong>}
      <div className="character-summary">
        <strong>{save.character.name}</strong>
        <small>IWT2 Level {save.character.level}</small>
        <small>{save.character.experience} XP</small>
      </div>
      {onBack && (
        <button className="back-button iwt2-header-back" data-controller-nav="skip" onClick={onBack} type="button">
          Back
        </button>
      )}
    </header>
  )
}

function buildIwt2SetupDualScreenState(
  screen: Iwt2Screen,
  selectedBossId: Iwt2BossId,
  save: Iwt2Save,
  difficulty: Iwt2Difficulty,
): DualScreenSetupState | null {
  if (screen !== 'dungeons' && screen !== 'raids') return null
  const boss = IWT2_BOSS_METADATA[selectedBossId]
  const raid = screen === 'raids'
  const coinReward = iwt2BossCoinRewardFor(selectedBossId, difficulty.slug)
  return {
    contentType: raid ? 'raid' : 'dungeon',
    description: raid
      ? `${boss.name} raid assignment. Tank holds aggro while party moves around modular boss mechanics. Reward: ${coinReward.name}.`
      : `${boss.name} arena. Heal the party through melee pressure, telegraphs, hazards, and stun recovery. Reward: ${coinReward.name}.`,
    difficultyName: difficulty.name,
    experience: Math.round(125 * difficulty.experienceMultiplier),
    initials: boss.icon,
    itemLevel: difficulty.droppedItemLevel,
    lockedReason: undefined,
    stats: {
      damage: `${difficulty.damageMultiplier.toFixed(2)}x`,
      health: `${difficulty.healthMultiplier.toFixed(2)}x`,
      loot: coinReward.name,
      xp: `${difficulty.experienceMultiplier.toFixed(1)}x`,
    },
    subtitle: `${raid ? 'Raid' : 'Dungeon'} | 6 Players | ${IWT2_HEALER_METADATA[save.character.healerStyle].name}`,
    title: raid ? `${boss.name} Raid` : `${boss.name} Arena`,
  }
}

function currentSetupDifficulty(
  screen: Iwt2Screen,
  selectedDungeonDifficultySlug: string,
  selectedRaidDifficultySlug: string,
): Iwt2Difficulty {
  if (screen === 'raids') {
    return findIwt2Difficulty(IWT2_RAID_DIFFICULTIES, selectedRaidDifficultySlug)
  }
  return findIwt2Difficulty(IWT2_DUNGEON_DIFFICULTIES, selectedDungeonDifficultySlug)
}

function buildIwt2WorkshopDualScreenState(
  screen: Iwt2Screen,
  save: Iwt2Save,
): DualScreenWorkshopState | null {
  if (screen === 'customize-character') {
    const healer = IWT2_HEALER_METADATA[save.character.healerStyle]
    return {
      items: abilitiesForHealer(save.character.healerStyle).map((ability) => ({
        glyph: ability.icon,
        meta: `${ability.manaCost} Mana | ${ability.cooldownSeconds}s cooldown`,
        status: `Slot ${ability.slot}`,
        title: ability.name,
      })),
      mode: 'class',
      subtitle: healer.description,
      summary: healer.name,
      title: 'Customize Character',
    }
  }

  return null
}