//
// Created by StanislausCichocki on 10.03.2025.
//

#include "Surplus.h"
#include "../model/Building.h"
#include <algorithm>
#include <vector>
#include <spdlog/spdlog.h>


void Surplus::CalculateSurplus() {
    auto iterateFunc = Community::iterateBuildings(communities);
    auto modifyCommunity = [](Community &c) {
        spdlog::info("Calculating Surplus for Community: {}", c.name());
    };
    auto modifyBuilding = [this](Building::Base &building) {
        spdlog::info("Calculating Surplus for Community: {}", building.metadata()->name());
        CalculateBuildingSurplus(building);
    };
    iterateFunc(modifyCommunity)(modifyBuilding);

    //TODO Calculate Relative Values
}

void Surplus::CalculateBuildingSurplus(Building::Base &building) {
    std::vector<std::unique_ptr<float> > ownCoverage;
    std::vector<std::unique_ptr<float> > neededConsumption;
    std::vector<std::unique_ptr<float> > neededGeneration;
    std::vector<std::unique_ptr<float> > ownUsage;

    const auto &consumption = building.metadata()->consumption_profile();
    const auto &generation = building.metadata()->generation_profile();

    ownCoverage.reserve(consumption.size());
    neededConsumption.reserve(consumption.size());
    neededGeneration.reserve(consumption.size());
    ownUsage.reserve(consumption.size());

    std::transform(consumption.begin(), consumption.end(),
                   generation.begin(), std::back_inserter(ownCoverage),
                   [&](const std::unique_ptr<float> &c, const std::unique_ptr<float> &g) {
                       auto own_cov = std::make_unique<float>((c ? *c : 0.0f) - (g ? *g : 0.0f));
                       ownCoverage.push_back(std::make_unique<float>(*own_cov));

                       neededConsumption.push_back(std::make_unique<float>(c && *c > 0.0f ? *c : 0.0f));
                       neededGeneration.push_back(std::make_unique<float>(g && *g < 0.0f ? -*g : 0.0f));
                       ownUsage.push_back(std::make_unique<float>((c ? *c : 0.0f) - *neededConsumption.back()));

                       return std::move(own_cov);
                   });
    building.values()->set_community_coverage(std::move(ownCoverage));
    building.values()->set_needed_con(std::move(neededGeneration));
    building.values()->set_needed_gen(std::move(neededGeneration));
    building.values()->set_own_usage(std::move(ownUsage));


    std::transform(generationAvailable.begin(), generationAvailable.end(), consumptionAvailable.begin(),
                   isGenBigger.begin(), [&](const float a, const float b) { return a > b; });
}