-- DESCRIPTION: Guess the five-letter word in six tries

local WORDS_PATH = "/.apps/Wordle/words.txt"
local WORD_LENGTH = 5
local MAX_GUESSES = 6
local SECTION_GAP = 10

local keyboard = {
    { "Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P" },
    { "A", "S", "D", "F", "G", "H", "J", "K", "L" },
    { "OK", "Z", "X", "C", "V", "B", "N", "M", "DEL" }
}

local answer = nil
local current = ""
local guesses = {}
local results = {}
local keyStates = {}
local cursorRow = 1
local cursorColumn = 1
local message = ""
local gameOver = false
local firstDraw = true

-- Word Source - Replace only this function to fetch answers from another source.
local function getRandomWord()
    local size = fs.fileSize(WORDS_PATH)
    if not size then return nil, "Missing " .. WORDS_PATH end
    if size == 0 then return nil, "Word list is empty" end

    for _ = 1, 8 do
        local word = fs.readLineAt(WORDS_PATH, math.random(0, size - 1)) or fs.readLineAt(WORDS_PATH, 0)
        if word then
            word = word:match("^%s*(.-)%s*$")
            if #word == WORD_LENGTH and word:match("^%a+$") then return word:upper() end
        end
    end

    return nil, "Word list has no five-letter words"
end

local function startGame()
    local errorMessage
    answer, errorMessage = getRandomWord()
    current = ""
    guesses = {}
    results = {}
    keyStates = {}
    cursorRow = 1
    cursorColumn = 1
    gameOver = not answer
    message = errorMessage or "Pick a letter"
    firstDraw = true
end

local function evaluateGuess(guess)
    local status = {}
    local remaining = {}

    for index = 1, WORD_LENGTH do
        local letter = answer:sub(index, index)
        if guess:sub(index, index) == letter then
            status[index] = 2
        else
            remaining[letter] = (remaining[letter] or 0) + 1
        end
    end

    for index = 1, WORD_LENGTH do
        if not status[index] then
            local letter = guess:sub(index, index)
            if (remaining[letter] or 0) > 0 then
                status[index] = 1
                remaining[letter] = remaining[letter] - 1
            else
                status[index] = 0
            end
        end
    end

    return status
end

local function submitGuess()
    if #current ~= WORD_LENGTH then
        message = "Enter five letters"
        return
    end

    local status = evaluateGuess(current)
    guesses[#guesses + 1] = current
    results[#results + 1] = status

    for index = 1, WORD_LENGTH do
        local letter = current:sub(index, index)
        keyStates[letter] = math.max(keyStates[letter] or 0, status[index])
    end

    if current == answer then
        message = "Solved! Press OK for a new word"
        gameOver = true
    elseif #guesses == MAX_GUESSES then
        message = answer .. " - Press OK for a new word"
        gameOver = true
    else
        message = tostring(MAX_GUESSES - #guesses) .. " guesses left"
    end
    current = ""
end

local function useKey(key)
    if key == "OK" then
        submitGuess()
    elseif key == "DEL" then
        current = current:sub(1, -2)
        message = "Pick a letter"
    elseif #current < WORD_LENGTH then
        current = current .. key
        message = "Pick a letter"
    end
end

local function centeredText(font, x, y, width, text, color, style)
    local textWidth = gui.getTextWidth(font, text, style)
    gui.drawText(font, x + math.floor((width - textWidth) / 2), y, text, color, style)
end

local function drawTile(letter, status, x, y, size, active)
    local fill = COLOR_WHITE
    local textColor = COLOR_BLACK

    if status == 2 then
        fill = COLOR_BLACK
        textColor = COLOR_WHITE
    elseif status == 1 then
        fill = COLOR_LIGHT_GRAY
    elseif status == 0 then
        fill = COLOR_DARK_GRAY
        textColor = COLOR_WHITE
    end

    if status ~= nil then gui.fillRoundedRect(x, y, size, size, 5, fill) end
    gui.drawRoundedRect(x, y, size, size, active and 3 or 2, 5, COLOR_BLACK)
    -- Present Marker - Gray shades alone are hard to tell apart on e-ink, so "in word, wrong spot" also gets an inset ring.
    if status == 1 then gui.drawRoundedRect(x + 5, y + 5, size - 10, size - 10, 2, 3, COLOR_BLACK) end
    if letter ~= "" then
        if active then gui.drawRoundedRect(x + 4, y + 4, size - 8, size - 8, 1, 3, COLOR_BLACK) end
        centeredText(FONT_NOTOSANS_16, x, y + math.floor(size / 2) - 10, size, letter, textColor, STYLE_BOLD)
    end
end

local function keyboardMetrics(height)
    local gap = 4
    local keyHeight = math.min(52, math.floor(height * 0.07))
    return height - 56 - (keyHeight * 3 + gap * 2), keyHeight
end

local function drawGrid(width, height)
    local gap = 6
    local startY = 72
    local keyboardTop = keyboardMetrics(height)
    local gridBottom = keyboardTop - SECTION_GAP * 2 - 18
    local size = math.min(72, math.floor((width - 40 - gap * (WORD_LENGTH - 1)) / WORD_LENGTH),
        math.floor((gridBottom - startY - gap * (MAX_GUESSES - 1)) / MAX_GUESSES))
    local gridWidth = size * WORD_LENGTH + gap * (WORD_LENGTH - 1)
    local startX = math.floor((width - gridWidth) / 2)

    for row = 1, MAX_GUESSES do
        local active = row == #guesses + 1
        local word = guesses[row] or (active and current or "")
        local status = results[row]
        for column = 1, WORD_LENGTH do
            drawTile(word:sub(column, column), status and status[column] or nil,
                startX + (column - 1) * (size + gap), startY + (row - 1) * (size + gap), size, active)
        end
    end

    return startY + MAX_GUESSES * size + (MAX_GUESSES - 1) * gap
end

local function drawLegend(width, y)
    local items = {
        {"Right", 2},
        {"Spot", 1},
        {"Miss", 0},
    }
    local swatch = 18
    local gap = 12
    local itemWidth = 76
    local startX = math.floor((width - itemWidth * #items - gap * (#items - 1)) / 2)

    for index, item in ipairs(items) do
        local x = startX + (index - 1) * (itemWidth + gap)
        drawTile("", item[2], x, y, swatch)
        gui.drawText(FONT_SMALL, x + swatch + 5, y + 2, item[1], COLOR_BLACK, STYLE_REGULAR)
    end
end

local function drawKeyboard(width, height)
    local gap = 4
    local margin = 12
    local keyWidth = math.floor((width - margin * 2 - gap * 9) / 10)
    local top, keyHeight = keyboardMetrics(height)

    for rowIndex, row in ipairs(keyboard) do
        local rowWidth = #row * keyWidth + (#row - 1) * gap
        local startX = math.floor((width - rowWidth) / 2)
        local y = top + (rowIndex - 1) * (keyHeight + gap)

        for columnIndex, key in ipairs(row) do
            local x = startX + (columnIndex - 1) * (keyWidth + gap)
            local status = keyStates[key]
            local fill = status == 2 and COLOR_BLACK or status == 1 and COLOR_LIGHT_GRAY or
                status == 0 and COLOR_DARK_GRAY or COLOR_WHITE
            local textColor = (status == 2 or status == 0) and COLOR_WHITE or COLOR_BLACK

            gui.fillRoundedRect(x, y, keyWidth, keyHeight, 4, fill)
            gui.drawRoundedRect(x, y, keyWidth, keyHeight, 1, 4, COLOR_BLACK)
            if status == 1 then gui.drawRoundedRect(x + 4, y + 4, keyWidth - 8, keyHeight - 8, 1, 3, COLOR_BLACK) end
            if rowIndex == cursorRow and columnIndex == cursorColumn then
                gui.drawRoundedRect(x + 2, y + 2, keyWidth - 4, keyHeight - 4, 3, 3, textColor)
            end
            centeredText(FONT_SMALL, x, y + math.floor(keyHeight / 2) - 7, keyWidth, key, textColor, STYLE_BOLD)
        end
    end
end

local function render()
    local width, height = gui.width(), gui.height()
    gui.clear()
    gui.drawCenteredText(FONT_NOTOSANS_16, 8, "WORDLE", COLOR_BLACK, STYLE_BOLD)
    gui.drawCenteredText(FONT_SMALL, 46, message, COLOR_BLACK, STYLE_REGULAR)

    if answer then
        local gridBottom = drawGrid(width, height)
        drawLegend(width, gridBottom + SECTION_GAP)
        drawKeyboard(width, height)
    end

    gui.drawButtonHints("<<", "Select", "<", ">")
    gui.refresh(firstDraw and REFRESH_HALF or REFRESH_FAST)
    firstDraw = false
end

function init()
    startGame()
    render()
end

function on_button(name, event)
    if event ~= "down" then return end

    if name == "back" then
        sys.exit()
        return
    end

    if gameOver and answer then
        if name ~= "confirm" then return end
        startGame()
    elseif answer then
        if name == "left" then
            cursorColumn = cursorColumn == 1 and #keyboard[cursorRow] or cursorColumn - 1
        elseif name == "right" then
            cursorColumn = cursorColumn == #keyboard[cursorRow] and 1 or cursorColumn + 1
        elseif name == "page_back" then
            cursorRow = cursorRow == 1 and #keyboard or cursorRow - 1
            cursorColumn = math.min(cursorColumn, #keyboard[cursorRow])
        elseif name == "page_forward" then
            cursorRow = cursorRow == #keyboard and 1 or cursorRow + 1
            cursorColumn = math.min(cursorColumn, #keyboard[cursorRow])
        elseif name == "confirm" then
            useKey(keyboard[cursorRow][cursorColumn])
        else
            return
        end
    else
        return
    end

    render()
end