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

void PressureCalculator::update() {

    double c2contrib = average.getAverage() * cachedConstante2;
    double c1contrib =
        cachedConstante1 * (cachedTemperature - cachedSP - c2contrib);
    double uncapedPressure = cachedMinimalPressure + c1contrib;

    double cappedPressure = uncapedPressure;

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

    if (cappedPressure < cachedMinimalPressure)
        cappedPressure = cachedMinimalPressure;

    if (cappedPressure > cachedMaximalPressure)
        cappedPressure = cachedMaximalPressure;

    Event event = {};

    if (c2contrib != 0) {
        event.c1contrib = c1contrib;
        event.c2contrib = c2contrib;
        event.uncapedPressure = uncapedPressure;
        event.cappedPressure = cappedPressure;
    }

    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::CONSTANTE_1:
                updateConstante1(std::get<float>(e.value));
                break;
            case DemandHandler::EventType::CONSTANTE_2:
                updateConstante2(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::updateConstante1(float value) {
    cachedConstante1 = value;
    update();
}

void PressureCalculator::updateConstante2(float value) {
    cachedConstante2 = value;
    update();
}