main.cpp

#include "vr/system.h"

#include "vr/overlay.h"
#include "vr/overlay_scene.h"
#include "vr/tracked_device.h"
#include "vr/transform.h"

#include "api_client.h"
#include "config.h"
#include "vrwidget.h"

#include <QApplication>
#include <QTimer>

#include <fmt/core.h>
#include <glm/trigonometric.hpp>
#include <openvr.h>

void at_exit() {
    OpenShock::VR::VRSystem::Shutdown();
}

int main(int argc, char** argv) {
    std::atexit(at_exit);
    QCoreApplication::setAttribute(Qt::AA_UseDesktopOpenGL);
    QCoreApplication::setApplicationName("OpenShockVR");
    QCoreApplication::setOrganizationName("OpenShock");
    QApplication app(argc, argv);

    // Load config
    OpenShock::Config::Instance().Load();

    if (!OpenShock::VR::VRSystem::Initialize()) {
        fmt::print("Failed to initialize OpenVR\n");
        return 1;
    }

    auto overlay = new OpenShock::VR::Overlay("openshock.main", "OpenShock", &app);
    if (!overlay->Ok()) {
        fmt::print("Failed to create overlay\n");
        return 1;
    }

    auto* widget = new OpenShock::VRWidget();
    widget->setStyleSheet("QWidget { background-color: #2c3e50; }");

    overlay->Scene()->SetWidget(widget);
    overlay->SetWidth(0.25f);
    overlay->SetVisible(true);

    // Place in front initially, attach to left controller once available
    {
        vr::HmdMatrix34_t transform = {};
        transform.m[0][0] = 1.0f;
        transform.m[1][1] = 1.0f;
        transform.m[2][2] = 1.0f;
        transform.m[0][3] = 0.0f;
        transform.m[1][3] = 1.2f;
        transform.m[2][3] = -1.5f;
        vr::VROverlay()->SetOverlayTransformAbsolute(overlay->Handle(), vr::TrackingUniverseStanding, &transform);
    }

    OpenShock::VR::Transform controllerOffset;
    controllerOffset.SetPosition(glm::vec3(0.0f, 0.05f, 0.1f));
    controllerOffset.SetRotation(glm::radians(glm::vec3(-90.0f, 0.0f, 0.0f)));
    bool attachedToController = false;

    // Switch hand
    QObject::connect(widget, &OpenShock::VRWidget::SwitchHandRequested, [&]() {
        auto& cfg = OpenShock::Config::Instance();
        bool wasLeft = cfg.LeftHanded();
        cfg.SetLeftHanded(!wasLeft);

        auto targetDevice = cfg.LeftHanded()
            ? OpenShock::VR::TrackedDevice::DeviceType::ControllerLeft
            : OpenShock::VR::TrackedDevice::DeviceType::ControllerRight;
        overlay->MirrorToDevice(targetDevice);

        fmt::print("Switched overlay to {} hand\n", cfg.LeftHanded() ? "left" : "right");
        widget->SetStatus(cfg.LeftHanded() ? "Left hand" : "Right hand");
    });

    // API client
    auto* apiClient = new OpenShock::ApiClient(&app);

    QObject::connect(widget, &OpenShock::VRWidget::ShockRequested, [&](int intensity) {
        auto& config = OpenShock::Config::Instance();
        apiClient->SendControl(OpenShock::ControlType::Shock, intensity, config.DefaultDuration());
    });
    QObject::connect(widget, &OpenShock::VRWidget::VibrateRequested, [&](int intensity) {
        auto& config = OpenShock::Config::Instance();
        apiClient->SendControl(OpenShock::ControlType::Vibrate, intensity, config.DefaultDuration());
    });
    QObject::connect(widget, &OpenShock::VRWidget::SoundRequested, [&](int intensity) {
        auto& config = OpenShock::Config::Instance();
        apiClient->SendControl(OpenShock::ControlType::Sound, intensity, config.DefaultDuration());
    });

    QObject::connect(apiClient, &OpenShock::ApiClient::ControlSent, widget, &OpenShock::VRWidget::SetStatus);
    QObject::connect(apiClient, &OpenShock::ApiClient::Error, [widget](const QString& err) {
        widget->SetStatus(err);
        fmt::print("API error: {}\n", err.toStdString());
    });

    // Fetch shockers on startup if configured
    auto& config = OpenShock::Config::Instance();
    if (!config.ApiToken().isEmpty()) {
        apiClient->FetchShockers();

        QObject::connect(apiClient, &OpenShock::ApiClient::ShockersFetched, [](const QList<OpenShock::ShockerInfo>& shockers) {
            for (const auto& s : shockers) {
                fmt::print("  Shocker: {} ({}){}\n", s.name.toStdString(), s.id.toStdString(), s.isPaused ? " [PAUSED]" : "");
            }

            // Auto-select all shockers if none configured
            auto& cfg = OpenShock::Config::Instance();
            if (cfg.ShockerIds().isEmpty()) {
                QStringList ids;
                for (const auto& s : shockers) {
                    ids.append(s.id);
                }
                cfg.SetShockerIds(ids);
                fmt::print("Auto-selected {} shockers\n", ids.size());
            }
        });
    }

    QTimer* vrLoopTimer = new QTimer(&app);
    QObject::connect(vrLoopTimer, &QTimer::timeout, [&]() {
        OpenShock::VR::VRSystem::Update();

        if (!attachedToController) {
            auto& cfg = OpenShock::Config::Instance();
            auto deviceType = cfg.LeftHanded()
                ? OpenShock::VR::TrackedDevice::DeviceType::ControllerLeft
                : OpenShock::VR::TrackedDevice::DeviceType::ControllerRight;
            auto idx = OpenShock::VR::TrackedDevice::GetIndex(deviceType);
            if (idx != vr::k_unTrackedDeviceIndexInvalid) {
                overlay->SetTransformRelative(controllerOffset, deviceType);
                attachedToController = true;
                fmt::print("Overlay attached to {} controller\n", cfg.LeftHanded() ? "left" : "right");
            }
        }
    });
    vrLoopTimer->start(10);

    return app.exec();
}