SMODS.Sound({key = "enlightened", path = "enlightened.ogg"})
SMODS.Sound({key = "warning_heartbeat", path = "warning_heartbeat.ogg"})

for i = 1, 8 do
    SMODS.Sound({key = "gore" .. i, path = "gore" .. i .. ".ogg"})
end

SMODS.Sound({
    key = "music_attuned",
    path = "music_attuned.ogg",
    volume = 1,
    select_music_track = function()
        for _, v in pairs(SMODS.find_card("j_jane_saint")) do
            if v.ability.extra.is_attuned then
                return 201
            end
        end

        return -1 / 0
    end,
})

SMODS.Sound({
    key = "music_attuned_sinister",
    path = "music_attuned_sinister.ogg",
    volume = 1,
    select_music_track = function()
        if not Jane.sinister then
            return -1 / 0
        end

        for _, v in pairs(SMODS.find_card("j_jane_saint")) do
            if v.ability.extra.is_attuned then
                return 202
            end
        end

        return -1 / 0
    end,
})

for _, v in pairs({
    "artificer",
    "hunter",
    "gourmand",
    "monk",
    "rivulet",
    "rot",
    "saint",
    "spearmaster",
    "survivor",
}) do
    SMODS.Atlas {
        key = "jane" .. v,
        px = 71,
        py = 95,
        path = Jane.config.texture_pack .. "/j_jane_" .. v .. ".png",
    }
end

local epic = Jane.cry and "cry_epic" or 3
local exotic = Jane.cry and "cry_exotic" or 4

SMODS.Rarity {
    key = "junk",
    default_weight = 0.05,
    pools = {Joker = true},
    loc_txt = {name = "Junk"},
    badge_colour = G.C.JOKER_GREY,
}

local monk_limit = 25

SMODS.Joker {
    key = "monk",
    atlas = "janemonk",
    loc_txt = {
        name = "The Monk",
        text = {
            "{C:attention}Retrigger {}scored",
            "cards {C:attention}#1# time#2# {}if",
            "hand contains {C:attention}#3#",
            "or fewer card#4#",
        },
    },
    config = {extra = {retriggers = 2, requirement = 4}},
    pos = {x = 0, y = 0},
    soul_pos = {x = 1, y = 0},
    cost = 20,
    rarity = 4,
    blueprint_compat = true,
    loc_vars = function(_, _, card)
        local extra = card.ability.extra
        local retriggers = extra.retriggers
        local requirement = extra.requirement

        return {
            vars = {
                retriggers,
                retriggers == 1 and "" or "s",
                requirement,
                requirement == 1 and "" or "s",
            },
        }
    end,
    calculate = function(_, card, context)
        if not context.repetition or
            context.cardarea ~= G.play or not
            context.other_card or
            #G.play.cards > card.ability.extra.requirement then
            return
        end

        local min = math.min(card.ability.extra.retriggers, monk_limit)
        card.ability.extra.retriggers = min

        return {
            card = card,
            repetitions = min,
            colour = G.C.ORANGE,
            message = localize("k_again_ex"),
        }, true
    end,
}

SMODS.Joker {
    key = "survivor",
    atlas = "janesurvivor",
    loc_txt = {
        name = "The Survivor",
        text = {
            "All cards held in",
            "hand also {C:attention}score" .. (Jane.cry and " {}and" or ""),
            Jane.cry and "considered as the" or nil,
            Jane.cry and "{C:attention}first {}played card" or nil,
        },
    },
    pos = {x = 0, y = 0},
    soul_pos = {x = 1, y = 0},
    cost = 20,
    rarity = 4,
}

local hunter = {5, 4, 3, 2, 1}

SMODS.Joker {
    key = "hunter",
    atlas = "janehunter",
    loc_txt = {
        name = "The Hunter",
        text = {
            "{E:1}Succumbs to the {X:black,C:white,E:1}Rot{},",
            (Jane.cry and "creating an {C:spectral}Empowered" or "creating a {C:dark_edition}Negative"),
            (Jane.cry and "{C:spectral}Tag" or "{C:spectral}Soul") .. " {}after #1#",
        },
    },
    config = {extra = {rounds_left = hunter[1]}},
    pos = {x = 0, y = 0},
    eternal_compat = false,
    blueprint_compat = false,
    perishable_compat = false,
    soul_pos = {x = 1, y = 0},
    cost = Jane.cry and 15 or 8,
    rarity = Jane.cry and epic or 3,
    loc_vars = function(_, info_queue, card)
        local function rounds(amount)
            return " round" .. ((math.abs(amount) > 1 or math.abs(amount) == 0) and "s" or "")
        end

        info_queue[#info_queue + 1] = G.P_CENTERS.j_jane_rot
        info_queue[#info_queue + 1] = Jane.cry and G.P_CENTERS.c_cry_empowered or G.P_CENTERS.c_soul
        local rounds_left = card.ability.extra.rounds_left
        local sold = rounds_left - hunter[5]

        return {
            vars = {
                rounds_left .. rounds(rounds_left) .. (rounds_left <= 0 and "...?" or ""),
                sold <= 0 and "" or " after " .. sold .. rounds(sold),
                sold <= 0 and " into" or "",
                sold <= 0 and "" or "into ",
            },
        }
    end,
    update = function(_, card, _)
        if card.added_to_deck and card.children.center and card.children.floating_sprite then
            for k, v in ipairs(hunter) do
                if card.ability.extra.rounds_left <= v then
                    card.children.center:set_sprite_pos({x = 0, y = k - 1})
                    card.children.floating_sprite:set_sprite_pos({x = 1, y = k - 1})
                else
                    break
                end
            end
        end
    end,
    calculate = function(_, card, context)
        local function spawn_rot()
            card:flip()
            card:juice_up(2, 0.8)
            card.getting_sliced = true
            Jane.card_status_text(card, "Dead!", nil, 0.05 * card.T.h, G.C.BLACK, 2, 0, 0, nil, "bm", "jane_gore6")

            Jane.q(function()
                local rot = create_card("Joker", G.jokers, nil, nil, nil, nil, "j_jane_rot", "hunter_rot_death")
                rot:add_to_deck()
                G.jokers:emplace(rot)
                card:set_eternal(nil)
                rot:set_eternal(true)
                rot:set_edition(card.edition)
                play_sound("jane_gore5")
            end)

            Jane.q(function()
                card:start_dissolve()
            end, 1)
        end

        local function die()
            Jane.q(function()
                Jane.empowered()
            end, 0.1)

            spawn_rot()
        end

        if context.blueprint or
            context.individual or
            context.repetition or
            context.retrigger_joker or
            not context.end_of_round then
            return
        end

        card.ability.extra.rounds_left = card.ability.extra.rounds_left - 1
        local rl = card.ability.extra.rounds_left
        Jane.card_status_text(card, tostring(card.ability.extra.rounds_left), nil, nil, G.C.RED, nil, nil, nil, nil,
            nil, "generic1")

        if rl > hunter[2] then
            card:juice_up(0.6, 0.1)
        elseif rl > hunter[3] then
            if rl == hunter[2] then
                Jane.play_sound("jane_gore1")
            end

            card:juice_up(0.6, 0.1)
        elseif rl > hunter[4] then
            if rl == hunter[3] then
                Jane.play_sound("jane_gore3")
            end

            card:juice_up(0.6, 0.1)
        elseif rl > hunter[5] then
            if rl == hunter[4] then
                Jane.play_sound("jane_gore8")
            end

            card:juice_up(0.6, 0.1)
            Jane.play_sound("jane_warning_heartbeat")
        elseif rl > 0 then
            if rl == hunter[5] then
                Jane.play_sound("jane_gore4")
            end

            card:juice_up(1.8, 0.3)
            Jane.play_sound("jane_warning_heartbeat")
        else
            card:juice_up(2, 0.8)
            Jane.play_sound("jane_warning_heartbeat")
            Jane.q(die, 0)
        end
    end,
}

SMODS.Joker {
    key = "gourmand",
    atlas = "janegourmand",
    loc_txt = {
        name = "The Gourmand",
        text = {"All cards are {C:dark_edition}Jumbo"},
    },
    pos = {x = 0, y = 0},
    soul_pos = {x = 1, y = 0},
    blueprint_compat = false,
    cost = 20,
    rarity = 4,
    loc_vars = function(_, info_queue, card)
        info_queue[#info_queue + 1] =
            (not card.edition or not card.edition.e_jane_jumbo) and
            G.P_CENTERS.e_jane_jumbo or nil
    end,
}

local function add_to_consumable_ability_by(n)
    local f = SMODS.Mods.Roland.qol[1]

    local function new(v)
        return type(v) == "number" and v + n or type(v) == "table" and f(v):map(new):table() or v
    end

    ---@param card Card
    return function(card)
        local ability = card.ability or {}

        local function go(key)
            ---@type { [string]: number }|number
            local value = ability[key]
            --print(key)
            if not value then
                return
            end

            if type(value) == "number" then
                ability[key] = value + n
                return
            end

            if type(value) ~= "table" then
                return
            end

            local new_value = f(value):map(new):table()

            f(new_value):each(function(v, k)
                ability[k] = v
            end)

            ability[key] = new_value
        end

        local center_key = (card.config or {}).center_key

        if center_key and center_key:sub(1, 2) == "c_" then
            f {"extra", "consumeable"}:each(go)
        end
    end
end

local orig_set_ability = Card.set_ability

---@diagnostic disable-next-line: duplicate-set-field
function Card:set_ability(center, initial, delay_sprites)
    orig_set_ability(self, center, initial, delay_sprites)

    if next(SMODS.find_card("j_jane_rivulet")) and
        self.gc and
        self:gc().key ~= "c_base" and
        string.sub(self:gc().key, 1, 2) == "c_" then
        if Jane.cry or not ((SMODS.Mods.Roland or {}).qol or {})[1] then
            local mod = 1

            for _, v in pairs(SMODS.find_card("j_jane_rivulet")) do
                mod = mod * v.ability.modifier
            end

            Jane.misprintize(self, {min = mod, max = mod}, nil, true)
        else
            local mod = 0

            for _, v in pairs(SMODS.find_card("j_jane_rivulet")) do
                mod = mod + v.ability.modifier
            end

            add_to_consumable_ability_by(mod)(self)
        end
    end
end

SMODS.Joker {
    key = "artificer",
    atlas = "janeartificer",
    loc_txt = {
        name = "The Artificer",
        text = {
            "Use to {C:red}destroy",
            "selected {C:attention}playing cards",
            not Jane.cry and "{C:red,E:1}Self-destructs" or nil,
            not Jane.cry and "after {C:attention}#1# #2#" or nil,
        },
    },
    pos = {x = 0, y = 0},
    soul_pos = {x = 1, y = 0},
    config = {extra = {uses = 2}},
    eternal_compat = false,
    blueprint_compat = false,
    cost = Jane.cry and 50 or 7,
    rarity = Jane.cry and exotic or 3,
    loc_vars = function(_, _, card)
        card.ability = card.ability or {}
        card.ability.extra = card.ability.extra or {}
        card.ability.extra.uses = card.ability.extra.uses or 2
        local uses = card.ability.extra.uses
        return {vars = {uses, uses == 1 and "use" or "uses"}}
    end,
    Bakery_use_button_text = function(_, _) return "DESTROY" end,
    Bakery_can_use = function(_, card)
        return not card.debuff and Jane.can_use() and next(G.hand.highlighted)
    end,
    Bakery_use_joker = function(_, card)
        for _, v in pairs(SMODS.find_card("j_jane_oxy")) do
            Jane.oxy(v, G.hand.highlighted)
        end

        for _, v in pairs(G.hand.highlighted) do
            v:start_dissolve()
        end

        if Jane.cry then
            return
        end

        card.ability.extra.uses = card.ability.extra.uses - 1
        local _ = card.ability.extra.uses <= 0 and card:start_dissolve()

        local _ = card.ability.extra.uses == 1 and juice_card_until(card, function()
            return card.area == G.jokers
        end, true)
    end,
}

local spearmaster_limit = 25

SMODS.Joker {
    key = "spearmaster",
    atlas = "janespearmaster",
    loc_txt = {
        name = "The Spearmaster",
        text = {
            "You can choose {C:attention}any",
            "number of cards",
            "in {C:attention}Booster Packs",
            "{C:attention}Booster Packs{} have",
            "{C:green}+#1#{} additional cards",
        },
    },
    config = {extra = {choices = 1}},
    loc_vars = function(_, _, card)
        return {vars = {card.ability.extra.choices}}
    end,
    calculate = function(_, card, _)
        card.ability.extra.choices = math.min(card.ability.extra.choices, spearmaster_limit)
    end,
    pos = {x = 0, y = 0},
    soul_pos = {x = 1, y = 0},
    blueprint_compat = false,
    cost = Jane.cry and 12 or 20,
    rarity = Jane.cry and epic or 4,
    Bakery_can_use = function(_, card)
        if card.debuff or not
            Jane.can_use() or not
            ((G.pack_cards or {}).cards or {})[1] then
            return false
        end

        local ret = false

        for _, v in pairs(G.pack_cards.cards) do
            if v.jane_spearmaster then
                return false
            elseif ((v.ability or {}).consumeable or {}).hand_type then
                ret = true
            end
        end

        return ret
    end,
    Bakery_use_button_text = function() return "USE ALL" end,
    Bakery_use_joker = function(self, card)
        if not self:Bakery_can_use(card) then
            return
        end

        local c = G.pack_cards.cards

        for i = #c, 1, -1 do
            if ((c[i].ability or {}).consumeable or {}).hand_type then
                c[i].jane_spearmaster = true
                c[i]:use_consumeable()
                SMODS.calculate_context {using_consumeable = true, consumeable = c[i], area = c[i].from_area}
                local normal = c[i].area ~= G.pack_cards
                c[i]:start_dissolve()

                if not normal then
                    G.GAME.pack_choices = G.GAME.pack_choices - 1
                    local _ = G.GAME.pack_choices <= 0 and G.FUNCS.end_consumeable()
                end
            end
        end
    end,
}

local orig_open = Card.open

---@diagnostic disable-next-line: duplicate-set-field
function Card:open()
    local orig = self.ability.extra or 1
    local spearmasters = SMODS.find_card("j_jane_spearmaster")

    if next(spearmasters) then
        for _, v in pairs(spearmasters) do
            orig = orig + v.ability.extra.choices
        end

        self.config.choose = math.floor(orig)
        self.ability.extra = math.floor(orig)
    end

    orig_open(self)

    Jane.q(function()
        if next(spearmasters) then
            G.GAME.pack_choices = math.floor(self.ability.extra)
        end
    end, 0.5, "REAL")
end

SMODS.Joker {
    key = "rivulet",
    atlas = "janerivulet",
    loc_txt = {
        name = "The Rivulet",
        text = {
            "Values on {C:attention}consumables",
            "are {C:attention}" .. (Jane.cry and "multiplied" or "added") .. "{} by {C:attention}#1#" .. (Jane.cry and "" or "{} when"),
            (Jane.cry and "when " or "") .. "they are created",
            "{C:inactive}(If possible)",
        },
    },
    config = {modifier = Jane.cry and 2 or 1},
    pos = {x = 0, y = 0},
    soul_pos = {x = 1, y = 0},
    blueprint_compat = false,
    cost = 8,
    rarity = 3,
    loc_vars = function(_, _, center)
        return {vars = {center.ability.modifier}}
    end,
}

local orig_draw = Card.draw

function Card:draw(layer)
    local cen = self.gc and self:gc()

    if self.children.floating_sprite and cen.sinis then
        if Jane.sinister and not self.shows_sinister then
            self.shows_sinister = true
            self.children.floating_sprite:set_sprite_pos(cen.sinis)
        elseif not Jane.sinister and self.shows_sinister then
            self.shows_sinister = nil
            self.children.floating_sprite:set_sprite_pos(cen.soul_pos)
        end

        if self.shows_sinister then
            self:juice_up(0, math.random())
        end
    end

    if cen and
        self.facing == "front" and
        self.config and
        (self.added_to_deck or (self.area and self.area == G.hand)) and
        not self.edition and
        (self.area == G.consumeables or cen.set ~= "Booster") and
        next(SMODS.find_card("j_jane_gourmand")) then
        self:set_edition("e_jane_jumbo", true, true)
    end

    orig_draw(self, layer)
end

local orig_debuff = Card.set_debuff

function Card:set_debuff(should_debuff)
    if should_debuff and ((self.config or {}).center or {}).debuff_immune then
        Jane.card_status_text(self, "Immune!", nil, 0.05 * self.T.h, G.C.RED, nil, 0.6, nil, nil, "bm", "cancel", 1, 0.9)
        return false
    else
        orig_debuff(self, should_debuff)
    end
end

SMODS.Joker {
    key = "saint",
    atlas = "janesaint",
    loc_txt = {
        name = {"{}", "#1#{C:jane_RGB,s:0.8}#2#", "{C:jane_RGB,s:1.6}#3#"},
        text = {
            "{C:attention}Use {}to toggle itself or",
            "other Jokers to its",
            "left's {C:legendary}Eternal{} sticker",
            "{C:attention}#4#{}#5#{C:spectral}#6#{C:planet}#7#{}#8#",
            "{C:inactive,s:1.25}#9#{C:attention,s:1.25}#10#{C:inactive,s:1.25}#11#",
            Jane.cry and "{C:inactive}(Gateway has no downside)" or nil,
        },
    },
    config = {extra = {changes_editions = false, jokers = 1, karma = -10}},
    pos = {x = 0, y = 0},
    soul_pos = {x = 1, y = 0},
    cost = 20,
    rarity = 4,
    debuff_immune = true,
    eternal_compat = true,
    blueprint_compat = false,
    perishable_compat = true,
    loc_vars = function(self, info_queue, card)
        info_queue[#info_queue + 1] = Jane.cry and G.P_CENTERS.c_cry_gateway or nil

        local extra = card.ability.extra
        local attuned = extra.karma >= 0

        return {
            vars = {
                attuned and "" or "The Saint",
                attuned and "The" or "",
                attuned and "Attuned" or "",
                attuned and "" or "Attune ",
                attuned and "" or "at ",
                attuned and (Jane.cry and "Gateways " or "Spectrals ") or
                (Jane.cry and -self.config.extra.karma .. " Gateways" or ""),
                (attuned or Jane.cry) and "" or -self.config.extra.karma .. " Planets",
                attuned and "add Joker slots" or "",
                attuned and "[Currently " or "[",
                attuned and "+" .. extra.karma or extra.karma - self.config.extra.karma,
                attuned and "]" or " / " .. -self.config.extra.karma .. "]",
            },
        }
    end,
    update = function(_, card, _)
        if card.edition and card.edition.Roland_frozen then
            card:set_edition("e_base")
        elseif card.children.floating_sprite then
            card.children.floating_sprite:set_sprite_pos({x = card.ability.extra.is_attuned and 2 or 1, y = 0})
        end
    end,
    calculate = function(self, card, context)
        local extra = card.ability.extra
        extra.is_attuned = extra.is_attuned and extra.karma >= 0

        local function ascend()
            if extra.is_attuning then
                return
            end

            extra.is_attuning = true

            Jane.card_status_text(
                card,
                "!!!",
                nil,
                0.05 * card.T.h,
                G.C.DARK_EDITION,
                0.6,
                0.6,
                2,
                2,
                "bm",
                "jane_enlightened"
            )

            Jane.q(function()
                card:flip()
                play_sound("card1")
            end, 0.1)

            Jane.q(function()
                card:flip()
                card:juice_up(1, 1)
                play_sound("card1")
                extra.is_attuned = true
            end, 1)

            Jane.q(function()
                extra.karma = extra.karma + extra.jokers
                G.jokers:change_size(extra.jokers)
            end, 1)
        end

        if extra.karma >= 0 then
            local karma = extra.is_attuning and 0 or (extra.is_attuned and 1 or extra.karma)
            G.jokers:change_size(karma * extra.jokers)
            ascend()
        end

        if not (not context.blueprint and
                (not context.retrigger_joker_check and not context.retrigger_joker) and
                context.using_consumeable and
                context.consumeable) then
            return
        end

        local gc = context.consumeable:gc()

        if Jane.cry and gc.key ~= "c_cry_gateway" or
            not Jane.cry and gc.set ~= (extra.karma > 0 and "Spectral" or "Planet") then
            return
        end

        local quota = context.consumeable.getEvalQty and context.consumeable:getEvalQty() or 1
        extra.karma = extra.karma + quota

        card_eval_status_text(
            card,
            "extra",
            nil,
            nil,
            nil,
            {message = "+" .. quota .. " Karma", colour = G.C.PALE_GREEN}
        )

        local _ = extra.karma <= 0 and card_eval_status_text(
            card,
            "extra",
            nil,
            nil,
            nil,
            {
                message = (extra.karma - self.config.extra.karma) ..
                    " / " ..
                    -self.config.extra.karma,
                colour = G.C.GREEN,
            }
        )

        if extra.karma < 0 then
            return
        end

        G.jokers:change_size((extra.is_attuned and quota or extra.karma) * extra.jokers)
        ascend()
    end,
    add_to_deck = function(_, card)
        local extra = card.ability.extra

        local _ = extra.karma > 0 and
            (extra.is_attuning or extra.is_attuned) and
            G.jokers:change_size(extra.karma * extra.jokers)
    end,
    remove_from_deck = function(_, card)
        local extra = card.ability.extra

        local _ = extra.karma > 0 and
            (extra.is_attuning or extra.is_attuned) and
            G.jokers:change_size(-extra.karma * extra.jokers)
    end,
    Bakery_can_use = function(_, card)
        return Jane.can_use() and not card.debuff
    end,
    Bakery_use_joker = function(_, card)
        for joker_index = 1, math.max(card.rank - 1, 1) do
            local joker = G.jokers.cards[joker_index]
            joker:set_eternal(not joker.ability.eternal)

            if joker.Roland_frozen_ability then
                joker.Roland_frozen_ability.eternal = joker.ability.eternal
            end

            if not card.ability.extra.changes_editions or
                not card.ability.extra.is_attuned or
                joker.ability.eternal then
                joker:juice_up()
                goto continue
            end

            local edition = 1

            for ii, vv in ipairs(joker.edition and G.P_CENTER_POOLS.Edition or {}) do
                if vv.key == joker.edition.key then
                    edition = ii
                    break
                end
            end

            local next = edition < #G.P_CENTER_POOLS.Edition and edition + 1 or 1
            joker:set_edition(G.P_CENTER_POOLS.Edition[next].key)
            ::continue::
        end
    end,
}

if Cryptid and Cryptid.aliases then
    Cryptid.aliases["saint"] = "j_jane_saint"
    Cryptid.aliases["attuned"] = "j_jane_saint"
    Cryptid.aliases["the saint"] = "j_jane_saint"
    Cryptid.aliases["the attuned"] = "j_jane_saint"
end

SMODS.Joker {
    key = "rot",
    atlas = "janerot",
    loc_txt = {
        name = "The Rot",
        text = {
            Jane.cry and "{C:attention}Duplicates itself{} at the" or "{C:inactive,E:1}Does nothing",
            Jane.cry and "end of {C:attention}every ante" or nil,
        },
    },
    pos = {x = 0, y = 0},
    soul_pos = {x = 1, y = 0},
    blueprint_compat = true,
    cost = 1,
    rarity = "jane_junk",
    in_pool = function(_, _)
        if next(SMODS.find_card("j_jane_rot")) then
            return true, {allow_duplicates = true}
        end

        for _, v in pairs(SMODS.find_card("j_jane_honey")) do
            if tonumber(v.ability.extra.level) == #Jane.rarity_ids - 1 then
                return true, {allow_duplicates = true}
            end
        end
    end,
    calculate = Jane.cry and function(_, card, context)
        local function has_room()
            return G.jokers.config.card_count < G.jokers.config.card_limit
        end

        local function spawn()
            if card.cloned then
                return
            end

            local rot = copy_card(card)
            rot.cloned = true
            rot:add_to_deck()
            G.jokers:emplace(rot)
            Jane.card_status_text(rot, "...", nil, 0.05 * card.T.h, G.C.BLACK, 3, 0, 0, nil, "bm")
        end

        if has_room() and not card.cloned and Jane.is_end_of_ante(context, card) then
            Jane.q(spawn, 0.5)
        else
            card.cloned = false
        end
    end or nil,
}