#include "xr_session.h"

#include <dlfcn.h>
#include <stdlib.h>
#include <string.h>

#include <android/log.h>
#include <jni.h>

#include <EGL/egl.h>
#include <GLES3/gl3.h>

#define XR_USE_PLATFORM_ANDROID 1
#define XR_USE_GRAPHICS_API_OPENGL_ES 1
#include <openxr/openxr.h>
#include <openxr/openxr_platform.h>

#include <SDL.h>

#include "xr_input.h"
#include "xr_menu.h"

#define TAG "QuestShock"
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__)
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__)

// Fixed pose/size for the single game quad - 2m in front of the local space
// origin, sized to preserve the game's own aspect ratio at a comfortable
// visual angle. No per-eye view/projection work is needed for a quad layer
// at all - the compositor handles reprojecting it per eye itself, which is
// exactly why this milestone doesn't need xrLocateViews or any stereo
// rendering (see the plan's step A notes).
#define QUAD_DISTANCE_METERS 2.0f
#define QUAD_WIDTH_METERS 1.6f

// Up to this many swapchain images/FBOs - real runtimes report small counts
// (2-4); this is just a fixed upper bound for the cache arrays below.
#define MAX_SWAPCHAIN_IMAGES 8

static XrInstance g_instance = XR_NULL_HANDLE;
static XrSystemId g_system_id = XR_NULL_SYSTEM_ID;
static XrSession g_session = XR_NULL_HANDLE;
static XrSpace g_local_space = XR_NULL_HANDLE;
static XrSessionState g_session_state = XR_SESSION_STATE_UNKNOWN;
// Distinct from g_session_state - true from a successful xrBeginSession
// until xrEndSession/loss/exit. Many runtimes only advance the *state*
// (e.g. READY -> SYNCHRONIZED -> VISIBLE -> FOCUSED) in response to the
// app actually calling xrWaitFrame/xrBeginFrame/xrEndFrame continuously
// after xrBeginSession - gating frame submission on already having
// reached SYNCHRONIZED+ (as this used to) is a chicken-and-egg deadlock,
// since the runtime never progresses past READY without the frame loop
// running in the first place. Frame calls just need the session to have
// begun, per the standard OpenXR sample pattern - not any particular
// later state.
static bool g_session_running = false;

// A single shared swapchain, wide enough to hold the game's own content
// (left) and the menu's content (right) side by side - see xr_frame_end()
// for how each gets its own imageRect/viewport/scissor sub-rectangle within
// it. Deliberately not two independent swapchains: submitting two
// separately-created swapchains as two XrCompositionLayerQuads makes the
// Horizon OS compositor show the game's own content on the menu quad
// instead of the menu's - a compositor-level limitation with that
// configuration, not something fixable from app-side GL/OpenXR code.
// Sharing one swapchain avoids it entirely.
static XrSwapchain g_swapchain = XR_NULL_HANDLE;
static int g_game_width = 0;
static int g_game_height = 0;
static int g_menu_width = 0;
static int g_menu_height = 0;
static GLuint g_swapchain_fbos[MAX_SWAPCHAIN_IMAGES];
static uint32_t g_swapchain_image_count = 0;

static XrTime g_predicted_display_time = 0;
static bool g_frame_should_render = false;
static bool g_have_acquired_image = false;

// This file's GL calls otherwise resolve to gl4es (the only GL symbol
// provider linked into this binary - see android/engine-patches/
// 02-android-opengl-es.patch), which is fine for anything shared with the
// engine's own gl4es-routed rendering. But the swapchain images OpenXR
// hands us are real driver texture objects gl4es never created itself,
// and gl4es's own glFramebufferTexture2D can't attach a texture it has no
// tracked metadata for. So the FBO *container* is created via gl4es's own
// glGenFramebuffers/glBindFramebuffer (so gl4es recognizes the id as its
// own and its own per-frame glBindFramebuffer succeeds), while the
// texture-attach step - the specifically foreign part - goes through the
// real driver directly, via dlsym against libGLESv2.so.
typedef void (*PFNQSFRAMEBUFFERTEXTURE2D)(GLenum, GLenum, GLenum, GLuint, GLint);
typedef GLenum (*PFNQSCHECKFRAMEBUFFERSTATUS)(GLenum);

static PFNQSFRAMEBUFFERTEXTURE2D real_glFramebufferTexture2D;
static PFNQSCHECKFRAMEBUFFERSTATUS real_glCheckFramebufferStatus;

static bool xr_load_real_gles(void) {
    void *lib = dlopen("libGLESv2.so", RTLD_NOW | RTLD_LOCAL);
    if (lib == NULL) {
        LOGE("XR: dlopen(libGLESv2.so) failed: %s", dlerror());
        return false;
    }
    real_glFramebufferTexture2D = (PFNQSFRAMEBUFFERTEXTURE2D)dlsym(lib, "glFramebufferTexture2D");
    real_glCheckFramebufferStatus =
        (PFNQSCHECKFRAMEBUFFERSTATUS)dlsym(lib, "glCheckFramebufferStatus");
    return real_glFramebufferTexture2D && real_glCheckFramebufferStatus;
}

static bool xr_check(XrResult result, const char *what) {
    if (XR_SUCCEEDED(result))
        return true;
    char resultString[XR_MAX_RESULT_STRING_SIZE] = {0};
    if (g_instance != XR_NULL_HANDLE)
        xrResultToString(g_instance, result, resultString);
    LOGE("XR: %s failed: %s (%d)", what, resultString[0] ? resultString : "?", (int)result);
    return false;
}

static PFN_xrVoidFunction xr_get_proc(const char *name) {
    PFN_xrVoidFunction fn = NULL;
    // xrGetInstanceProcAddr itself works with a NULL instance for the
    // handful of functions (like xrInitializeLoaderKHR) that must be called
    // before an instance exists.
    if (!xr_check(xrGetInstanceProcAddr(g_instance, name, &fn), name))
        return NULL;
    return fn;
}

// The Android OpenXR loader needs the JavaVM/context before anything else -
// separate from XR_KHR_android_create_instance below, which only affects
// xrCreateInstance itself. Skipping this is a common cause of
// xrCreateInstance silently failing to find a runtime on Android.
static bool xr_initialize_android_loader(JavaVM *vm, jobject activity) {
    PFN_xrInitializeLoaderKHR initializeLoader =
        (PFN_xrInitializeLoaderKHR)xr_get_proc("xrInitializeLoaderKHR");
    if (initializeLoader == NULL) {
        LOGE("XR: xrInitializeLoaderKHR not available - no Android OpenXR loader present?");
        return false;
    }

    XrLoaderInitInfoAndroidKHR loaderInitInfo = {XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR};
    loaderInitInfo.applicationVM = vm;
    loaderInitInfo.applicationContext = activity;
    return xr_check(initializeLoader((const XrLoaderInitInfoBaseHeaderKHR *)&loaderInitInfo),
                     "xrInitializeLoaderKHR");
}

// eglGetCurrentDisplay()/eglGetCurrentContext() hand us the display/context,
// but not the EGLConfig they were created with - eglQueryContext's
// EGL_CONFIG_ID plus eglChooseConfig is the standard way to recover it (the
// same trick Khronos' own hello_xr sample uses).
static EGLConfig xr_get_current_egl_config(EGLDisplay display, EGLContext context) {
    EGLint configId = 0;
    eglQueryContext(display, context, EGL_CONFIG_ID, &configId);

    EGLint attribs[] = {EGL_CONFIG_ID, configId, EGL_NONE};
    EGLConfig config = NULL;
    EGLint numConfigs = 0;
    eglChooseConfig(display, attribs, &config, 1, &numConfigs);
    return config;
}

static bool xr_create_instance_and_session(int game_width, int game_height) {
    JNIEnv *env = (JNIEnv *)SDL_AndroidGetJNIEnv();
    jobject activity = (jobject)SDL_AndroidGetActivity();
    if (env == NULL || activity == NULL) {
        LOGE("XR: no JNIEnv/Activity from SDL - can't init OpenXR");
        return false;
    }
    JavaVM *vm = NULL;
    (*env)->GetJavaVM(env, &vm);

    if (!xr_initialize_android_loader(vm, activity))
        return false;

    const char *extensions[] = {
        XR_KHR_ANDROID_CREATE_INSTANCE_EXTENSION_NAME,
        XR_KHR_OPENGL_ES_ENABLE_EXTENSION_NAME,
    };

    XrInstanceCreateInfoAndroidKHR androidInfo = {XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR};
    androidInfo.applicationVM = vm;
    androidInfo.applicationActivity = activity;

    XrInstanceCreateInfo createInfo = {XR_TYPE_INSTANCE_CREATE_INFO};
    createInfo.next = &androidInfo;
    createInfo.enabledExtensionCount = sizeof(extensions) / sizeof(extensions[0]);
    createInfo.enabledExtensionNames = extensions;
    strncpy(createInfo.applicationInfo.applicationName, "QuestShock",
            XR_MAX_APPLICATION_NAME_SIZE - 1);
    strncpy(createInfo.applicationInfo.engineName, "Shockolate", XR_MAX_ENGINE_NAME_SIZE - 1);
    createInfo.applicationInfo.applicationVersion = 1;
    createInfo.applicationInfo.engineVersion = 1;
    createInfo.applicationInfo.apiVersion = XR_CURRENT_API_VERSION;

    if (!xr_check(xrCreateInstance(&createInfo, &g_instance), "xrCreateInstance"))
        return false;

    XrSystemGetInfo systemInfo = {XR_TYPE_SYSTEM_GET_INFO};
    systemInfo.formFactor = XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY;
    if (!xr_check(xrGetSystem(g_instance, &systemInfo, &g_system_id), "xrGetSystem"))
        return false;

    // Required by spec before creating an OpenGL ES-backed session, even
    // though we don't gate on the returned min/max API version here.
    PFN_xrGetOpenGLESGraphicsRequirementsKHR getGLESRequirements =
        (PFN_xrGetOpenGLESGraphicsRequirementsKHR)xr_get_proc("xrGetOpenGLESGraphicsRequirementsKHR");
    if (getGLESRequirements == NULL)
        return false;
    XrGraphicsRequirementsOpenGLESKHR glesRequirements = {XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR};
    if (!xr_check(getGLESRequirements(g_instance, g_system_id, &glesRequirements),
                  "xrGetOpenGLESGraphicsRequirementsKHR"))
        return false;

    EGLDisplay display = eglGetCurrentDisplay();
    EGLContext context = eglGetCurrentContext();
    if (display == EGL_NO_DISPLAY || context == EGL_NO_CONTEXT) {
        LOGE("XR: no current EGL display/context - call xr_init() after init_opengl()");
        return false;
    }

    XrGraphicsBindingOpenGLESAndroidKHR graphicsBinding = {
        XR_TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR};
    graphicsBinding.display = display;
    graphicsBinding.config = xr_get_current_egl_config(display, context);
    graphicsBinding.context = context;

    XrSessionCreateInfo sessionInfo = {XR_TYPE_SESSION_CREATE_INFO};
    sessionInfo.next = &graphicsBinding;
    sessionInfo.systemId = g_system_id;
    if (!xr_check(xrCreateSession(g_instance, &sessionInfo, &g_session), "xrCreateSession"))
        return false;

    XrReferenceSpaceCreateInfo spaceInfo = {XR_TYPE_REFERENCE_SPACE_CREATE_INFO};
    spaceInfo.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_LOCAL;
    spaceInfo.poseInReferenceSpace.orientation.w = 1.0f;
    if (!xr_check(xrCreateReferenceSpace(g_session, &spaceInfo, &g_local_space),
                  "xrCreateReferenceSpace"))
        return false;

    // Non-fatal if it fails (e.g. no controllers bound yet) - rendering
    // keeps working either way, just without the laser pointer.
    xr_input_init(g_instance, g_session);

    // Prefer a plain linear 8-bit format over GL_SRGB8_ALPHA8: the source
    // SDL surface pixels are already sRGB-encoded (as ordinary 8-bit image
    // data conventionally is) and get uploaded/sampled as plain linear
    // GL_RGBA with no decode step anywhere in this path, matching the
    // desktop SDL_RenderCopy path this replaces - an sRGB swapchain format
    // would auto-gamma-encode on write and double-encode already-encoded
    // data.
    uint32_t formatCount = 0;
    xrEnumerateSwapchainFormats(g_session, 0, &formatCount, NULL);
    int64_t *formats = (int64_t *)malloc(sizeof(int64_t) * formatCount);
    xrEnumerateSwapchainFormats(g_session, formatCount, &formatCount, formats);
    int64_t chosenFormat = formats[0];
    for (uint32_t i = 0; i < formatCount; i++) {
        LOGI("XR: swapchain format[%u] = 0x%llx", i, (unsigned long long)formats[i]);
        if (formats[i] == GL_RGBA8) {
            chosenFormat = GL_RGBA8;
            break;
        }
    }
    free(formats);

    g_game_width = game_width;
    g_game_height = game_height;
    xr_menu_get_content_size(&g_menu_width, &g_menu_height);
    // The game's own content occupies (0,0)-(game_width,game_height); the
    // menu's occupies (game_width,0)-(game_width+menu_width,menu_height) -
    // side by side in one image, wide enough and tall enough for both.
    uint32_t sharedWidth = (uint32_t)(g_game_width + g_menu_width);
    uint32_t sharedHeight = (uint32_t)(g_game_height > g_menu_height ? g_game_height : g_menu_height);

    XrSwapchainCreateInfo swapchainInfo = {XR_TYPE_SWAPCHAIN_CREATE_INFO};
    swapchainInfo.usageFlags = XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT | XR_SWAPCHAIN_USAGE_SAMPLED_BIT;
    swapchainInfo.format = chosenFormat;
    swapchainInfo.sampleCount = 1;
    swapchainInfo.width = sharedWidth;
    swapchainInfo.height = sharedHeight;
    swapchainInfo.faceCount = 1;
    swapchainInfo.arraySize = 1;
    swapchainInfo.mipCount = 1;
    if (!xr_check(xrCreateSwapchain(g_session, &swapchainInfo, &g_swapchain),
                  "xrCreateSwapchain"))
        return false;

    uint32_t imageCount = 0;
    xrEnumerateSwapchainImages(g_swapchain, 0, &imageCount, NULL);
    if (imageCount > MAX_SWAPCHAIN_IMAGES) {
        LOGE("XR: swapchain reports %u images, only room for %d", imageCount,
             MAX_SWAPCHAIN_IMAGES);
        return false;
    }
    // Zero-initialized, not just `.type` set per element - these structs
    // also carry a `next` field the runtime may read, and an
    // uninitialized stack array would leave it as garbage.
    XrSwapchainImageOpenGLESKHR images[MAX_SWAPCHAIN_IMAGES] = {0};
    for (uint32_t i = 0; i < imageCount; i++)
        images[i].type = XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR;
    if (!xr_check(xrEnumerateSwapchainImages(g_swapchain, imageCount, &imageCount,
                                              (XrSwapchainImageBaseHeader *)images),
                  "xrEnumerateSwapchainImages"))
        return false;
    g_swapchain_image_count = imageCount;

    if (!xr_load_real_gles()) {
        LOGE("XR: couldn't resolve real GLES FBO functions via dlsym");
        return false;
    }

    // Wraps each swapchain-provided texture in its own framebuffer, matching
    // how OpenGL.cc's own CreateFrameBuffer() wraps backupBuffer - just
    // without a depth/stencil attachment, since the final composite draw
    // (see opengl_swap_and_restore) never needs one. The Gen/Bind calls are
    // gl4es's own (linked, not dlsym'd) - see the comment above
    // real_glFramebufferTexture2D for why.
    bool all_complete = true;
    for (uint32_t i = 0; i < imageCount; i++) {
        glGenFramebuffers(1, &g_swapchain_fbos[i]);
        glBindFramebuffer(GL_FRAMEBUFFER, g_swapchain_fbos[i]);
        real_glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                                     images[i].image, 0);
        GLenum status = real_glCheckFramebufferStatus(GL_FRAMEBUFFER);
        if (status != GL_FRAMEBUFFER_COMPLETE) {
            LOGE("XR: swapchain FBO %u incomplete: 0x%x", i, status);
            all_complete = false;
        }
    }
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
    if (!all_complete)
        return false;

    LOGI("XR: instance/session/swapchain ready (%ux%u shared, %dx%d game + %dx%d menu, %u images)",
         sharedWidth, sharedHeight, g_game_width, g_game_height, g_menu_width, g_menu_height,
         imageCount);

    // Also non-fatal - the game keeps rendering with no menu quad if this
    // fails (e.g. MenuOverlay couldn't be resolved via JNI).
    xr_menu_init(g_instance, g_session);

    return true;
}

bool xr_init(int game_width, int game_height) {
    if (!xr_create_instance_and_session(game_width, game_height)) {
        LOGE("XR: bring-up failed - falling back to the normal window present path");
        xr_shutdown();
        return false;
    }
    return true;
}

void xr_poll_events(void) {
    if (g_instance == XR_NULL_HANDLE)
        return;

    while (true) {
        XrEventDataBuffer event = {XR_TYPE_EVENT_DATA_BUFFER};
        XrResult result = xrPollEvent(g_instance, &event);
        if (result == XR_EVENT_UNAVAILABLE)
            break;
        if (!xr_check(result, "xrPollEvent"))
            break;

        if (event.type == XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED) {
            XrEventDataSessionStateChanged *stateEvent = (XrEventDataSessionStateChanged *)&event;
            g_session_state = stateEvent->state;
            LOGI("XR: session state -> %d", (int)g_session_state);

            if (g_session_state == XR_SESSION_STATE_READY) {
                XrSessionBeginInfo beginInfo = {XR_TYPE_SESSION_BEGIN_INFO};
                beginInfo.primaryViewConfigurationType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO;
                g_session_running = xr_check(xrBeginSession(g_session, &beginInfo), "xrBeginSession");
            } else if (g_session_state == XR_SESSION_STATE_STOPPING) {
                xr_check(xrEndSession(g_session), "xrEndSession");
                g_session_running = false;
            } else if (g_session_state == XR_SESSION_STATE_EXITING ||
                       g_session_state == XR_SESSION_STATE_LOSS_PENDING) {
                g_session_running = false;
            }
        }
    }
}

bool xr_is_session_running(void) { return g_session_running; }

bool xr_frame_begin(void) {
    g_have_acquired_image = false;
    if (!xr_is_session_running())
        return false;

    XrFrameWaitInfo waitInfo = {XR_TYPE_FRAME_WAIT_INFO};
    XrFrameState frameState = {XR_TYPE_FRAME_STATE};
    if (!xr_check(xrWaitFrame(g_session, &waitInfo, &frameState), "xrWaitFrame"))
        return false;
    g_predicted_display_time = frameState.predictedDisplayTime;
    g_frame_should_render = frameState.shouldRender;

    XrFrameBeginInfo beginInfo = {XR_TYPE_FRAME_BEGIN_INFO};
    if (!xr_check(xrBeginFrame(g_session, &beginInfo), "xrBeginFrame"))
        return false;

    if (!g_frame_should_render)
        return false;

    uint32_t imageIndex = 0;
    XrSwapchainImageAcquireInfo acquireInfo = {XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO};
    if (!xr_check(xrAcquireSwapchainImage(g_swapchain, &acquireInfo, &imageIndex),
                  "xrAcquireSwapchainImage"))
        return false;

    XrSwapchainImageWaitInfo waitImageInfo = {XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO};
    waitImageInfo.timeout = XR_INFINITE_DURATION;
    if (!xr_check(xrWaitSwapchainImage(g_swapchain, &waitImageInfo), "xrWaitSwapchainImage"))
        return false;

    // gl4es's own (linked, not dlsym'd) bind - this targets an FBO id
    // gl4es itself created (see xr_create_instance_and_session()), so its
    // own "current FBO" bookkeeping updates correctly and its immediate-
    // mode draw calls in android_draw_surface_as_quad() land in the right
    // place. Scissor-limited to the game's own sub-rectangle of the shared
    // image (see g_swapchain's comment) - glViewport alone would already
    // keep the engine's draw calls within that rectangle, but glClear
    // ignores viewport and would otherwise wipe the menu's own region of
    // the same image whenever the engine clears before drawing.
    glBindFramebuffer(GL_FRAMEBUFFER, g_swapchain_fbos[imageIndex]);
    glViewport(0, 0, g_game_width, g_game_height);
    glEnable(GL_SCISSOR_TEST);
    glScissor(0, 0, g_game_width, g_game_height);

    g_have_acquired_image = true;
    return true;
}

void xr_frame_end(void) {
    if (g_session == XR_NULL_HANDLE)
        return;

    // Draw the laser-pointer reticle into the still-bound swapchain
    // framebuffer before releasing it, so it composites on top of
    // whatever this frame's game content already drew there. Syncing
    // actions happens even when there's nothing to draw (no acquired
    // image this frame), so edge detection (trigger/menu-button clicks)
    // doesn't miss a frame. Only ever draws while the menu isn't visible
    // (see xr_input.c), so it never needs to know about the menu's own
    // sub-rectangle below.
    if (xr_is_session_running())
        xr_input_sync_and_draw(g_local_space, g_predicted_display_time, g_have_acquired_image);

    bool menuVisible = g_have_acquired_image && xr_menu_is_visible();
    if (menuVisible) {
        // Switch viewport/scissor to the menu's own sub-rectangle of the
        // same shared image (to the right of the game's own region, see
        // g_swapchain's comment) and let xr_menu.c draw its content there -
        // still the same framebuffer bound in xr_frame_begin(), just a
        // different sub-rectangle of it.
        glViewport(g_game_width, 0, g_menu_width, g_menu_height);
        glScissor(g_game_width, 0, g_menu_width, g_menu_height);
        xr_menu_render_if_visible();
    }

    if (g_have_acquired_image) {
        glDisable(GL_SCISSOR_TEST);
        XrSwapchainImageReleaseInfo releaseInfo = {XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO};
        xr_check(xrReleaseSwapchainImage(g_swapchain, &releaseInfo), "xrReleaseSwapchainImage");
    }

    if (!xr_is_session_running())
        return;

    XrCompositionLayerQuad gameQuad = {XR_TYPE_COMPOSITION_LAYER_QUAD};
    gameQuad.space = g_local_space;
    gameQuad.eyeVisibility = XR_EYE_VISIBILITY_BOTH;
    gameQuad.subImage.swapchain = g_swapchain;
    gameQuad.subImage.imageRect.offset.x = 0;
    gameQuad.subImage.imageRect.offset.y = 0;
    gameQuad.subImage.imageRect.extent.width = g_game_width;
    gameQuad.subImage.imageRect.extent.height = g_game_height;
    gameQuad.pose.orientation.w = 1.0f;
    gameQuad.pose.position.z = -QUAD_DISTANCE_METERS;
    gameQuad.size.width = QUAD_WIDTH_METERS;
    gameQuad.size.height = QUAD_WIDTH_METERS * (float)g_game_height / (float)g_game_width;

    // Up to 2 layers: the game quad (if a frame was actually rendered) and,
    // while toggled on, the menu quad in front of it - see xr_input.c's
    // menu_toggle handling. Both reference the SAME g_swapchain, just
    // different imageRect sub-rectangles within it.
    const XrCompositionLayerBaseHeader *layers[2];
    uint32_t layerCount = 0;
    if (g_have_acquired_image)
        layers[layerCount++] = (XrCompositionLayerBaseHeader *)&gameQuad;

    XrCompositionLayerQuad menuQuad = {XR_TYPE_COMPOSITION_LAYER_QUAD};
    if (menuVisible) {
        float centerX, centerY, distance, halfWidth, halfHeight;
        xr_menu_get_quad_extent(&centerX, &centerY, &distance, &halfWidth, &halfHeight);
        menuQuad.space = g_local_space;
        menuQuad.eyeVisibility = XR_EYE_VISIBILITY_BOTH;
        menuQuad.subImage.swapchain = g_swapchain;
        menuQuad.subImage.imageRect.offset.x = g_game_width;
        menuQuad.subImage.imageRect.offset.y = 0;
        menuQuad.subImage.imageRect.extent.width = g_menu_width;
        menuQuad.subImage.imageRect.extent.height = g_menu_height;
        menuQuad.pose.orientation.w = 1.0f;
        menuQuad.pose.position.x = centerX;
        menuQuad.pose.position.y = centerY;
        menuQuad.pose.position.z = -distance;
        menuQuad.size.width = halfWidth * 2.0f;
        menuQuad.size.height = halfHeight * 2.0f;
        layers[layerCount++] = (XrCompositionLayerBaseHeader *)&menuQuad;
    }

    XrFrameEndInfo endInfo = {XR_TYPE_FRAME_END_INFO};
    endInfo.displayTime = g_predicted_display_time;
    endInfo.environmentBlendMode = XR_ENVIRONMENT_BLEND_MODE_OPAQUE;
    endInfo.layerCount = layerCount;
    endInfo.layers = layerCount > 0 ? layers : NULL;
    xr_check(xrEndFrame(g_session, &endInfo), "xrEndFrame");
}

void xr_shutdown(void) {
    for (uint32_t i = 0; i < g_swapchain_image_count; i++) {
        if (g_swapchain_fbos[i] != 0)
            glDeleteFramebuffers(1, &g_swapchain_fbos[i]);
    }
    g_swapchain_image_count = 0;

    if (g_swapchain != XR_NULL_HANDLE)
        xrDestroySwapchain(g_swapchain);
    g_swapchain = XR_NULL_HANDLE;

    if (g_local_space != XR_NULL_HANDLE)
        xrDestroySpace(g_local_space);
    g_local_space = XR_NULL_HANDLE;

    // Before the session/instance they were created from.
    xr_input_shutdown();
    xr_menu_shutdown();

    if (g_session != XR_NULL_HANDLE)
        xrDestroySession(g_session);
    g_session = XR_NULL_HANDLE;

    if (g_instance != XR_NULL_HANDLE)
        xrDestroyInstance(g_instance);
    g_instance = XR_NULL_HANDLE;

    g_session_state = XR_SESSION_STATE_UNKNOWN;
    g_session_running = false;
}

void xr_get_game_quad_extent(float *distance_m, float *half_width_m, float *half_height_m) {
    *distance_m = QUAD_DISTANCE_METERS;
    *half_width_m = QUAD_WIDTH_METERS * 0.5f;
    *half_height_m = QUAD_WIDTH_METERS * 0.5f * (float)g_game_height / (float)g_game_width;
}
