#include "TaskManager.h"
#include <Arduino.h>
#include <TaskScheduler.h>

// Define static members
std::map<std::string, std::function<void()>> TaskManager::callbackRegistry;

TaskManager::TaskManager(NodeContext& ctx) : ctx(ctx) {}

TaskManager::~TaskManager() {
    // Clean up tasks
    for (auto task : tasks) {
        delete task;
    }
    tasks.clear();
}

void TaskManager::registerTask(const std::string& name, unsigned long interval, TaskFunction callback, bool enabled, bool autoStart) {
    TaskDefinition taskDef(name, interval, callback, enabled, autoStart);
    registerTask(taskDef);
}

void TaskManager::registerTask(const TaskDefinition& taskDef) {
    taskDefinitions.push_back(taskDef);
}

void TaskManager::initialize() {
    // Initialize the scheduler
    ctx.scheduler->init();
    
    // Create all registered tasks
    for (const auto& taskDef : taskDefinitions) {
        createTask(taskDef);
    }
    
    // Enable tasks that should auto-start
    for (const auto& taskDef : taskDefinitions) {
        if (taskDef.autoStart && taskDef.enabled) {
            enableTask(taskDef.name);
        }
    }
}

void TaskManager::createTask(const TaskDefinition& taskDef) {
    // Store the callback in the static registry
    callbackRegistry[taskDef.name] = taskDef.callback;
    
    // Create a dummy task - we'll handle execution ourselves
    Task* task = new Task(0, TASK_FOREVER, []() { /* Dummy callback */ });
    task->setInterval(taskDef.interval);
    
    // Add to scheduler
    ctx.scheduler->addTask(*task);
    
    // Store task pointer
    tasks.push_back(task);
    
    Serial.printf("[TaskManager] Created task: %s (interval: %lu ms)\n", 
                  taskDef.name.c_str(), taskDef.interval);
}

void TaskManager::enableTask(const std::string& name) {
    Task* task = findTask(name);
    if (task) {
        task->enable();
        Serial.printf("[TaskManager] Enabled task: %s\n", name.c_str());
    } else {
        Serial.printf("[TaskManager] Warning: Task not found: %s\n", name.c_str());
    }
}

void TaskManager::disableTask(const std::string& name) {
    Task* task = findTask(name);
    if (task) {
        task->disable();
        Serial.printf("[TaskManager] Disabled task: %s\n", name.c_str());
    } else {
        Serial.printf("[TaskManager] Warning: Task not found: %s\n", name.c_str());
    }
}

void TaskManager::setTaskInterval(const std::string& name, unsigned long interval) {
    Task* task = findTask(name);
    if (task) {
        task->setInterval(interval);
        Serial.printf("[TaskManager] Set interval for task %s: %lu ms\n", name.c_str(), interval);
    } else {
        Serial.printf("[TaskManager] Warning: Task not found: %s\n", name.c_str());
    }
}

void TaskManager::startTask(const std::string& name) {
    Task* task = findTask(name);
    if (task) {
        task->enable();
        Serial.printf("[TaskManager] Started task: %s\n", name.c_str());
    } else {
        Serial.printf("[TaskManager] Warning: Task not found: %s\n", name.c_str());
    }
}

void TaskManager::stopTask(const std::string& name) {
    Task* task = findTask(name);
    if (task) {
        task->disable();
        Serial.printf("[TaskManager] Stopped task: %s\n", name.c_str());
    } else {
        Serial.printf("[TaskManager] Warning: Task not found: %s\n", name.c_str());
    }
}

bool TaskManager::isTaskEnabled(const std::string& name) const {
    Task* task = findTask(name);
    return task ? task->isEnabled() : false;
}

bool TaskManager::isTaskRunning(const std::string& name) const {
    Task* task = findTask(name);
    return task ? task->isEnabled() : false;
}

unsigned long TaskManager::getTaskInterval(const std::string& name) const {
    Task* task = findTask(name);
    return task ? task->getInterval() : 0;
}

void TaskManager::enableAllTasks() {
    for (auto task : tasks) {
        task->enable();
    }
    Serial.println("[TaskManager] Enabled all tasks");
}

void TaskManager::disableAllTasks() {
    for (auto task : tasks) {
        task->disable();
    }
    Serial.println("[TaskManager] Disabled all tasks");
}

void TaskManager::printTaskStatus() const {
    Serial.println("\n[TaskManager] Task Status:");
    Serial.println("==========================");
    
    for (size_t i = 0; i < tasks.size() && i < taskDefinitions.size(); ++i) {
        const auto& taskDef = taskDefinitions[i];
        const auto& task = tasks[i];
        
        Serial.printf("  %s: %s (interval: %lu ms)\n", 
                      taskDef.name.c_str(),
                      task->isEnabled() ? "ENABLED" : "DISABLED",
                      task->getInterval());
    }
    Serial.println("==========================\n");
}

void TaskManager::execute() {
    // Execute all enabled tasks by calling their stored callbacks
    static unsigned long lastExecutionTimes[100] = {0}; // Simple array for timing
    static int taskCount = 0;
    
    if (taskCount == 0) {
        taskCount = tasks.size();
    }
    
    unsigned long currentTime = millis();
    
    for (size_t i = 0; i < tasks.size() && i < taskDefinitions.size(); ++i) {
        Task* task = tasks[i];
        const std::string& taskName = taskDefinitions[i].name;
        
        if (task->isEnabled()) {
            // Check if it's time to run this task
            if (currentTime - lastExecutionTimes[i] >= task->getInterval()) {
                // Execute the stored callback
                if (callbackRegistry.find(taskName) != callbackRegistry.end()) {
                    callbackRegistry[taskName]();
                }
                
                // Update the last execution time
                lastExecutionTimes[i] = currentTime;
            }
        }
    }
}

Task* TaskManager::findTask(const std::string& name) const {
    for (size_t i = 0; i < tasks.size() && i < taskDefinitions.size(); ++i) {
        if (taskDefinitions[i].name == name) {
            return tasks[i];
        }
    }
    return nullptr;
}

std::vector<std::pair<std::string, JsonObject>> TaskManager::getAllTaskStatuses(JsonDocument& doc) const {
    std::vector<std::pair<std::string, JsonObject>> taskStatuses;
    
    for (size_t i = 0; i < tasks.size() && i < taskDefinitions.size(); ++i) {
        const auto& taskDef = taskDefinitions[i];
        const auto& task = tasks[i];
        
        JsonObject taskStatus = doc.add<JsonObject>();
        taskStatus["name"] = taskDef.name;
        taskStatus["interval"] = task->getInterval();
        taskStatus["enabled"] = task->isEnabled();
        taskStatus["running"] = task->isEnabled(); // For now, enabled = running
        taskStatus["autoStart"] = taskDef.autoStart;
        
        taskStatuses.push_back(std::make_pair(taskDef.name, taskStatus));
    }
    
    return taskStatuses;
}