#include <openxr/openxr.h>

#ifndef XR_FB_spatial_entity
#define XR_FB_spatial_entity_EXPERIMENTAL_VERSION 2
#include <openxr/fb_spatial_entity.h>
#endif

#ifndef XR_FB_spatial_entity_storage
#define XR_FB_spatial_entity_storage_EXPERIMENTAL_VERSION 2
#include <openxr/fb_spatial_entity_storage.h>
#endif

#ifndef XR_FB_spatial_entity_query
#define XR_FB_spatial_entity_query_EXPERIMENTAL_VERSION 2
#include <openxr/fb_spatial_entity_query.h>
#endif

#include <openxr/openxr.h>

OXR(xrGetInstanceProcAddr(
  instance,
  "xrCreateSpatialAnchorFB",
  (PFN_xrVoidFunction*)(&app.FunPtrs.xrCreateSpatialAnchorFB)));

OXR(xrGetInstanceProcAddr(
  instance,
  "xrEnumerateSpaceSupportedComponentsFB",
  (PFN_xrVoidFunction*)(&app.FunPtrs.xrEnumerateSpaceSupportedComponentsFB)));

OXR(xrGetInstanceProcAddr(
  instance,
  "xrGetSpaceComponentStatusFB",
  (PFN_xrVoidFunction*)(&app.FunPtrs.xrGetSpaceComponentStatusFB)));

OXR(xrGetInstanceProcAddr(
  instance,
  "xrSetSpaceComponentStatusFB",
  (PFN_xrVoidFunction*)(&app.FunPtrs.xrSetSpaceComponentStatusFB)));

OXR(xrGetInstanceProcAddr(
  instance, "xrQuerySpacesFB", (PFN_xrVoidFunction*)(&app.FunPtrs.xrQuerySpacesFB)));

OXR(xrGetInstanceProcAddr(
  instance,
  "xrRetrieveSpaceQueryResultsFB",
  (PFN_xrVoidFunction*)(&app.FunPtrs.xrRetrieveSpaceQueryResultsFB)));

OXR(xrGetInstanceProcAddr(
  instance, "xrSaveSpaceFB", (PFN_xrVoidFunction*)(&app.FunPtrs.xrSaveSpaceFB)));

OXR(xrGetInstanceProcAddr(
  instance, "xrEraseSpaceFB", (PFN_xrVoidFunction*)(&app.FunPtrs.xrEraseSpaceFB)));

#include <openxr/openxr.h>

// Assumptions:
//   ContentObject is some app-defined class representing content
//     that can be attached to an Anchor.
//   contentToAttachToNewAnchor is some std::vector of content objects
//     that was populated before initiating the xrCreateSpatialAnchorFB(3)
//     call.

// These maps should be visible from both the code making the
// xrCreateSpatialAnchorFB call and from the event handler code.
std::unordered_map<XrAsyncRequestId, std::vector<ContentObject>> anchorCreationRequests;
std::unordered_map<XrSpace, std::vector<ContentObject>> anchorToContentMap;
. . .
XrSpatialAnchorCreateInfoFB anchorCreateInfo = {XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_FB};
anchorCreateInfo.space = app.LocalSpace;
anchorCreateInfo.poseInSpace = ToXrPosef(localFromRightAim);
anchorCreateInfo.time = frameState.predictedDisplayTime;
XrAsyncRequestIdFB createRequest;
OXR(app.FunPtrs.xrCreateSpatialAnchorFB(app.Session, &anchorCreateInfo, &createRequest));

// Associate the content to be attached with the creation request ID
// so that it can be attached to the Anchor on completion of the create operation.
anchorCreationRequests.insert_or_assign(createRequest, contentToAttachToNewAnchor);

. . .

. . .

// Event handler code
case XR_TYPE_EVENT_DATA_SPATIAL_ANCHOR_CREATE_COMPLETE_FB: {
  const XrEventDataSpatialAnchorCreateCompleteFB* createAnchorResult =
    (XrEventDataSpatialAnchorCreateCompleteFB*)(baseEventHeader);
  XrSpace space = createAnchorResult->space;

  // Set up the content attachment to Spatial Anchor.
  XrAsyncRequestIdFB creationRequestId = createAnchorResult->requestId;
  if (anchorCreationRequests.contains(creationRequestId) {
    anchorToContentMap.insert_or_assign(
        space, anchorCreationRequests[creationRequestId]);
    anchorCreationRequests.erase(creationRequestId);
  }

  // The optional blob below is an example of immediately saving
  // (persisting) the Spatial Anchor that was just created.
  if (IsComponentSupported(space, XR_SPACE_COMPONENT_TYPE_STORABLE_FB)) {
    XrSpaceComponentStatusSetInfoFB request = {
      XR_TYPE_SPACE_COMPONENT_STATUS_SET_INFO_FB,
      nullptr,
      XR_SPACE_COMPONENT_TYPE_STORABLE_FB,
      XR_TRUE,
      0};

    XrAsyncRequestIdFB requestId;
    XrResult res = FunPtrs.xrSetSpaceComponentStatusFB(space,
      &request, &saveRequestId);
    if (res == XR_ERROR_SPACE_COMPONENT_STATUS_ALREADY_SET_FB) {
      XrSpaceSaveInfoFB saveInfo = {
        XR_TYPE_SPACE_SAVE_INFO_FB,
        nullptr,
        space,
        XR_SPACE_STORAGE_LOCATION_LOCAL_FB,
        XR_SPACE_PERSISTENCE_MODE_INDEFINITE_FB};

      // save the space
      OXR(FunPtrs.xrSaveSpaceFB(Session, &saveInfo, &requestId));
    }
  }
} break;
. . .

case XR_TYPE_EVENT_DATA_SPACE_QUERY_RESULTS_AVAILABLE_FB: {
  const auto resultsAvailable =
    (XrEventDataSpaceQueryResultsAvailableFB*)baseEventHeader;
  XrResult res = XR_SUCCESS;
  XrSpaceQueryResultsFB queryResults{XR_TYPE_SPACE_QUERY_RESULTS_FB};
  res = FunPtrs.xrRetrieveSpaceQueryResultsFB(
    Session, resultsAvailable->requestId, &queryResults);
  if (res != XR_SUCCESS) {
    break;
  }
  std::vector<XrSpaceQueryResultFB> results(queryResults.resultCountOutput);
  queryResults.resultCapacityInput = results.size();
  queryResults.results = results.data();
  res = FunPtrs.xrRetrieveSpaceQueryResultsFB(
    Session, resultsAvailable->requestId, &queryResults);
  for (uint32_t i = 0; i < queryResults.resultCountOutput; ++i) {
    . . .
  }
} break;

typedef struct XrEventDataSpatialAnchorCreateCompleteFB {
  XrStructureType type;
  const void* XR_MAY_ALIAS   next;
  XrAsyncRequestIdFB         requestId;
  XrResult                   result;
  XrSpace                    space;
  XrUuidEXT                  uuid;
} XrEventDataSpatialAnchorCreateCompleteFB;

typedef struct XrEventDataSetComponentEnableResultFB {
  XrStructureType type;
  const void* XR_MAY_ALIAS   next;
  XrAsyncRequestIdFB         requestId;
  XrResult                   result;
  XrComponentTypeFB          componentType;
  XrSpace                    space;</code>
} XrEventDataSetComponentEnableResultFB;

typedef struct XrEventDataSpaceSetStatusCompleteFB {
  XrStructureType            type;
  const void* XR_MAY_ALIAS   next;
  XrAsyncRequestIdFB         requestId;
  XrResult                   result;
  XrSpace                    space;
  XrUuidEXT                  uuid;
  XrSpaceComponentTypeFB     componentType;
  XrBool32                   enabled;
} XrEventDataSpaceSetStatusCompleteFB;

typedef struct XrEventSpatialEntityQueryResultsFB {
  XrStructureType                type;
  const void* XR_MAY_ALIAS       next;
  XrAsyncRequestIdFB             request;
  uint32_t                       numResults;
  XrSpatialEntityQueryResultFB[] results;
} XrEventSpatialEntityQueryResultsFB;

typedef struct XrEventDataSpaceQueryResultsAvailableFB {
  XrStructureType            type;
  const void* XR_MAY_ALIAS   next;
  XrAsyncRequestIdFB         requestId;
} XrEventDataSpaceQueryResultsAvailableFB;

typedef struct XrEventSpatialEntityQueryCompleteFB {
  XrStructureType            type;
  const void* XR_MAY_ALIAS   next;
  XrResult                   result;
  int32_t                    numSpacesFound;
  XrAsyncRequestIdFB         request;
} XrEventSpatialEntityQueryCompleteFB;

typedef struct XrEventDataSpaceQueryCompleteFB {
  XrStructureType            type;
  const void* XR_MAY_ALIAS   next;
  XrAsyncRequestIdFB         requestId;
  XrResult                   result;
} XrEventDataSpaceQueryCompleteFB;

typedef struct XrEventSpatialEntityStorageSaveResultFB {
  XrStructureType            type;
  const void* XR_MAY_ALIAS   next;
  XrResult                   result;
  XrSpace                    space;
  XrSpatialEntityUuidFB      uuid;
  XrAsyncRequestIdFB         request;
} XrEventSpatialEntityStorageSaveResultFB;

typedef struct XrEventDataSpaceSaveCompleteFB {
  XrStructureType            type;
  const void* XR_MAY_ALIAS   next;
  XrAsyncRequestIdFB         requestId;
  XrResult                   result;
  XrSpace                    space;
  XrUuidEXT                  uuid;
  XrSpaceStorageLocationFB   location;
} XrEventDataSpaceSaveCompleteFB;

typedef struct XrEventSpatialEntityStorageEraseResultFB {
  XrStructureType                  type;
  const void* XR_MAY_ALIAS         next;
  XrResult                         result;
  XrSpatialEntityStorageLocationFB location;
  XrSpatialEntityUuidFB            uuid;
  XrAsyncRequestIdFB               request;
} XrEventSpatialEntityStorageEraseResultFB;

typedef struct XrEventDataSpaceEraseCompleteFB {
  XrStructureType            type;
  const void* XR_MAY_ALIAS   next;
  XrAsyncRequestIdFB         requestId;
  XrResult                   result;
  XrSpace                    space;
  XrUuidEXT                  uuid;
  XrSpaceStorageLocationFB   location;
} XrEventDataSpaceEraseCompleteFB;