// StardustBridge.cpp
#include "StardustBridge.hpp"

#include <chrono>
#include <cmath>
#include <cstdlib>
#include <filesystem>
#include <iostream>
#include <thread>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <vector>
#include <algorithm>
#include <cstring>
#include <dlfcn.h>

using namespace std::chrono_literals;

static std::vector<std::string> candidateSocketPaths() {
    std::vector<std::string> out;

    if (const char* envSock = std::getenv("STARDUSTXR_SOCKET")) out.emplace_back(envSock);
    if (const char* envSock2 = std::getenv("STARDUST_SOCKET")) out.emplace_back(envSock2);
    if (const char* envAbs = std::getenv("STARDUSTXR_ABSTRACT")) {
        // If provided without @, add @ prefix for abstract namespace
        std::string v = envAbs;
        if (v.empty() || v[0] != '@') v = '@' + v;
        out.emplace_back(v);
    }

    std::string xdg;
    if (const char* env = std::getenv("XDG_RUNTIME_DIR")) xdg = env;
    if (!xdg.empty()) {
        out.emplace_back(xdg + "/stardust.sock");
        out.emplace_back(xdg + "/stardustxr.sock");
        out.emplace_back(xdg + "/stardust/stardust.sock");
        out.emplace_back(xdg + "/stardustxr/stardust.sock");
    }

    // /run/user/<uid>/...
    char uidPath[128];
    std::snprintf(uidPath, sizeof(uidPath), "/run/user/%d", (int)getuid());
    std::string runUser(uidPath);
    out.emplace_back(runUser + "/stardust.sock");
    out.emplace_back(runUser + "/stardustxr.sock");
    out.emplace_back(runUser + "/stardust/stardust.sock");
    out.emplace_back(runUser + "/stardustxr/stardust.sock");

    out.emplace_back("/tmp/stardustxr.sock");

    // Common abstract names to try as a fallback
    out.emplace_back("@stardust");
    out.emplace_back("@stardustxr");
    out.emplace_back("@stardust/stardust");
    out.emplace_back("@stardustxr/stardust");
    return out;
}

std::string StardustBridge::defaultSocketPath() {
    auto c = candidateSocketPaths();
    return c.empty() ? std::string{} : c.front();
}

bool StardustBridge::connect(const std::string& socketPath) {
    // Prefer Rust bridge if available.
    if (loadBridge()) {
        const char* appId = "org.stardustxr.starworld";
        int rc = m_fnStart ? m_fnStart(appId) : -1;
        if (rc == 0) {
            m_connected = true;
            std::cout << "[StardustBridge] Connected via Rust bridge (C-ABI)." << std::endl;
            m_overteRoot = createNode("OverteWorld");
            return true;
        } else {
            std::cerr << "[StardustBridge] Rust bridge present but start() failed (rc=" << rc << ")" << std::endl;
        }
    }

    std::vector<std::string> paths;
    if (!socketPath.empty()) paths.push_back(socketPath);
    auto candidates = candidateSocketPaths();
    paths.insert(paths.end(), candidates.begin(), candidates.end());

    // Deduplicate while preserving order
    std::vector<std::string> unique;
    for (auto& p : paths) {
        if (!p.empty() && std::find(unique.begin(), unique.end(), p) == unique.end()) unique.push_back(p);
    }

    for (const auto& p : unique) {
        // Try to connect regardless of fs existence—server may create on first accept.
        bool isAbstract = !p.empty() && p[0] == '@';
        int fd = ::socket(AF_UNIX, SOCK_STREAM, 0);
        if (fd == -1) {
            continue;
        }

        sockaddr_un addr{};
        addr.sun_family = AF_UNIX;
        if (isAbstract) {
            // Linux abstract namespace: first byte of sun_path is NUL, name in the rest.
            // p begins with '@' per our convention; skip it when copying.
            std::memset(addr.sun_path, 0, sizeof(addr.sun_path));
            std::snprintf(addr.sun_path + 1, sizeof(addr.sun_path) - 1, "%s", p.c_str() + 1);
        } else {
            std::snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", p.c_str());
        }

        if (::connect(fd, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) == -1) {
            ::close(fd);
            continue;
        }

        // Make non-blocking after successful connect
        int flags = ::fcntl(fd, F_GETFL, 0);
        if (flags != -1) ::fcntl(fd, F_SETFL, flags | O_NONBLOCK);

        m_socketFd = fd;
        m_socketPath = p;
        m_connected = true;
    std::cout << "[StardustBridge] Connected to compositor at " << (isAbstract ? ("abstract:" + p.substr(1)) : p) << std::endl;

        m_overteRoot = createNode("OverteWorld");
        return true;
    }

    std::cerr << "[StardustBridge] Could not connect to StardustXR. Tried:" << std::endl;
    for (auto& p : unique) std::cerr << "  - " << p << std::endl;
    std::cerr << "Hint: set STARDUSTXR_SOCKET to a filesystem path, or STARDUSTXR_ABSTRACT to an abstract name (e.g. export STARDUSTXR_ABSTRACT=stardustxr). Leading '@' denotes abstract." << std::endl;
    return false;
}

StardustBridge::NodeId StardustBridge::createNode(const std::string& name,
                                                  const glm::mat4& transform,
                                                  std::optional<NodeId> parent) {
    NodeId id = m_nextId++;
    m_nodes.emplace(id, Node{ name, parent, transform });
    // Forward to Rust bridge if available.
    if (m_fnCreateNode) {
        float m[16];
        // GLM mat4 is column-major; pass as 16 floats as-is
        std::memcpy(m, &transform[0][0], sizeof(m));
        std::uint64_t rid = m_fnCreateNode(name.c_str(), m);
        (void)rid; // Could map to NodeId if Rust returns its own id
    }
    return id;
}

bool StardustBridge::updateNodeTransform(NodeId id, const glm::mat4& transform) {
    auto it = m_nodes.find(id);
    if (it == m_nodes.end()) return false;
    it->second.transform = transform;
    if (m_fnUpdateNode) {
        float m[16];
        std::memcpy(m, &transform[0][0], sizeof(m));
        (void)m_fnUpdateNode(id, m);
    }
    return true;
}

bool StardustBridge::removeNode(NodeId id) {
    auto it = m_nodes.find(id);
    if (it == m_nodes.end()) return false;
    m_nodes.erase(it);
    if (m_fnRemoveNode) {
        (void)m_fnRemoveNode(id);
    }
    return true;
}

void StardustBridge::poll() {
    if (!m_connected) return;

    if (m_fnPoll) {
        int rc = m_fnPoll();
        if (rc < 0) {
            std::cerr << "[StardustBridge] Bridge reported disconnected; shutting down." << std::endl;
            m_running = false;
            m_connected = false;
            return;
        }
    }

    // Detect disconnect: a non-blocking read of 0 or error indicating closed.
    if (m_socketFd < 0) return;
    char buf;
    ssize_t n = ::recv(m_socketFd, &buf, 1, MSG_PEEK);
    if (n == 0) {
        std::cerr << "[StardustBridge] Compositor socket closed" << std::endl;
        m_connected = false;
        m_running = false; // Request shutdown
        return;
    } else if (n == -1 && (errno == ECONNRESET || errno == ENOTCONN)) {
        std::cerr << "[StardustBridge] Compositor connection reset" << std::endl;
        m_connected = false;
        m_running = false;
        return;
    } else if (n == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
        // No data pending; connection still alive.
    }

    // TODO: poll actual StardustXR event queue & input devices.
    // Simulate input for now: small circular joystick motion over time.
    static auto start = std::chrono::steady_clock::now();
    auto now = std::chrono::steady_clock::now();
    float t = std::chrono::duration<float>(now - start).count();
    m_joystick = { std::sin(t * 0.5f), std::cos(t * 0.5f) };

    // Head pose remains identity; in real implementation populate from HMD tracking.
    m_headPose = glm::mat4(1.0f);
}

void StardustBridge::close() {
    if (m_fnShutdown) m_fnShutdown();
    if (m_socketFd >= 0) {
        ::close(m_socketFd);
        m_socketFd = -1;
    }
    m_connected = false;
}

// Ensure socket is closed on destruction
StardustBridge::~StardustBridge() { close(); }

bool StardustBridge::loadBridge() {
    if (m_bridgeHandle) return true;

    const char* overridePath = std::getenv("STARWORLD_BRIDGE_PATH");
    std::vector<std::string> candidates;
    if (overridePath) {
        candidates.emplace_back(std::string(overridePath));
    }
    // Likely local dev output
    candidates.emplace_back("./bridge/target/debug/libstardust_bridge.so");
    candidates.emplace_back("libstardust_bridge.so");

    for (const auto& path : candidates) {
        void* h = ::dlopen(path.c_str(), RTLD_LAZY | RTLD_LOCAL);
        if (!h) continue;
        auto req = [&](const char* sym){ return ::dlsym(h, sym); };
        m_fnStart = reinterpret_cast<fn_start_t>(req("sdxr_start"));
        if (!m_fnStart) m_fnStart = reinterpret_cast<fn_start_t>(req("_sdxr_start"));
        m_fnPoll = reinterpret_cast<fn_poll_t>(req("sdxr_poll"));
        m_fnShutdown = reinterpret_cast<fn_shutdown_t>(req("sdxr_shutdown"));
        m_fnCreateNode = reinterpret_cast<fn_create_node_t>(req("sdxr_create_node"));
        m_fnCreateNode = reinterpret_cast<fn_create_node_t>(req("sdxr_create_node"));
        m_fnUpdateNode = reinterpret_cast<fn_update_node_t>(req("sdxr_update_node"));
        m_fnRemoveNode = reinterpret_cast<fn_remove_node_t>(req("sdxr_remove_node"));
        if (m_fnStart && m_fnPoll && m_fnCreateNode && m_fnUpdateNode) {
            m_bridgeHandle = h;
            std::cout << "[StardustBridge] Loaded Rust bridge: " << path << std::endl;
            return true;
        }
        ::dlclose(h);
    }
    return false;
}

// Legacy snippet removed after implementing new connect signature.