import { PRESTIGE_ICONS, PRESTIGES, SLUMBER_ROOMS, SLUMBER_WALLETS } from "@/data/hypixel/bedwars"
import { floorLevel } from "./formatters"

export function getBedwarsStar(level: number) {
    if (level < 1100) {
        return PRESTIGE_ICONS[0].symbol
    }

    if (level > 1100 && level < 2100) {
        return PRESTIGE_ICONS[1].symbol
    }

    if (level > 2100 && level < 3100) {
        return PRESTIGE_ICONS[2].symbol
    }

    return PRESTIGE_ICONS[3].symbol
}

export function getTextColor(level: number) {
    const floored = floorLevel(level, 100)

    if (level > 5000) {
        return PRESTIGES[PRESTIGES.length - 1].color
    }

    return PRESTIGES.find(l => l.level === floored)!.color
}

export function getPrestigeName(level: number) {
    const floored = floorLevel(level, 100)

    if (level > 5000) {
        return PRESTIGES[PRESTIGES.length - 1].name
    }

    return PRESTIGES.find(p => p.level === floored)!.name
}

export function getWalletMax(name?: string) {
    if (!name) return 25

    const wallets = SLUMBER_WALLETS as Record<string, number>

    if (!wallets[name]) return 25

    return wallets[name]
}

export function getLatestRoom(rooms?: Record<string, boolean>) {
    if (!rooms) return null

    let latestRoom = null

    for (const room of SLUMBER_ROOMS) {
        if (rooms[room.id]) {
            latestRoom = room.name
        }
    }

    return latestRoom
}

export type _BedwarsStats = Record<string, number> & { [key: `${string}_winstreak`]: number | undefined }
type Mode =
    | "solo"
    | "doubles"
    | "3s"
    | "4s"
    | "4v4"
    | "rush_2s"
    | "rush_4s"
    | "ultimate_2s"
    | "ultimate_4s"
    | "lucky_2s"
    | "lucky_4s"
    | "voidless_2s"
    | "voidless_4s"
    | "armed_2s"
    | "armed_4s"
    | "swap_4s"
    | "underworld_4s"
    | "castle"

export function getBedwarsModeStats(mode: Mode, stats: _BedwarsStats, raw: true): number[]
export function getBedwarsModeStats(mode: Mode, stats: _BedwarsStats, raw?: false): (string | number)[]
export function getBedwarsModeStats(mode: Mode, stats: _BedwarsStats, raw = false) {
    switch (mode) {
        case "solo":
            return bedwarsModeStats("eight_one", stats, raw)
        case "doubles":
            return bedwarsModeStats("eight_two", stats, raw)
        case "3s":
            return bedwarsModeStats("four_three", stats, raw)
        case "4s":
            return bedwarsModeStats("four_four", stats, raw)
        case "4v4":
            return bedwarsModeStats("two_four", stats, raw)
        case "rush_2s":
            return bedwarsModeStats("eight_two_rush", stats, raw)
        case "rush_4s":
            return bedwarsModeStats("four_four_rush", stats, raw)
        case "ultimate_2s":
            return bedwarsModeStats("eight_two_ultimate", stats, raw)
        case "ultimate_4s":
            return bedwarsModeStats("four_four_ultimate", stats, raw)
        case "lucky_2s":
            return bedwarsModeStats("eight_two_lucky", stats, raw)
        case "lucky_4s":
            return bedwarsModeStats("four_four_lucky", stats, raw)
        case "voidless_2s":
            return bedwarsModeStats("eight_two_voidless", stats, raw)
        case "voidless_4s":
            return bedwarsModeStats("four_four_voidless", stats, raw)
        case "armed_2s":
            return bedwarsModeStats("eight_two_armed", stats, raw)
        case "armed_4s":
            return bedwarsModeStats("four_four_armed", stats, raw)
        case "swap_4s":
            return bedwarsModeStats("four_four_swap", stats, raw)
        case "underworld_4s":
            return bedwarsModeStats("four_four_underworld", stats, raw)
        case "castle":
            return bedwarsModeStats("castle", stats, raw)
        default:
            throw new Error(`${mode satisfies never} does not exist`)
    }
}

function bedwarsModeStats(prefix: string, stats: _BedwarsStats, raw = false) {
    if (raw) {
        return [
            stats[`${prefix}_kills_bedwars`],
            stats[`${prefix}_deaths_bedwars`],
            stats[`${prefix}_kills_bedwars`] / stats[`${prefix}_deaths_bedwars`],
            stats[`${prefix}_final_kills_bedwars`],
            stats[`${prefix}_final_deaths_bedwars`],
            stats[`${prefix}_final_kills_bedwars`] / stats[`${prefix}_final_deaths_bedwars`],
            stats[`${prefix}_wins_bedwars`],
            stats[`${prefix}_losses_bedwars`],
            stats[`${prefix}_wins_bedwars`] / stats[`${prefix}_losses_bedwars`],
            stats[`${prefix}_winstreak`] ?? -1,
            stats[`${prefix}_beds_broken_bedwars`],
            stats[`${prefix}_beds_lost_bedwars`],
            stats[`${prefix}_beds_broken_bedwars`] / stats[`${prefix}_beds_lost_bedwars`]
        ]
    }

    return [
        stats[`${prefix}_kills_bedwars`],
        stats[`${prefix}_deaths_bedwars`],
        (stats[`${prefix}_kills_bedwars`] / stats[`${prefix}_deaths_bedwars`]).toFixed(2),
        stats[`${prefix}_final_kills_bedwars`],
        stats[`${prefix}_final_deaths_bedwars`],
        (stats[`${prefix}_final_kills_bedwars`] / stats[`${prefix}_final_deaths_bedwars`]).toFixed(2),
        stats[`${prefix}_wins_bedwars`],
        stats[`${prefix}_losses_bedwars`],
        (stats[`${prefix}_wins_bedwars`] / stats[`${prefix}_losses_bedwars`]).toFixed(2),
        stats[`${prefix}_winstreak`] ?? "?",
        stats[`${prefix}_beds_broken_bedwars`],
        stats[`${prefix}_beds_lost_bedwars`],
        (stats[`${prefix}_beds_broken_bedwars`] / stats[`${prefix}_beds_lost_bedwars`]).toFixed(2)
    ]
}