-- Roulette Machine — static wheel, physics ball
-- Tom's Peripherals GPU + screen wall (any size).
--
-- The wheel is completely static — it never rotates.
-- The ball is simulated in 2-D Cartesian coordinates:
--   * Orbits inside a circular track (bounces off outer rim and inner wall)
--   * Has tangential + radial velocity components
--   * Loses energy each bounce (restitution < 1)
--   * When slow enough, crosses the inner wall and bounces around the
--     pocket ring until it comes to rest in a pocket
--
-- Result: whichever pocket the ball is closest to when it stops.
-- The wheel is drawn once at startup; only the ball moves each frame.

----------------------------------------------------------------------
-- GPU discovery
----------------------------------------------------------------------

local function findGPU()
    print("[roulette] Scanning peripherals...")
    for _, name in ipairs(peripheral.getNames()) do
        local t = peripheral.getType(name)
        print("  " .. name .. " = " .. tostring(t))
        if t and t:find("gpu") then
            print("[roulette] Using GPU: " .. name)
            return peripheral.wrap(name)
        end
    end
    return nil
end

----------------------------------------------------------------------
-- Constants
----------------------------------------------------------------------

local FRAME_DELAY = 0.03   -- ~33 fps
local TWO_PI      = math.pi * 2

local WHEEL_ORDER = {
    0, 32, 15, 19, 4, 21, 2, 25, 17, 34, 6, 27, 13, 36,
    11, 30, 8, 23, 10, 5, 24, 16, 33, 1, 20, 14, 31, 9,
    22, 18, 29, 7, 28, 12, 35, 3, 26
}
local NUM_POCKETS = #WHEEL_ORDER  -- 37

local RED_SET = {}
for _, n in ipairs({1,3,5,7,9,12,14,16,18,19,21,23,25,27,30,32,34,36}) do
    RED_SET[n] = true
end

local CX, CY
local R_OUTER, R_POCKET_OUT, R_POCKET_IN, R_HUB

-- Colours
local COL_BG       = 0x050505
local COL_RIM      = 0x8B6914
local COL_TRACK    = 0x1A1A1A
local COL_RED      = 0xC62828
local COL_BLACK    = 0x1C1C1C
local COL_GREEN    = 0x1B5E20
local COL_SEP      = 0xB8860B
local COL_HUB      = 0x2C2C2C
local COL_HUB_RING = 0x8B6914
local COL_WHITE    = 0xFFFFFF
local COL_BALL     = 0xF0F0F0
local COL_BALL_SHD = 0x444444

-- Ball physics
local BALL_RADIUS      = 8      -- px
local BALL_SPEED_MIN   = 420    -- px/s  initial tangential speed
local BALL_SPEED_MAX   = 620
local TRACK_RESTITUTION = 0.72  -- speed fraction kept on track-wall bounce
local POCKET_RESTITUTION = 0.45 -- speed fraction kept bouncing inside pocket ring
local FRICTION_TRACK   = 0.992  -- multiplier per frame while in track (energy loss)
local FRICTION_POCKET  = 0.970  -- higher damping once in pocket ring
-- Ball enters pocket ring when its speed drops below this
local DROP_SPEED       = 90     -- px/s
-- Small random kick angle on each wall bounce
local BOUNCE_KICK_MAX  = 0.12   -- rad

----------------------------------------------------------------------
-- GPU / pixel primitives
----------------------------------------------------------------------

local gpu
local PW, PH

local function px_rect(x, y, w, h, col)
    x = math.floor(x); y = math.floor(y)
    w = math.floor(w); h = math.floor(h)
    if x < 1 then w = w + x - 1; x = 1 end
    if y < 1 then h = h + y - 1; y = 1 end
    if x + w - 1 > PW then w = PW - x + 1 end
    if y + h - 1 > PH then h = PH - y + 1 end
    if w < 1 or h < 1 then return end
    gpu.filledRectangle(x, y, w, h, col)
end

local function px_circle(cx, cy, r, col)
    cx = math.floor(cx); cy = math.floor(cy); r = math.floor(r)
    for dy = -r, r do
        local half = math.floor(math.sqrt(r*r - dy*dy) + 0.5)
        px_rect(cx - half, cy + dy, half*2 + 1, 1, col)
    end
end

local function px_annulus(cx, cy, r1, r2, col)
    cx = math.floor(cx); cy = math.floor(cy)
    r1 = math.floor(r1); r2 = math.floor(r2)
    for dy = -r2, r2 do
        local ho = math.floor(math.sqrt(math.max(0, r2*r2 - dy*dy)) + 0.5)
        local hi = math.floor(math.sqrt(math.max(0, r1*r1 - dy*dy)) + 0.5)
        if ho > hi then
            px_rect(cx - ho, cy + dy, ho - hi,     1, col)
            px_rect(cx + hi, cy + dy, ho - hi + 1, 1, col)
        elseif hi == 0 then
            px_rect(cx - ho, cy + dy, ho*2 + 1, 1, col)
        end
    end
end

local function px_spoke(cx, cy, r1, r2, angle, col)
    local ca, sa = math.cos(angle), math.sin(angle)
    for i = 0, r2 - r1 do
        local r = r1 + i
        px_rect(math.floor(cx + ca*r + 0.5), math.floor(cy + sa*r + 0.5), 1, 1, col)
    end
end

local function px_text(str, x, y, fg, bg, size)
    pcall(gpu.drawText, math.floor(x), math.floor(y), str, fg, bg, size or 1, 0)
end

----------------------------------------------------------------------
-- Wheel drawing (static — drawn once, never redrawn during spin)
----------------------------------------------------------------------

local function pocketColor(num)
    if num == 0 then return COL_GREEN end
    if RED_SET[num] then return COL_RED end
    return COL_BLACK
end

local FIXED_ROTOR = 0   -- wheel never rotates

local function drawWedge(slotIdx, glowing)
    local halfArc  = math.pi / NUM_POCKETS
    local midAngle = FIXED_ROTOR + (slotIdx - 1) * TWO_PI / NUM_POCKETS
    local a0 = midAngle - halfArc
    local a1 = midAngle + halfArc

    local num = WHEEL_ORDER[slotIdx]
    local col = pocketColor(num)
    if glowing then
        local r = math.min(255, math.floor(col / 0x10000) + 70)
        local g = math.min(255, math.floor((col % 0x10000) / 0x100) + 70)
        local b = math.min(255, col % 0x100 + 70)
        col = r * 0x10000 + g * 0x100 + b
    end

    local ri, ro = R_POCKET_IN, R_POCKET_OUT
    local bx0 = math.floor(CX - ro) - 1
    local bx1 = math.ceil (CX + ro) + 1
    local by0 = math.floor(CY - ro) - 1
    local by1 = math.ceil (CY + ro) + 1
    local arc  = (a1 - a0) % TWO_PI

    for sy = by0, by1 do
        local runStart = nil
        for sx = bx0, bx1 do
            local dx = sx - CX; local dy = sy - CY
            local dist = math.sqrt(dx*dx + dy*dy)
            local inRing  = dist >= ri and dist <= ro
            local rel     = (math.atan2(dy, dx) - a0) % TWO_PI
            local inWedge = rel <= arc
            if inRing and inWedge then
                if not runStart then runStart = sx end
            else
                if runStart then
                    px_rect(runStart, sy, sx - runStart, 1, col)
                    runStart = nil
                end
            end
        end
        if runStart then px_rect(runStart, sy, bx1 - runStart + 1, 1, col) end
    end

    px_spoke(CX, CY, ri, ro, a0, COL_SEP)

    local labelR = (ri + ro) / 2
    local lx = CX + math.cos(midAngle) * labelR
    local ly = CY + math.sin(midAngle) * labelR
    local label = tostring(num)
    px_text(label, lx - (#label * 4), ly - 4, COL_WHITE, col, 1)
end

local function drawAllWedges(glowSlot)
    for i = 1, NUM_POCKETS do
        drawWedge(i, i == glowSlot)
        sleep(0)
    end
end

local function drawChrome()
    px_annulus(CX, CY, R_OUTER - 6, R_OUTER, COL_RIM)
    px_annulus(CX, CY, R_POCKET_OUT + 2, R_OUTER - 6, COL_TRACK)
    px_annulus(CX, CY, R_POCKET_OUT, R_POCKET_OUT + 2, COL_RIM)
    px_annulus(CX, CY, R_POCKET_IN - 2, R_POCKET_IN, COL_RIM)
    px_circle(CX, CY, R_HUB, COL_HUB)
    px_annulus(CX, CY, R_HUB - 4, R_HUB, COL_HUB_RING)
    px_circle(CX, CY, 6, COL_HUB_RING)
    px_circle(CX, CY, 3, COL_HUB)
end

local function drawWheelFull(glowSlot)
    px_circle(CX, CY, R_OUTER, COL_BG)
    drawAllWedges(glowSlot)
    drawChrome()
end

----------------------------------------------------------------------
-- Ball helpers
----------------------------------------------------------------------

local ballX, ballY = 0, 0

local function bgAt(bx, by)
    local d = math.sqrt((bx - CX)^2 + (by - CY)^2)
    if d > R_POCKET_OUT then return COL_TRACK end
    if d > R_POCKET_IN  then
        -- approximate — use average of red/black (dark grey)
        return 0x181818
    end
    return COL_HUB
end

local function eraseBall()
    px_circle(ballX, ballY, BALL_RADIUS + 2, bgAt(ballX, ballY))
end

local function drawBall(bx, by)
    ballX = math.floor(bx)
    ballY = math.floor(by)
    px_circle(ballX + 2, ballY + 2, BALL_RADIUS, COL_BALL_SHD)
    px_circle(ballX,     ballY,     BALL_RADIUS, COL_BALL)
    px_circle(ballX - 2, ballY - 2, 2,           COL_WHITE)
end

----------------------------------------------------------------------
-- Center text
----------------------------------------------------------------------

local function drawCenterText(lines, textSize)
    textSize = textSize or 2
    local r  = R_HUB - 8
    px_circle(CX, CY, r, COL_HUB)
    local lineH  = 13 * textSize
    local totalH = #lines * lineH
    local startY = CY - math.floor(totalH / 2)
    for i, line in ipairs(lines) do
        local lx = CX - math.floor(#line * 6 * textSize / 2)
        px_text(line, lx, startY + (i-1) * lineH, COL_WHITE, COL_HUB, textSize)
    end
    px_annulus(CX, CY, R_HUB - 4, R_HUB, COL_HUB_RING)
    gpu.sync()
end

----------------------------------------------------------------------
-- Physics spin — Cartesian 2-D ball, static wheel
--
-- Ball position: (bx, by) in pixel space
-- Ball velocity: (vx, vy) in px/s
--
-- Track outer wall : circle of radius R_WALL_OUT centred on (CX, CY)
-- Track inner wall : circle of radius R_WALL_IN
-- Pocket ring      : between R_POCKET_IN and R_POCKET_OUT
--
-- Collision response: reflect velocity along the surface normal (radial
-- direction), apply restitution, add small random kick to angle.
----------------------------------------------------------------------

local function spin()
    local dt = FRAME_DELAY

    local R_WALL_OUT = R_OUTER - 6 - BALL_RADIUS
    local R_WALL_IN  = R_POCKET_OUT + 2 + BALL_RADIUS
    local R_PKT_OUT  = R_POCKET_OUT - BALL_RADIUS
    local R_PKT_IN   = R_POCKET_IN  + BALL_RADIUS
    local R_SETTLE   = (R_POCKET_IN + R_POCKET_OUT) / 2

    -- Start ball at a random angle on the outer track, moving tangentially
    local startAngle = math.random() * TWO_PI
    local startSpeed = BALL_SPEED_MIN + math.random() * (BALL_SPEED_MAX - BALL_SPEED_MIN)
    -- Tangential direction (perpendicular to radial, CCW = 90° CCW from outward normal)
    -- Outward normal at angle a: (cos a, sin a)
    -- CCW tangent: (-sin a, cos a)
    local bx = CX + math.cos(startAngle) * (R_WALL_OUT - 2)
    local by = CY + math.sin(startAngle) * (R_WALL_OUT - 2)
    local vx = -math.sin(startAngle) * startSpeed
    local vy =  math.cos(startAngle) * startSpeed

    local inPocket = false
    local elapsed  = 0
    local MAX_TIME = 20.0

    -- Draw initial ball position (wheel already on screen)
    drawBall(bx, by)
    gpu.sync()

    while elapsed < MAX_TIME do
        local speed = math.sqrt(vx*vx + vy*vy)

        -- Apply friction
        local fric = inPocket and FRICTION_POCKET or FRICTION_TRACK
        vx = vx * fric
        vy = vy * fric

        -- Integrate
        bx = bx + vx * dt
        by = by + vy * dt

        -- Distance from centre
        local dx   = bx - CX
        local dy   = by - CY
        local dist = math.sqrt(dx*dx + dy*dy)
        -- Outward unit normal
        local nx = dx / dist
        local ny = dy / dist

        if not inPocket then
            -- ── Outer wall bounce ───────────────────────────────────
            if dist > R_WALL_OUT then
                -- Push back inside
                bx = CX + nx * R_WALL_OUT
                by = CY + ny * R_WALL_OUT
                -- Reflect radial component
                local vn = vx*nx + vy*ny
                vx = vx - 2*vn*nx; vy = vy - 2*vn*ny
                -- Apply restitution to the reflected (now inward) normal part
                local vn2 = vx*nx + vy*ny
                vx = vx - vn2*nx*(1 - TRACK_RESTITUTION)
                vy = vy - vn2*ny*(1 - TRACK_RESTITUTION)
                -- Small random angular kick
                local kick = (math.random() - 0.5) * BOUNCE_KICK_MAX * 2
                local c, s = math.cos(kick), math.sin(kick)
                vx, vy = vx*c - vy*s, vx*s + vy*c
            end

            -- ── Enter pocket ring when slow enough ──────────────────
            if speed < DROP_SPEED and dist >= R_WALL_IN - 4 then
                inPocket = true
            end

            -- ── Inner wall bounce (deflector tip) ───────────────────
            if dist < R_WALL_IN and not inPocket then
                bx = CX + nx * R_WALL_IN
                by = CY + ny * R_WALL_IN
                local vn = vx*nx + vy*ny
                vx = vx - 2*vn*nx; vy = vy - 2*vn*ny
                local vn2 = vx*nx + vy*ny
                vx = vx - vn2*nx*(1 - TRACK_RESTITUTION)
                vy = vy - vn2*ny*(1 - TRACK_RESTITUTION)
                local kick = (math.random() - 0.5) * BOUNCE_KICK_MAX * 2
                local c, s = math.cos(kick), math.sin(kick)
                vx, vy = vx*c - vy*s, vx*s + vy*c
            end
        else
            -- ── Inside pocket ring ───────────────────────────────────
            -- Bounce off outer pocket wall
            if dist > R_PKT_OUT then
                bx = CX + nx * R_PKT_OUT
                by = CY + ny * R_PKT_OUT
                local vn = vx*nx + vy*ny
                vx = vx - 2*vn*nx; vy = vy - 2*vn*ny
                local vn2 = vx*nx + vy*ny
                vx = vx - vn2*nx*(1 - POCKET_RESTITUTION)
                vy = vy - vn2*ny*(1 - POCKET_RESTITUTION)
                local kick = (math.random() - 0.5) * BOUNCE_KICK_MAX * 2
                local c, s = math.cos(kick), math.sin(kick)
                vx, vy = vx*c - vy*s, vx*s + vy*c
            end
            -- Bounce off inner pocket wall
            if dist < R_PKT_IN then
                bx = CX + nx * R_PKT_IN
                by = CY + ny * R_PKT_IN
                local vn = vx*nx + vy*ny
                vx = vx - 2*vn*nx; vy = vy - 2*vn*ny
                local vn2 = vx*nx + vy*ny
                vx = vx - vn2*nx*(1 - POCKET_RESTITUTION)
                vy = vy - vn2*ny*(1 - POCKET_RESTITUTION)
                local kick = (math.random() - 0.5) * BOUNCE_KICK_MAX * 2
                local c, s = math.cos(kick), math.sin(kick)
                vx, vy = vx*c - vy*s, vx*s + vy*c
            end

            -- Settled?
            if speed < 6 then break end
        end

        eraseBall()
        drawBall(bx, by)
        gpu.sync()
        sleep(dt)
        elapsed = elapsed + dt
    end

    -- Final position
    eraseBall()
    drawBall(bx, by)
    gpu.sync()

    -- Nearest pocket by angle
    local finalAngle = math.atan2(by - CY, bx - CX)
    local bestSlot, bestDist = 1, math.huge
    for i = 1, NUM_POCKETS do
        local sa   = ((i - 1) * TWO_PI / NUM_POCKETS) % TWO_PI
        -- normalise finalAngle to [0, 2pi)
        local fa   = finalAngle % TWO_PI
        local diff = math.abs(sa - fa)
        if diff > math.pi then diff = TWO_PI - diff end
        if diff < bestDist then bestDist = diff; bestSlot = i end
    end

    -- Snap to pocket centre
    local snapAngle = FIXED_ROTOR + (bestSlot - 1) * TWO_PI / NUM_POCKETS
    local sx = CX + math.cos(snapAngle) * R_SETTLE
    local sy = CY + math.sin(snapAngle) * R_SETTLE
    eraseBall()
    drawBall(sx, sy)
    gpu.sync()

    return WHEEL_ORDER[bestSlot], bestSlot
end

----------------------------------------------------------------------
-- Glow animation
----------------------------------------------------------------------

local function glowAnimation(slotIdx)
    local R_SETTLE = (R_POCKET_IN + R_POCKET_OUT) / 2
    local sa = FIXED_ROTOR + (slotIdx - 1) * TWO_PI / NUM_POCKETS
    local bx = CX + math.cos(sa) * R_SETTLE
    local by = CY + math.sin(sa) * R_SETTLE
    for flash = 1, 6 do
        drawWedge(slotIdx, flash % 2 == 1)
        drawBall(bx, by)
        gpu.sync()
        sleep(0.15)
    end
    drawWedge(slotIdx, true)
    drawBall(bx, by)
    gpu.sync()
end

----------------------------------------------------------------------
-- Redstone helper
----------------------------------------------------------------------

local function waitForRedstonePulse()
    while true do
        os.pullEvent("redstone")
        for _, side in ipairs(redstone.getSides()) do
            if redstone.getInput(side) then return end
        end
    end
end

----------------------------------------------------------------------
-- Lifecycle
----------------------------------------------------------------------

local function start()
    math.randomseed(os.epoch("utc"))

    gpu = findGPU()
    if not gpu then error("No GPU peripheral found.") end

    gpu.refreshSize()
    sleep(0)
    gpu.setSize(64)

    PW, PH = gpu.getSize()
    print(("[roulette] GPU: %dx%d px"):format(PW, PH))
    if not PW or PW < 128 or PH < 128 then
        error(("GPU pixel size %dx%d too small."):format(PW or 0, PH or 0))
    end

    CX = math.floor(PW / 2)
    CY = math.floor(PH / 2)
    local R_MAX  = math.floor(math.min(PW, PH) / 2) - 4
    R_OUTER      = R_MAX
    R_POCKET_OUT = math.floor(R_MAX * 0.82)
    R_POCKET_IN  = math.floor(R_MAX * 0.58)
    R_HUB        = math.floor(R_MAX * 0.38)

    gpu.fill(COL_BG)
    drawWheelFull(nil)
    drawCenterText({ "ROULETTE", "Pull lever" })
end

local function stop()
    if gpu then gpu.fill(COL_BG); gpu.sync() end
end

local function main()
    while true do
        waitForRedstonePulse()

        drawCenterText({ "SPINNING..." })
        sleep(0.1)

        local num, slotIdx = spin()

        glowAnimation(slotIdx)

        local name = "GREEN"
        if num ~= 0 then
            name = RED_SET[num] and "RED" or "BLACK"
        end
        drawCenterText({ "WINNER!", name, tostring(num) })

        sleep(5)

        -- Erase ball, redraw wheel clean
        eraseBall()
        drawChrome()
        drawCenterText({ "ROULETTE", "Pull lever" })
    end
end

return { start = start, stop = stop, main = main }