// Include only the application API header
#include <openvr.h>
#include <string>
#include <cstring>
#include <iostream>

// Forward declare the driver interfaces we need
namespace vr
{
    class IVRDriverManager;
    class IVRDriverInput;
}

// Define the export macro based on the platform
#if defined(_WIN32)
    #define EXPORT_API __declspec(dllexport)
#else
    #define EXPORT_API
#endif

// Global variables
vr::IVRSystem* g_pVRSystem = nullptr;
vr::IVRDriverManager* g_pDriverManager = nullptr;
vr::IVRDriverInput* g_pDriverInput = nullptr;
std::string g_driverName = "Unknown";
bool g_isInitialized = false;

// Helper function to get a generic interface
template<class T>
T* GetGenericInterface(const char* interfaceName) {
    vr::EVRInitError error = vr::VRInitError_None;
    T* interface_ptr = (T*)vr::VR_GetGenericInterface(interfaceName, &error);
    
    if (error != vr::VRInitError_None) {
        std::cerr << "Failed to get interface " << interfaceName << ": " << error << std::endl;
        return nullptr;
    }
    
    return interface_ptr;
}

// Initialize the plugin and connect to OpenVR
extern "C" EXPORT_API bool InitializePlugin() {
    if (g_isInitialized) {
        return true;
    }
    
    // Initialize OpenVR
    vr::EVRInitError error = vr::VRInitError_None;
    g_pVRSystem = vr::VR_Init(&error, vr::VRApplication_Background);
    
    if (error != vr::VRInitError_None) {
        std::cerr << "Failed to initialize OpenVR: " << error << std::endl;
        return false;
    }
    
    // Try to get driver manager interface
    g_pDriverManager = GetGenericInterface<vr::IVRDriverManager>("IVRDriverManager_001");
    
    // Try to get driver input interface
    g_pDriverInput = GetGenericInterface<vr::IVRDriverInput>("IVRDriverInput_005");
    
    // Get the driver name
    if (g_pVRSystem) {
        char buffer[256];
        vr::ETrackedPropertyError propError = vr::TrackedProp_Success;
        g_pVRSystem->GetStringTrackedDeviceProperty(vr::k_unTrackedDeviceIndex_Hmd, 
            vr::Prop_TrackingSystemName_String, buffer, sizeof(buffer), &propError);
            
        if (propError == vr::TrackedProp_Success) {
            g_driverName = buffer;
        }
    }
    
    g_isInitialized = true;
    return true;
}

// Shutdown the plugin and disconnect from OpenVR
extern "C" EXPORT_API void ShutdownPlugin() {
    if (g_isInitialized) {
        vr::VR_Shutdown();
        g_pVRSystem = nullptr;
        g_pDriverManager = nullptr;
        g_pDriverInput = nullptr;
        g_isInitialized = false;
    }
}

// Get raw gyroscope data from the headset
extern "C" EXPORT_API bool GetRawGyroscopeData(float* x, float* y, float* z) {
    if (!g_isInitialized || !g_pVRSystem) {
        return false;
    }
    
    // TODO: Implement direct access to raw gyroscope data
    // This is where you would need to access the driver-level API
    // to get the raw IMU data
    
    // For now, we'll try to get it from the tracked device pose
    vr::TrackedDevicePose_t poses[vr::k_unMaxTrackedDeviceCount];
    g_pVRSystem->GetDeviceToAbsoluteTrackingPose(
        vr::TrackingUniverseRawAndUncalibrated, 
        0, 
        poses, 
        vr::k_unMaxTrackedDeviceCount);
    
    if (poses[vr::k_unTrackedDeviceIndex_Hmd].bDeviceIsConnected) {
        *x = poses[vr::k_unTrackedDeviceIndex_Hmd].vAngularVelocity.v[0];
        *y = poses[vr::k_unTrackedDeviceIndex_Hmd].vAngularVelocity.v[1];
        *z = poses[vr::k_unTrackedDeviceIndex_Hmd].vAngularVelocity.v[2];
        return true;
    }
    
    // If we can't get the data from the pose, try to access it directly
    // This would require knowledge of the specific driver implementation
    // and might not be possible through the public OpenVR API
    
    return false;
}

// Get raw accelerometer data from the headset
extern "C" EXPORT_API bool GetRawAccelerometerData(float* x, float* y, float* z) {
    if (!g_isInitialized || !g_pVRSystem) {
        return false;
    }
    
    // TODO: Implement direct access to raw accelerometer data
    // Similar to the gyroscope data, this would require
    // driver-level access
    
    return false;
}

// Check if the headset is connected
extern "C" EXPORT_API bool IsHeadsetConnected() {
    if (!g_isInitialized || !g_pVRSystem) {
        return false;
    }
    
    return g_pVRSystem->IsTrackedDeviceConnected(vr::k_unTrackedDeviceIndex_Hmd);
}

// Get the current tracking state
extern "C" EXPORT_API bool IsTrackingValid() {
    if (!g_isInitialized || !g_pVRSystem) {
        return false;
    }
    
    vr::TrackedDevicePose_t pose;
    g_pVRSystem->GetDeviceToAbsoluteTrackingPose(
        vr::TrackingUniverseStanding, 
        0, 
        &pose, 
        1);
    
    return pose.bPoseIsValid;
}

// Get the driver name
extern "C" EXPORT_API const char* GetDriverName() {
    return g_driverName.c_str();
}

// Additional functions for direct driver access could be added here
// These would depend on the specific driver implementation and might
// require reverse engineering or access to driver source code