#pragma once

#include <grove/IModule.h>
#include <grove/JsonDataNode.h>

#include <spdlog/spdlog.h>
#include <spdlog/sinks/stdout_color_sinks.h>
#include <memory>
#include <string>
#include <vector>
#include <chrono>
#include <ctime>
#include <iomanip>
#include <sstream>

namespace celuna {

/**
 * @brief Scheduler Module - Gestion du temps et détection d'hyperfocus
 *
 * Fonctionnalités:
 * - Planning de tâches avec durées estimées
 * - Détection d'hyperfocus (session > seuil configurable)
 * - Rappels de pauses automatiques
 * - Tracking du temps par tâche
 *
 * Publie sur:
 * - "scheduler:hyperfocus_alert" : Alerte quand hyperfocus detecte
 * - "scheduler:break_reminder"   : Rappel de pause
 * - "scheduler:task_started"     : Debut de tache
 * - "scheduler:task_completed"   : Fin de tache
 *
 * Souscrit a:
 * - "user:activity"              : Activite utilisateur (reset idle)
 * - "user:task_switch"           : Changement de tache manuel
 * - "monitoring:idle_detected"   : Utilisateur inactif
 * - "monitoring:activity_resumed": Retour activite
 */
class SchedulerModule : public grove::IModule {
public:
    struct Task {
        std::string id;
        std::string name;
        std::string category;
        int estimatedMinutes;
        int actualMinutes;
        bool completed;
    };

    SchedulerModule();
    ~SchedulerModule() override = default;

    // IModule interface
    void process(const grove::IDataNode& input) override;
    void setConfiguration(const grove::IDataNode& configNode, grove::IIO* io,
                         grove::ITaskScheduler* scheduler) override;
    const grove::IDataNode& getConfiguration() override;
    std::unique_ptr<grove::IDataNode> getHealthStatus() override;
    void shutdown() override;
    std::unique_ptr<grove::IDataNode> getState() override;
    void setState(const grove::IDataNode& state) override;
    std::string getType() const override { return "SchedulerModule"; }
    bool isIdle() const override { return true; }
    int getVersion() const override { return 1; }

private:
    // Configuration
    int m_hyperfocusThresholdMinutes = 120;  // 2 heures par défaut
    int m_breakReminderIntervalMinutes = 45; // Rappel toutes les 45 min
    int m_breakDurationMinutes = 10;         // Pause de 10 min suggérée

    // État
    std::vector<Task> m_tasks;
    std::string m_currentTaskId;
    float m_sessionStartTime = 0.0f;         // Temps de début de session (gameTime)
    float m_lastBreakTime = 0.0f;            // Dernier rappel de pause
    float m_lastActivityTime = 0.0f;         // Dernière activité utilisateur
    bool m_hyperfocusAlertSent = false;
    int m_totalFocusMinutesToday = 0;

    // Services
    grove::IIO* m_io = nullptr;
    std::unique_ptr<grove::JsonDataNode> m_config;
    std::shared_ptr<spdlog::logger> m_logger;

    // Helpers
    void processMessages();
    void checkHyperfocus(float currentTime);
    void checkBreakReminder(float currentTime);
    void startTask(const std::string& taskId);
    void completeCurrentTask();
    Task* findTask(const std::string& taskId);

    // Tool handlers
    void handleToolQuery(const grove::IDataNode& request);
    void handleToolCommand(const grove::IDataNode& request);
};

} // namespace celuna

extern "C" {
    grove::IModule* createModule();
    void destroyModule(grove::IModule* module);
}
