idle_detect.h

/*
 * Copyright (C) 2025 James C. Owens
 *
 * This code is licensed under the MIT license. See LICENSE.md in the repository.
 */

#ifndef IDLE_DETECT_H
#define IDLE_DETECT_H

#include <condition_variable>
#include <cstdint> // For int64_t
#include <thread>
#include <util.h>

// Forward declare Wayland types
struct wl_display;
struct wl_registry;
struct wl_seat;
struct ext_idle_notifier_v1;
struct ext_idle_notification_v1;

namespace IdleDetect {
// Function to get the user's idle time in seconds
int64_t GetIdleTimeSeconds();

class IdleDetectControlMonitor
{
public:
    enum State {
        UNKNOWN,
        NORMAL,
        FORCED_ACTIVE,
        FORCED_IDLE
    };

    std::thread m_idle_detect_control_monitor_thread;

    std::condition_variable cv_idle_detect_control_monitor_thread;

    std::atomic<bool> m_interrupt_idle_detect_control_monitor;

    IdleDetectControlMonitor();

    void IdleDetectControlMonitorThread();

    bool IsInitialized() const;

    State GetState() const;

    static std::string StateToString(const State& state);

    std::string StateToString() const;

private:
    mutable std::mutex mtx_idle_detect_control_monitor;

    mutable std::mutex mtx_idle_detect_control_monitor_thread;

    std::atomic<State> m_state;

    std::atomic<bool> m_initialized;
};

class WaylandIdleMonitor
{
public:
    WaylandIdleMonitor();

    ~WaylandIdleMonitor();

    WaylandIdleMonitor(const WaylandIdleMonitor&) = delete;
    WaylandIdleMonitor& operator=(const WaylandIdleMonitor&) = delete;
    WaylandIdleMonitor(WaylandIdleMonitor&&) = delete;
    WaylandIdleMonitor& operator=(WaylandIdleMonitor&&) = delete;

    bool Start(int notification_timeout_ms);

    void Stop();

    bool IsAvailable() const;

    int64_t GetIdleSeconds() const;

    bool IsIdle() const;

public: // Accessible to static C callbacks
    wl_seat* m_seat;
    ext_idle_notifier_v1* m_idle_notifier;
    uint32_t m_seat_id;
    uint32_t m_idle_notifier_id;
    std::atomic<bool> m_is_idle;
    std::atomic<int64_t> m_idle_start_time;

private:
    std::thread m_monitor_thread;

    std::atomic<bool> m_interrupt_monitor;

    int m_interrupt_pipe_fd[2];

    std::atomic<bool> m_initialized;

    wl_display* m_display;
    wl_registry* m_registry;

    ext_idle_notification_v1* m_idle_notification;

    int m_notification_timeout_ms;

    bool InitializeWayland();

    void CleanupWayland();

    void CreateIdleNotification();

    void WaylandMonitorThread();

    static void HandleGlobal(void *data, wl_registry *registry, uint32_t name, const char *interface, uint32_t version);

    static void HandleGlobalRemove(void *data, wl_registry *registry, uint32_t name);

    static void HandleIdled(void *data, ext_idle_notification_v1 *notification);

    static void HandleResumed(void *data, ext_idle_notification_v1 *notification);

    static const void* c_registry_listener_ptr;

    static const void* c_idle_notification_listener_ptr;
};

} // namespace IdleDetect

class IdleDetectConfig : public Config
{
    void ProcessArgs() override;
};

#endif // IDLE_DETECT_H