#include "PressureCalculator.h"
#include "../itc_pressure_optimizer.h"
#include "Average.h"
#include "DemandHandler.h"
#include "InputHandler.h"
#include <algorithm>
#include <string>

void PressureCalculator::update() {
    float averagePower = average.getAverage();
    float c2contrib = averagePower * cachedConstant2;
    float c1contrib =
        cachedConstant1 * (cachedTemperature - cachedSP - c2contrib);
    float uncappedPressure = cachedMinimalPressure + c1contrib;

    float cappedPressure = uncappedPressure;

    if (c2contrib != 0) {
        c2contrib = -c2contrib * cachedConstant1;
    } else {
        c2contrib = 0.0f;
    }

    cappedPressure = std::clamp(uncappedPressure, cachedMinimalPressure,
                                cachedMaximalPressure);

    Event event = {};

    event.c1contrib = c1contrib;
    event.c2contrib = c2contrib;
    event.uncappedPressure = uncappedPressure;
    event.cappedPressure = cappedPressure;
    event.averagePower = averagePower;

    eventBus.publish(event);
}

PressureCalculator::PressureCalculator(EventBus &eventBusReference)
    : average(30), eventBus(eventBusReference) {
    eventBus.subscribe<DemandHandler::Event>(
        [this](const DemandHandler::Event &e) {
            switch (e.type) {
            case DemandHandler::EventType::MINIMAL_PRESSURE:
                updateMinimalPressure(std::get<float>(e.value));
                break;
            case DemandHandler::EventType::MAXIMAL_PRESSURE:
                updateMaximalPressure(std::get<float>(e.value));
                break;
            case DemandHandler::EventType::CONSTANT_1:
                updateConstant1(std::get<float>(e.value));
                break;
            case DemandHandler::EventType::CONSTANT_2:
                updateConstant2(std::get<float>(e.value));
                break;
            default:
                break;
            }
        });

    eventBus.subscribe<InputHandler::Event>(
        [this](const InputHandler::Event &e) {
            switch (e.type) {
            case InputHandler::EventType::SP_VALUE:
                updateSP(e.value);
                break;
            case InputHandler::EventType::TEMPERATURE_VALUE:
                updateTemperature(e.value);
                break;
            case InputHandler::EventType::POWER_VALUE:
                updatePower(e.value);
                break;
            default:
                break;
            }
        });

    eventBus.subscribe<itcPressureOptimizer::EquipmentPollEvent>(
        [this](const itcPressureOptimizer::EquipmentPollEvent &e) {
            update();
        });
}

void PressureCalculator::updateSP(float value) {
    cachedSP = value;
    update();
}

void PressureCalculator::updateTemperature(float value) {
    cachedTemperature = value;
    update();
}

void PressureCalculator::updatePower(float value) {
    cachedPower = value;
    average.addValue(static_cast<double>(value));
    update();
}

void PressureCalculator::updateMinimalPressure(float value) {
    cachedMinimalPressure = value;
    update();
}

void PressureCalculator::updateMaximalPressure(float value) {
    cachedMaximalPressure = value;
    update();
}

void PressureCalculator::updateConstant1(float value) {
    cachedConstant1 = value;
    update();
}

void PressureCalculator::updateConstant2(float value) {
    cachedConstant2 = value;
    update();
}