#pragma once

#include <openvr_driver.h>
#include "../lighthouse_driver_wrapper.h"
#include <vector>
#include <memory>

namespace sauna {

// Mock implementation of the lighthouse driver for testing
class MockLighthouseDriver {
private:
    bool isInitialized;
    bool isConnected;
    std::vector<vr::TrackedDevicePose_t> devicePoses;
    bool opticalTrackingAvailable;
    
public:
    MockLighthouseDriver() 
        : isInitialized(false)
        , isConnected(false)
        , opticalTrackingAvailable(true) {
        // Initialize with some default poses
        devicePoses.resize(vr::k_unMaxTrackedDeviceCount);
        for (auto& pose : devicePoses) {
            pose.bPoseIsValid = false;
            pose.bDeviceIsConnected = false;
            pose.eTrackingResult = vr::TrackingResult_Uninitialized;
        }
    }
    
    // Simulate initialization of the lighthouse driver
    bool Initialize() {
        isInitialized = true;
        return true;
    }
    
    // Simulate connection to the lighthouse driver
    bool Connect() {
        if (!isInitialized) {
            return false;
        }
        isConnected = true;
        return true;
    }
    
    // Simulate disconnection from the lighthouse driver
    void Disconnect() {
        isConnected = false;
    }
    
    // Check if the lighthouse driver is connected
    bool IsConnected() const {
        return isConnected;
    }
    
    // Get the pose of a tracked device
    vr::TrackedDevicePose_t GetDevicePose(vr::TrackedDeviceIndex_t deviceIndex) {
        if (deviceIndex < devicePoses.size()) {
            return devicePoses[deviceIndex];
        }
        
        vr::TrackedDevicePose_t invalidPose;
        invalidPose.bPoseIsValid = false;
        invalidPose.bDeviceIsConnected = false;
        invalidPose.eTrackingResult = vr::TrackingResult_Uninitialized;
        return invalidPose;
    }
    
    // Set the pose of a tracked device for testing
    void SetDevicePose(vr::TrackedDeviceIndex_t deviceIndex, const vr::TrackedDevicePose_t& pose) {
        if (deviceIndex < devicePoses.size()) {
            devicePoses[deviceIndex] = pose;
        }
    }
    
    // Simulate optical tracking loss
    void SimulateOpticalTrackingLoss() {
        opticalTrackingAvailable = false;
        for (auto& pose : devicePoses) {
            if (pose.bDeviceIsConnected) {
                pose.bPoseIsValid = false;
                pose.eTrackingResult = vr::TrackingResult_Running_OutOfRange;
            }
        }
    }
    
    // Simulate optical tracking recovery
    void SimulateOpticalTrackingRecovery() {
        opticalTrackingAvailable = true;
        for (auto& pose : devicePoses) {
            if (pose.bDeviceIsConnected) {
                pose.bPoseIsValid = true;
                pose.eTrackingResult = vr::TrackingResult_Running_OK;
            }
        }
    }
    
    // Check if optical tracking is available
    bool IsOpticalTrackingAvailable() const {
        return opticalTrackingAvailable;
    }
};

// Mock implementation of the lighthouse driver wrapper for testing
class MockLighthouseDriverWrapper {
private:
    std::shared_ptr<MockLighthouseDriver> mockDriver;
    
public:
    MockLighthouseDriverWrapper() 
        : mockDriver(std::make_shared<MockLighthouseDriver>()) {
    }
    
    // Methods to use the mock driver
    bool Initialize(vr::IVRDriverContext* pDriverContext) {
        return mockDriver->Initialize();
    }
    
    bool Connect() {
        return mockDriver->Connect();
    }
    
    void Disconnect() {
        mockDriver->Disconnect();
    }
    
    bool IsConnected() const {
        return mockDriver->IsConnected();
    }
    
    vr::TrackedDevicePose_t GetDevicePose(vr::TrackedDeviceIndex_t deviceIndex) const {
        return mockDriver->GetDevicePose(deviceIndex);
    }
    
    bool IsOpticalTrackingAvailable() const {
        return mockDriver->IsOpticalTrackingAvailable();
    }
    
    // Mock-specific methods for test control
    std::shared_ptr<MockLighthouseDriver> GetMockDriver() {
        return mockDriver;
    }
    
    void SimulateOpticalTrackingLoss() {
        mockDriver->SimulateOpticalTrackingLoss();
    }
    
    void SimulateOpticalTrackingRecovery() {
        mockDriver->SimulateOpticalTrackingRecovery();
    }
    
    void SetDevicePose(vr::TrackedDeviceIndex_t deviceIndex, const vr::TrackedDevicePose_t& pose) {
        mockDriver->SetDevicePose(deviceIndex, pose);
    }
};

} // namespace sauna