import { MODES, PRESTIGE_ICONS, PRESTIGES, SLUMBER_ROOMS, SLUMBER_WALLETS } from "@/data/hypixel/bedwars"
import { getColorFromCode } from "@/lib/colors"
import { formatNumber } from "@/lib/formatters"
import { NonNullStats } from "@/lib/schema/player"
import { concatStatsArray, devide, floorLevel } from "../general"

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 concatBedwarsStats(...stats: BedwarsModeStats[]) {
    if (stats.length === 0) return []

    const summed = concatStatsArray<BedwarsModeStats>([
        "kills_bedwars",
        "deaths_bedwars",
        "final_kills_bedwars",
        "final_deaths_bedwars",
        "wins_bedwars",
        "losses_bedwars",
        "beds_broken_bedwars",
        "beds_lost_bedwars"
    ], ...stats)

    let winstreak = -1
    for (const s of stats) {
        if (s.winstreak !== -1) winstreak = Math.max(winstreak, s.winstreak)
    }

    const ret = {
        ...summed,
        winstreak: winstreak < 0 ? "?" : winstreak,
        kd: devide(summed.kills_bedwars, summed.deaths_bedwars),
        fkd: devide(summed.final_kills_bedwars, summed.final_deaths_bedwars),
        wl: devide(summed.wins_bedwars, summed.losses_bedwars),
        bbl: devide(summed.beds_broken_bedwars, summed.beds_lost_bedwars)
    }

    return [
        ret.kills_bedwars,
        ret.deaths_bedwars,
        ret.kd,
        ret.final_kills_bedwars,
        ret.final_deaths_bedwars,
        ret.fkd,
        ret.wins_bedwars,
        ret.losses_bedwars,
        ret.wl,
        ret.winstreak,
        ret.beds_broken_bedwars,
        ret.beds_lost_bedwars,
        ret.bbl
    ]
}

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

    if (level > 5000) {
        const pres = PRESTIGES.at(-1)!

        return {
            color: pres.color,
            name: pres.name,
            colormap: pres.colormap.split("").map(v => {
                return getColorFromCode(v)
            })
        }
    }

    if (level >= 1000) {
        const pres = PRESTIGES.find(p => p.level === floored)!
        return {
            color: pres.color,
            name: pres.name,
            colormap: pres.colormap.split("").map(v => {
                return getColorFromCode(v)
            })
        }
    }

    const pres = PRESTIGES.find(l => l.level === floored)!
    return {
        color: pres.color,
        name: pres.name,
        colormap: getColorFromCode(pres.colormap)
    }
}

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

    const wallets = SLUMBER_WALLETS as Record<string, number>

    if (!wallets[name]) return 25

    return wallets[name]
}

export function getBedwarsLatestRoom(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
}

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 type BedwarsModeStats = {
    kills_bedwars: number
    deaths_bedwars: number
    final_kills_bedwars: number
    final_deaths_bedwars: number
    wins_bedwars: number
    losses_bedwars: number
    winstreak: number
    beds_broken_bedwars: number
    beds_lost_bedwars: number
}

export function getBestMode(stats: NonNullable<NonNullStats["Bedwars"]>): "solo" | "doubles" | "3s" | "4s" | null {
    const { wins_bedwars: solo } = getBedwarsModeStats("solo", stats, true)
    const { wins_bedwars: doubles } = getBedwarsModeStats("doubles", stats, true)
    const { wins_bedwars: threes } = getBedwarsModeStats("3s", stats, true)
    const { wins_bedwars: fours } = getBedwarsModeStats("4s", stats, true)

    const max = Math.max(solo, doubles, threes, fours)

    switch (max) {
        case solo:
            return "solo"
        case doubles:
            return "doubles"
        case threes:
            return "3s"
        case fours:
            return "4s"
        default:
            return null
    }
}

export function getBedwarsModeStats(mode: Mode, stats: NonNullable<NonNullStats["Bedwars"]>, raw: true): BedwarsModeStats
export function getBedwarsModeStats(mode: Mode, stats: NonNullable<NonNullStats["Bedwars"]>, raw?: false): (string | number)[]
export function getBedwarsModeStats(mode: Mode, stats: NonNullable<NonNullStats["Bedwars"]>, 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: Exclude<typeof MODES[number]["id"], "">, stats: NonNullable<NonNullStats["Bedwars"]>, raw = false) {
    if (raw) {
        return {
            kills_bedwars: stats[`${prefix}_kills_bedwars`],
            deaths_bedwars: stats[`${prefix}_deaths_bedwars`],
            final_kills_bedwars: stats[`${prefix}_final_kills_bedwars`],
            final_deaths_bedwars: stats[`${prefix}_final_deaths_bedwars`],
            wins_bedwars: stats[`${prefix}_wins_bedwars`],
            losses_bedwars: stats[`${prefix}_losses_bedwars`],
            winstreak: stats[`${prefix}_winstreak`] ?? -1,
            beds_broken_bedwars: stats[`${prefix}_beds_broken_bedwars`],
            beds_lost_bedwars: stats[`${prefix}_beds_lost_bedwars`]
        }
    }

    return [
        stats[`${prefix}_kills_bedwars`],
        stats[`${prefix}_deaths_bedwars`],
        formatNumber(devide(stats[`${prefix}_kills_bedwars`], stats[`${prefix}_deaths_bedwars`])),
        stats[`${prefix}_final_kills_bedwars`],
        stats[`${prefix}_final_deaths_bedwars`],
        formatNumber(devide(stats[`${prefix}_final_kills_bedwars`], stats[`${prefix}_final_deaths_bedwars`])),
        stats[`${prefix}_wins_bedwars`],
        stats[`${prefix}_losses_bedwars`],
        formatNumber(devide(stats[`${prefix}_wins_bedwars`], stats[`${prefix}_losses_bedwars`])),
        stats[`${prefix}_winstreak`] ?? "?",
        stats[`${prefix}_beds_broken_bedwars`],
        stats[`${prefix}_beds_lost_bedwars`],
        formatNumber(devide(stats[`${prefix}_beds_broken_bedwars`], stats[`${prefix}_beds_lost_bedwars`]))
    ]
}