event_detect.h

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

#ifndef EVENT_DETECT_H
#define EVENT_DETECT_H

#include <atomic>
#include <condition_variable>
#include <mutex>
#include <thread>
#include <filesystem>

#include <util.h>

namespace EventDetect {

class Monitor
{
public:
    std::thread m_monitor_thread;

    std::condition_variable cv_monitor_thread;

    std::atomic<bool> m_interrupt_monitor;

    Monitor();

    std::vector<fs::path> GetEventDevices() const;

    void UpdateEventDevices();

    void EventActivityMonitorThread();

    bool IsInitialized() const;

    int64_t GetLastActiveTime() const;

private:
    static std::vector<fs::path> EnumerateEventDevices();

    void WriteLastActiveTimeToFile(const fs::path& filepath);

    mutable std::mutex mtx_event_monitor;

    mutable std::mutex mtx_event_monitor_thread;

    std::vector<fs::path> m_event_device_paths;

    std::atomic<int64_t> m_last_active_time;

    std::atomic<bool> m_initialized;
};

class InputEventRecorders
{
public:
    std::condition_variable cv_recorder_threads;

    std::atomic<bool> m_interrupt_recorders;

    InputEventRecorders();

    class EventRecorder
    {
    public:
        std::thread m_event_recorder_thread;

        explicit EventRecorder(fs::path event_device_path);

        fs::path GetEventDevicePath() const;

        int64_t GetEventCount() const;

        void EventActivityRecorderThread();

    private:
        mutable std::mutex mtx_event_recorder;

        fs::path m_event_device_path;

        std::atomic<int64_t> m_event_count;
    };

    int64_t GetTotalEventCount() const;

    std::vector<std::shared_ptr<EventRecorder>>& GetEventRecorders();

    void ResetEventRecorders();

private:
    mutable std::mutex mtx_event_recorders;

    mutable std::mutex mtx_event_recorder_threads;

    std::vector<std::shared_ptr<EventRecorder>> m_event_recorder_ptrs;
};

class TtyMonitor
{
public:
    std::thread m_tty_monitor_thread;

    std::condition_variable cv_tty_monitor_thread;

    std::atomic<bool> m_interrupt_tty_monitor;

    TtyMonitor();

    std::vector<fs::path> GetTtyDevices() const;

    void UpdateTtyDevices();

    void TtyMonitorThread();

    bool IsInitialized() const;

    int64_t GetLastTtyActiveTime() const;

    class Tty
    {
    public:
        explicit Tty(const fs::path& tty_device_path);

        fs::path m_tty_device_path;

        int64_t m_tty_last_active_time;
    };

private:
    static std::vector<fs::path> EnumerateTtyDevices();

    mutable std::mutex mtx_tty_monitor;

    mutable std::mutex mtx_tty_monitor_thread;

    std::vector<fs::path> m_tty_device_paths;

    std::vector<Tty> m_ttys;

    std::atomic<int64_t> m_last_ttys_active_time;

    std::atomic<bool> m_initialized;
};

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

    std::thread m_idle_detect_monitor_thread;

    std::condition_variable cv_idle_detect_monitor_thread;

    std::atomic<bool> m_interrupt_idle_detect_monitor;

    IdleDetectMonitor();

    void IdleDetectMonitorThread();

    bool IsInitialized() const;

    int64_t GetLastIdleDetectActiveTime() const;

    State GetState() const;

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

    std::string StateToString() const;

private:
    mutable std::mutex mtx_idle_detect_monitor;

    mutable std::mutex mtx_idle_detect_monitor_thread;

    std::atomic<int64_t> m_last_idle_detect_active_time;

    std::atomic<State> m_state;

    std::atomic<bool> m_initialized;
};

class SharedMemoryTimestampExporter {
public:
    explicit SharedMemoryTimestampExporter(const std::string& name);

    ~SharedMemoryTimestampExporter();

    // Prevent copying/moving
    SharedMemoryTimestampExporter(const SharedMemoryTimestampExporter&) = delete;
    SharedMemoryTimestampExporter& operator=(const SharedMemoryTimestampExporter&) = delete;
    SharedMemoryTimestampExporter(SharedMemoryTimestampExporter&&) = delete;
    SharedMemoryTimestampExporter& operator=(SharedMemoryTimestampExporter&&) = delete;

    bool CreateOrOpen(mode_t mode = 0666);

    // *** SIGNATURE CHANGED ***
    bool UpdateTimestamps(int64_t update_time, int64_t last_active_time);

    bool IsInitialized() const;

    bool UnlinkSegment();

private:
    void Cleanup();

    std::mutex mtx_shmem;

    std::string m_shm_name;
    int m_shm_fd;
    int64_t* m_mapped_ptr;             // Pointer to the start of the int64_t[2] array
    const size_t m_size;               // Size of the int64_t[2] array
    bool m_is_creator;                 // Did this instance create/resize the segment?
    std::atomic<bool> m_is_initialized;
};

void Shutdown(const int &exit_code = 0);

} // namespace event_detect

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

#endif // EVENT_DETECT_H