local cube_mesh_info = {
    path = "models/cube.stl",
    loaded = false,
    vertex_count = 0,
    index_count = 0,
    error = "load_mesh_from_file() not registered",
}

local cube_vertices = {}
local cube_indices = {}

local function load_cube_mesh()
    if type(load_mesh_from_file) ~= "function" then
        cube_mesh_info.error = "load_mesh_from_file() is unavailable"
        return
    end

    local mesh, err = load_mesh_from_file(cube_mesh_info.path)
    if not mesh then
        cube_mesh_info.error = err or "load_mesh_from_file() failed"
        return
    end

    if type(mesh.vertices) ~= "table" or type(mesh.indices) ~= "table" then
        cube_mesh_info.error = "loader returned unexpected structure"
        return
    end

    cube_vertices = mesh.vertices
    cube_indices = mesh.indices
    cube_mesh_info.loaded = true
    cube_mesh_info.vertex_count = #mesh.vertices
    cube_mesh_info.index_count = #mesh.indices
    cube_mesh_info.error = nil
end

load_cube_mesh()

if not cube_mesh_info.loaded then
    error("Unable to load cube mesh: " .. (cube_mesh_info.error or "unknown"))
end

local music_state = {
    playing = false,
    togglePressed = false,
}

local function start_music()
    if type(audio_play_background) == "function" then
        audio_play_background("modmusic.ogg", true)
        music_state.playing = true
    end
end

local function stop_music()
    if type(audio_stop_background) == "function" then
        audio_stop_background()
    end
    music_state.playing = false
end

local function toggle_music()
    if music_state.playing then
        stop_music()
    else
        start_music()
    end
end

start_music()

local math3d = require("math3d")
local Gui = require("gui")
local string_format = string.format

local InputState = {}
InputState.__index = InputState

function InputState:new()
    local sharedKeys = {}
    local instance = {
        mouseX = 0.0,
        mouseY = 0.0,
        mouseDeltaX = 0.0,
        mouseDeltaY = 0.0,
        mouseDown = false,
        mouseDownPrevious = false,
        wheel = 0.0,
        textInput = "",
        keyStates = sharedKeys,
        keys = sharedKeys,
        lastMouseX = nil,
        lastMouseY = nil,
        gamepad = {
            connected = false,
            leftX = 0.0,
            leftY = 0.0,
            rightX = 0.0,
            rightY = 0.0,
            togglePressed = false,
        },
    }
    return setmetatable(instance, InputState)
end

function InputState:resetTransient()
    self.textInput = ""
    self.wheel = 0.0
    self.mouseDeltaX = 0.0
    self.mouseDeltaY = 0.0
end

function InputState:setMouse(x, y, isDown, deltaX, deltaY)
    self.mouseDownPrevious = self.mouseDown
    if type(deltaX) == "number" and type(deltaY) == "number" then
        self.mouseDeltaX = deltaX
        self.mouseDeltaY = deltaY
    elseif self.lastMouseX ~= nil and self.lastMouseY ~= nil then
        self.mouseDeltaX = x - self.lastMouseX
        self.mouseDeltaY = y - self.lastMouseY
    end
    self.lastMouseX = x
    self.lastMouseY = y
    self.mouseX = x
    self.mouseY = y
    self.mouseDown = isDown
end

function InputState:setWheel(deltaY)
    self.wheel = deltaY
end

function InputState:setKey(keyName, isDown)
    self.keyStates[keyName] = isDown
end

function InputState:mouseJustPressed()
    return self.mouseDown and not self.mouseDownPrevious
end

function InputState:mouseJustReleased()
    return not self.mouseDown and self.mouseDownPrevious
end

function InputState:isKeyDown(keyName)
    return self.keyStates[keyName]
end

function InputState:addTextInput(text)
    if text then
        self.textInput = self.textInput .. text
    end
end

function InputState:setGamepad(connected, leftX, leftY, rightX, rightY, togglePressed)
    local pad = self.gamepad
    pad.connected = connected and true or false
    pad.leftX = leftX or 0.0
    pad.leftY = leftY or 0.0
    pad.rightX = rightX or 0.0
    pad.rightY = rightY or 0.0
    pad.togglePressed = togglePressed and true or false
end

gui_input = InputState:new()

local gui_context = Gui.newContext()
local ui_layout = {
    width = 1024,
    height = 768,
    margin = 16,
}
local compass_layout = {
    size = 120,
    label_height = 18,
    padding = 10,
}
local flight_layout = {
    width = 120,
    height = 28,
    spacing = 8,
}
local ui_state = {
    flyUpActive = false,
    flyDownActive = false,
    flyUpPulse = false,
    flyDownPulse = false,
}

local function log_debug(fmt, ...)
    if not lua_debug or not fmt then
        return
    end
    print(string_format(fmt, ...))
end

if cube_mesh_info.loaded then
    log_debug("Loaded cube mesh from %s (%d vertices, %d indices)",
        cube_mesh_info.path, cube_mesh_info.vertex_count, cube_mesh_info.index_count)
end

local shader_variants = {
    default = {
        vertex = "shaders/cube.vert.spv",
        fragment = "shaders/cube.frag.spv",
    },
}

local camera = {
    position = {0.0, 0.0, 5.0},
    yaw = -math.pi / 2.0,
    pitch = 0.0,
    fov = 0.78,
    near = 0.1,
    far = 50.0,
}

local controls = {
    move_speed = 4.0,
    fly_speed = 3.0,
    mouse_sensitivity = 0.0025,
    gamepad_look_speed = 2.5,
    stick_deadzone = 0.2,
    max_pitch = math.rad(85.0),
}

local last_frame_time = nil
local world_up = {0.0, 1.0, 0.0}

local function clamp(value, minValue, maxValue)
    if value < minValue then
        return minValue
    end
    if value > maxValue then
        return maxValue
    end
    return value
end

local function normalize(vec)
    local x, y, z = vec[1], vec[2], vec[3]
    local len = math.sqrt(x * x + y * y + z * z)
    if len == 0.0 then
        return {x, y, z}
    end
    return {x / len, y / len, z / len}
end

local function cross(a, b)
    return {
        a[2] * b[3] - a[3] * b[2],
        a[3] * b[1] - a[1] * b[3],
        a[1] * b[2] - a[2] * b[1],
    }
end

local function apply_deadzone(value, deadzone)
    local magnitude = math.abs(value)
    if magnitude < deadzone then
        return 0.0
    end
    local scaled = (magnitude - deadzone) / (1.0 - deadzone)
    if value < 0.0 then
        return -scaled
    end
    return scaled
end

local function forward_from_angles(yaw, pitch)
    local cos_pitch = math.cos(pitch)
    return {
        math.cos(yaw) * cos_pitch,
        math.sin(pitch),
        math.sin(yaw) * cos_pitch,
    }
end

local atan2_available = type(math.atan2) == "function"
if not atan2_available then
    log_debug("math.atan2 unavailable; using fallback for compass heading")
end

local function atan2(y, x)
    if atan2_available then
        return math.atan2(y, x)
    end
    if x == 0.0 then
        if y > 0.0 then
            return math.pi / 2.0
        elseif y < 0.0 then
            return -math.pi / 2.0
        end
        return 0.0
    end
    local angle = math.atan(y / x)
    if x < 0.0 then
        if y >= 0.0 then
            angle = angle + math.pi
        else
            angle = angle - math.pi
        end
    end
    return angle
end

local function update_camera(dt)
    if not gui_input then
        return
    end

    local look_delta_x = gui_input.mouseDeltaX * controls.mouse_sensitivity
    local look_delta_y = -gui_input.mouseDeltaY * controls.mouse_sensitivity

    local pad = gui_input.gamepad
    if pad and pad.connected then
        local stick_x = apply_deadzone(pad.rightX, controls.stick_deadzone)
        local stick_y = apply_deadzone(pad.rightY, controls.stick_deadzone)
        look_delta_x = look_delta_x + stick_x * controls.gamepad_look_speed * dt
        look_delta_y = look_delta_y - stick_y * controls.gamepad_look_speed * dt
    end

    camera.yaw = camera.yaw + look_delta_x
    camera.pitch = clamp(camera.pitch + look_delta_y, -controls.max_pitch, controls.max_pitch)

    local forward = forward_from_angles(camera.yaw, camera.pitch)
    local forward_flat = normalize({forward[1], 0.0, forward[3]})
    local right = normalize(cross(forward_flat, world_up))

    local move_x = 0.0
    local move_z = 0.0
    local move_y = 0.0

    if gui_input.keyStates["move_forward"] then
        move_z = move_z + 1.0
    end
    if gui_input.keyStates["move_back"] then
        move_z = move_z - 1.0
    end
    if gui_input.keyStates["move_right"] then
        move_x = move_x + 1.0
    end
    if gui_input.keyStates["move_left"] then
        move_x = move_x - 1.0
    end

    if gui_input.keyStates["fly_up"] or ui_state.flyUpActive or ui_state.flyUpPulse then
        move_y = move_y + 1.0
    end
    if gui_input.keyStates["fly_down"] or ui_state.flyDownActive or ui_state.flyDownPulse then
        move_y = move_y - 1.0
    end
    ui_state.flyUpPulse = false
    ui_state.flyDownPulse = false

    if pad and pad.connected then
        move_x = move_x + apply_deadzone(pad.leftX, controls.stick_deadzone)
        move_z = move_z - apply_deadzone(pad.leftY, controls.stick_deadzone)
    end

    local length = math.sqrt(move_x * move_x + move_z * move_z)
    if length > 1.0 then
        move_x = move_x / length
        move_z = move_z / length
    end

    if length > 0.0 then
        local speed = controls.move_speed * dt
        camera.position[1] = camera.position[1] + (right[1] * move_x + forward_flat[1] * move_z) * speed
        camera.position[2] = camera.position[2] + (right[2] * move_x + forward_flat[2] * move_z) * speed
        camera.position[3] = camera.position[3] + (right[3] * move_x + forward_flat[3] * move_z) * speed
    end

    if move_y ~= 0.0 then
        camera.position[2] = camera.position[2] + move_y * controls.fly_speed * dt
    end
end

local function update_audio_controls()
    if not gui_input then
        return
    end

    local pad = gui_input.gamepad
    local toggle_pressed = gui_input.keyStates["music_toggle"]
    if pad and pad.connected and pad.togglePressed then
        toggle_pressed = true
    end

    if toggle_pressed and not music_state.togglePressed then
        toggle_music()
    end

    music_state.togglePressed = toggle_pressed and true or false
end

local rotation_speed = 0.9

local function create_spinning_cube()
    local function compute_model_matrix(time)
        return math3d.rotation_y(time * rotation_speed)
    end

    return {
        vertices = cube_vertices,
        indices = cube_indices,
        compute_model_matrix = compute_model_matrix,
        shader_key = "default",
    }
end

local function heading_from_yaw(yaw)
    local forward = forward_from_angles(yaw, 0.0)
    local heading = math.deg(atan2(forward[1], -forward[3])) % 360
    return heading
end

local function heading_to_cardinal(degrees)
    local directions = {"N", "NE", "E", "SE", "S", "SW", "W", "NW"}
    local index = math.floor((degrees + 22.5) / 45.0) % 8 + 1
    return directions[index]
end

local function draw_compass_widget()
    local size = compass_layout.size
    local x = ui_layout.width - size - ui_layout.margin
    local y = ui_layout.margin
    local rect = {x = x, y = y, width = size, height = size}
    gui_context:pushRect(rect, {
        color = {0.06, 0.07, 0.09, 0.88},
        borderColor = {0.35, 0.38, 0.42, 1.0},
    })

    Gui.text(gui_context, {
        x = x,
        y = y + 2,
        width = size,
        height = compass_layout.label_height,
    }, "Compass", {
        fontSize = 12,
        alignX = "center",
        color = {0.82, 0.88, 0.95, 1.0},
    })

    local ring_rect = {
        x = x + compass_layout.padding,
        y = y + compass_layout.label_height,
        width = size - compass_layout.padding * 2,
        height = size - compass_layout.label_height - compass_layout.padding,
    }
    local center_x = ring_rect.x + ring_rect.width / 2
    local center_y = ring_rect.y + ring_rect.height / 2
    local radius = math.min(ring_rect.width, ring_rect.height) / 2 - 6

    Gui.text(gui_context, {x = center_x - 8, y = ring_rect.y - 2, width = 16, height = 14}, "N", {
        fontSize = 12,
        alignX = "center",
        color = {0.78, 0.82, 0.88, 1.0},
    })
    Gui.text(gui_context, {x = ring_rect.x + ring_rect.width - 12, y = center_y - 7, width = 14, height = 14}, "E", {
        fontSize = 12,
        alignX = "center",
        color = {0.78, 0.82, 0.88, 1.0},
    })
    Gui.text(gui_context, {x = center_x - 8, y = ring_rect.y + ring_rect.height - 12, width = 16, height = 14}, "S", {
        fontSize = 12,
        alignX = "center",
        color = {0.78, 0.82, 0.88, 1.0},
    })
    Gui.text(gui_context, {x = ring_rect.x - 2, y = center_y - 7, width = 14, height = 14}, "W", {
        fontSize = 12,
        alignX = "center",
        color = {0.78, 0.82, 0.88, 1.0},
    })

    local heading = heading_from_yaw(camera.yaw)
    local heading_int = math.floor(heading + 0.5) % 360
    local direction = heading_to_cardinal(heading)
    local angle = math.rad(heading) - math.pi / 2.0
    local needle_x = center_x + math.cos(angle) * radius
    local needle_y = center_y + math.sin(angle) * radius

    gui_context:pushRect({
        x = needle_x - 3,
        y = needle_y - 3,
        width = 6,
        height = 6,
    }, {
        color = {0.98, 0.78, 0.35, 1.0},
        radius = 2,
    })

    Gui.text(gui_context, {
        x = x,
        y = y + size - 18,
        width = size,
        height = 16,
    }, string_format("%03d deg %s", heading_int, direction), {
        fontSize = 11,
        alignX = "center",
        color = {0.9, 0.92, 0.95, 1.0},
    })
end

local function draw_flight_buttons()
    local x = ui_layout.width - flight_layout.width - ui_layout.margin
    local y = ui_layout.margin * 2 + compass_layout.size

    local up_clicked = Gui.button(gui_context, "fly_up", {
        x = x,
        y = y,
        width = flight_layout.width,
        height = flight_layout.height,
    }, "Fly Up")
    local down_clicked = Gui.button(gui_context, "fly_down", {
        x = x,
        y = y + flight_layout.height + flight_layout.spacing,
        width = flight_layout.width,
        height = flight_layout.height,
    }, "Fly Down")

    ui_state.flyUpActive = gui_context.activeWidget == "fly_up"
    ui_state.flyDownActive = gui_context.activeWidget == "fly_down"
    ui_state.flyUpPulse = up_clicked
    ui_state.flyDownPulse = down_clicked
end

function get_scene_objects()
    return {
        create_spinning_cube(),
    }
end

function get_shader_paths()
    return shader_variants
end

function get_view_projection(aspect)
    local now = os.clock()
    local dt = 0.0
    if last_frame_time then
        dt = now - last_frame_time
    end
    last_frame_time = now
    if dt < 0.0 then
        dt = 0.0
    elseif dt > 0.1 then
        dt = 0.1
    end

    update_camera(dt)
    update_audio_controls()

    local forward = forward_from_angles(camera.yaw, camera.pitch)
    local center = {
        camera.position[1] + forward[1],
        camera.position[2] + forward[2],
        camera.position[3] + forward[3],
    }

    local view = math3d.look_at(camera.position, center, world_up)
    local projection = math3d.perspective(camera.fov, aspect, camera.near, camera.far)
    return math3d.multiply(projection, view)
end

function get_gui_commands()
    gui_context:beginFrame(gui_input)
    draw_compass_widget()
    draw_flight_buttons()
    gui_context:endFrame()
    return gui_context:getCommands()
end