/**
 * @file State.h
 * @brief Defines the abstract base class for all device states.
 * @author Emmanuel Hernandez Cruz
 * @date 2025-09-04
 *
 * This file contains the definition of the abstract State class, which is a base
 * to implement the State Pattern. Concrete states (Standby, Running, Random, Fail, etc.)
 * will inherit from this class.
 */
#ifndef State_h
#define State_h
#include <string>
#include <Arduino.h>
#include <map>
#include "Strategies/Strategy_PID.h"
#include "Categories/ModbusFloatDecorator.h"
#include "Categories/ModbusPoint.h"

// Forward Declarations
template<typename T>class Equipment;
class Strategy_Behavior;

/**
 * @class State
 * @brief Abstract base class for a state in the State design pattern.
 *
 * This class defines the interface for all concrete states. It manages a
 * collection of "strategies" that define how Modbus points behave while the
 * equipment is in this state.
 */
template<typename T>
class State{
public:
    /**
     * @brief Virtual destructor.
     * Cleans up all associated Strategy_Behavior objects.
     */
    virtual ~State();

    /**
     * @brief Executes the state's logic for one update cycle.
     * This method applies the state's strategies and checks for transitions.
     * @param equipment Pointer to the Equipment instance.
     * @return A pointer to a new State if a transition should occur, otherwise nullptr.
     */
    virtual State* update(Equipment<T>* equipment) = 0;
    /**
     * @brief Logic to execute once when entering this state.
     * @param equipment Pointer to the Equipment instance.
     */
    virtual void enterState(Equipment<T>* equipment) {}
    /**
     * @brief Logic to execute once when exiting this state.
     * @param equipment Pointer to the Equipment instance.
     */
    virtual void exitState(Equipment<T>* equipment) {}
    /**
     * @brief Logic to apply all strategies created.
     * @param equipment Pointer to the Equipment instance.
     */
    virtual void _applyStrategies(Equipment<T>* equipment);
    

protected:
    /**
     * @brief Adds a behavior strategy for a specific Modbus point.
     * @param pointDescription The description of the Modbus point to apply the strategy to.
     * @param strategy A pointer to the Strategy_Behavior object. The State will take ownership.
     */
    float getPointValue(Equipment<T>* equipment, const std::string& pointName);
    void setPointValue(Equipment<T>* equipment, const std::string& pointName, float value);
    void addStrategy(const std::string& pointDescription, Strategy_Behavior* strategy);
    std::map<std::string, Strategy_Behavior*> _strategies;
};

template<typename T>
State<T>::~State(){
    for (auto const& pair : this->_strategies) {
        delete pair.second; // 'second' is the pointer to Strategy_Behavior
    }
}

/**
 * @brief Adds a new strategy to the state's behavior map.
 *
 * The State object takes ownership of the strategy pointer and will be
 * responsible for its deletion.
 *
 * @param pointDescription The description of the Modbus point this strategy applies to.
 * @param strategy A pointer to a Strategy_Behavior object.
 */
template<typename T>
void State<T>::addStrategy(const std::string& pointDescription, Strategy_Behavior* strategy){
    this->_strategies[pointDescription] = strategy;
}

template<typename T>
float State<T>::getPointValue(Equipment<T>* equipment, const std::string& pointName) {
    ModbusPoint<T>* point = equipment->getModbusPoint(pointName);
    if (!point) return 0.0f;

    if (point->getType() == PointType::FLOAT) {
        // If it's a float, cast and get the full float value
        return static_cast<ModbusFloatDecorator<T>*>(point)->getFloatValue();
    } else {
        // Otherwise, get the standard integer value
        return static_cast<float>(point->getValue());
    }
}

template<typename T>
void State<T>::setPointValue(Equipment<T>* equipment, const std::string& pointName, float value) {
    ModbusPoint<T>* point = equipment->getModbusPoint(pointName);
    if (!point) return;

    if (point->getType() == PointType::FLOAT) {
        static_cast<ModbusFloatDecorator<T>*>(point)->setFloatValue(value);
    } else {
        point->setValue(round(value));
    }
}

/**
 * @brief Applies all registered strategies for the current state.
 *
 * This helper method iterates through all strategies associated with this state.
 * For each strategy that is ready to run (based on its internal timer), it
 * retrieves the corresponding Modbus point and applies the new value.
 * It handles both integer and float point types.
 *
 * @param equipment A pointer to the main Equipment object.
 */
template<typename T>
void State<T>::_applyStrategies(Equipment<T>* equipment) {
    unsigned long currentTime = millis();

    // Use the C++11 compatible for-loop for std::map
    for (auto const& pair : this->_strategies) {
        const std::string& description = pair.first;
        Strategy_Behavior* strategy = pair.second;

        if (strategy->isReady(currentTime)) {
            ModbusPoint<T>* outputPoint = equipment->getModbusPoint(description);
            if (!outputPoint) continue;

            float inputValue; 

            if (strategy->isPID()) {
                PIDStrategy* pid = static_cast<PIDStrategy*>(strategy);
                inputValue = getPointValue(equipment, pid->getInputSensorName());
                
                ModbusPoint<T>* PIDsetpoint = equipment->getModbusPoint(pid->getSetpointName());
                if (PIDsetpoint) {
                    pid->setSetpoint(PIDsetpoint->getValue());
                }
            } else {
                inputValue = getPointValue(equipment, description);
            }
            
            float newValue = strategy->execute(inputValue);
            setPointValue(equipment, description, newValue);
        }
    }
}

#endif