collectedEntities = filteredSystem("collectedEntities", { collected = T.pd_image })

local onCollidingRemove = { "mass", "velocity", "canCollideWith" }

local Drop = { i = T.number, delay = T.number, startAt = T.XyPair }

disableCollisionWhenRoundEnds = filteredSystem("disableCollisionWhenRoundEnds", { disableCollisionWhenRoundEnds = T.marker })

collectableDropSystem = filteredSystem("collectableDrop", { drop = Drop }, function(e, dt, system)
    e.drop.delay = e.drop.delay - dt
    if e.drop.delay > 0 then
        return
    end
    local collX, collY = e.drop.sprite:getSize()
    system.world:addEntity({
        drawAsSprite = e.drop.sprite,
        size = { x = collX, y = collY / 2 },
        mass = 0.5,
        velocity = { x = 0, y = 0 },
        position = { x = e.drop.startAt.x - (collX / 2), y = e.drop.startAt.y },
        canCollideWith = 2,
        canBeCollidedBy = 2,
        isSolid = true,
        stopMovingOnCollision = true,
        onCollidingRemove = onCollidingRemove,
        focusOnCollide = e.drop.i,
        expireBelowScreenBy = 5,
        removeAtRoundStart = true,
    })
    system.world:removeEntity(e)
end)

removeAtRoundStart = filteredSystem("removeAtRoundStart", { removeAtRoundStart = T.bool })

filteredSystem("afterDelayAdd", { afterDelayAdd = { entityToAdd = T.Entity, delay = T.number } }, function(e, dt, system)
    e.afterDelayAdd.delay = e.afterDelayAdd.delay - dt
    if e.afterDelayAdd.delay > 0 then
        return
    end
    system.world:addEntity(e.afterDelayAdd.entityToAdd)
    system.world:removeEntity(e)
end)

roundSystem = filteredSystem("round", { roundAction = T.RoundStateAction, position = Maybe(T.XyPair) }, function(e, _, system)
    system.world:removeEntity(e)
    if e.roundAction == "start" then
        for _, cart in pairs(cartSystem.entities) do
            Cart.reset(cart)
            system.world:addEntity(cart)
        end
        for _, remove in pairs(removeAtRoundStart.entities) do
            system.world:removeEntity(remove)
        end
        system.world:addSystem(spawnerSystem)
        Ingredients.clearCache(system.world)
    elseif e.roundAction == "end" then
        system.world:removeSystem(spawnerSystem)
        for _, toExpire in pairs(disableCollisionWhenRoundEnds.entities) do
            toExpire.canCollideWith = nil
            toExpire.canBeCollidedBy = nil
            --system.world:addEntity(toExpire)
            system.world:removeEntity(toExpire)
        end
        -- playdate.setAutoLockDisabled(false)

        local y = e.position.y - 240
        local rectWidth = 150
        local plateSize = { x = rectWidth, y = 10 }

        system.world:addEntity({
            drawAsRectangle = { size = plateSize },
            size = plateSize,
            mass = 0.5,
            velocity = { x = 0, y = 0 },
            position = { x = e.position.x - (rectWidth / 2), y = y },
            canCollideWith = 2,
            canBeCollidedBy = 2,
            isSolid = true,
            stopMovingOnCollision = true,
            removeAtRoundStart = true,
        })

        -- TODO: Big ol' numbers displaying how many ingredients were collected?
        -- TODO: Could layer ingredients in rows of three? Maybe just when it's higher?
        local delayPerDrop = 0.100
        local delay = 0
        for i, collectable in ipairs(collectedEntities.entities) do
            local _, collY = collectable.collected:getSize()
            y = y - collY - 15
            system.world:addEntity({
                drop = {
                    sprite = collectable.collected,
                    i = i,
                    delay = delay,
                    startAt = {
                        x = e.position.x,
                        y = y
                    }
                },
            })
            delay = delay + delayPerDrop
            system.world:removeEntity(collectable)
        end

        ---@type NamedUpgrade[]
        local availableUpgrades = Utils.getNDifferentValues(getAvailableUpgrades(), 3)
        -- Sorting from shortest to longest sort of makes them look like a bun?
        table.sort(availableUpgrades, function(a, b)
            return #a.name > #b.name
        end)

        y = y - 50
        local menuEntity = {
            menuItems = {},
            canReceiveInput = T.marker,
        }
        local upgradeBelow
        local i = #collectedEntities.entities
        for _, upgrade in ipairs(availableUpgrades) do
            i = i + 1
            local collX, collY = 75, 21
            y = y - collY - 15 - 15
            ---@type Selectable
            local upgradeEntity = {
                replacements = { upgrade.replace },
                drawAsText = {
                    text = upgrade.name,
                    style = TextStyle.Inverted,
                },
                size = { x = collX, y = collY },
                mass = 0.5,
                velocity = { x = 0, y = 0 },
                position = { x = e.position.x, y = y },
                canCollideWith = 2,
                canBeCollidedBy = 2,
                isSolid = true,
                stopMovingOnCollision = true,
                onCollidingRemove = onCollidingRemove,
                focusOnCollide = i,
                navigateDown = upgradeBelow,
                highlighted = true,
                removeAtRoundStart = true,
            }
            if upgradeBelow then
                upgradeBelow.navigateUp = upgradeEntity
                upgradeBelow.highlighted = false
                upgradeBelow.drawAsText.style = TextStyle.Bordered
            end
            upgradeBelow = upgradeEntity
            menuEntity.menuItems[#menuEntity.menuItems + 1] = upgradeEntity
            delay = delay + delayPerDrop
            system.world:addEntity({
                afterDelayAdd = {
                    delay = delay,
                    entityToAdd = upgradeEntity
                },
            })
            system.world:addEntity(menuEntity)
        end
    end
end)