package eu.eudat.logic.managers;

import io.prometheus.client.Gauge;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.transaction.Transactional;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@Component
public class MetricsManager {
    private static Map<String, Gauge> gauges = Stream.of( new Object[][]{
            {"usersLoggedIn", Gauge.build("users_logged_in", "Number of current logged in users").register()},
            {"projects", Gauge.build("projects", "Number of registered Projects").register()},
            {"draftDMPs", Gauge.build("draft_dmps", "Number of draft DMPs").register()},
            {"finalizedDMPs", Gauge.build("finalized_dmps", "Number of finalized DMPs").register()},
            {"publishedDMPs", Gauge.build("published_dmps", "Number of published DMPs").register()},
            {"doiedDMPs", Gauge.build("doied_dmps", "Number of DMPs with DOI").register()},
            {"draftDatasets", Gauge.build("draft_datasets", "Number of draft Datasets").register()},
            {"finalizedDatasets", Gauge.build("finalized_datasets", "Number of finalized Datasets").register()},
            {"publishedDatasets", Gauge.build("published_datasets", "Number of published Datasets").register()},
            {"doiedDatasets", Gauge.build("doied_datasets", "Number of Datasets with DOI").register()},
            {"researchers", Gauge.build("researchers", "Number of Colaborators/Researchers").register()},
            {"totalTemplates", Gauge.build("total_templates", "Number of total Templates").register()},
            {"activeTemplates", Gauge.build("active_templates", "Number of active Templates").register()},
            {"usedTemplates", Gauge.build("used_templates", "Number of used Templates").register()},
            {"languages", Gauge.build("languages", "Number of Languages").register()}
    }).collect(Collectors.toMap(data -> (String)data[0], data -> (Gauge) data[1]));
    
    public static void increaseValue(String name, int amount) {
        gauges.get(name).inc(amount);
    }
    
    public static void decreaseValue(String name, int amount) {
        gauges.get(name).dec(amount);
    }

    public static Integer getValue(String name) {
        return Double.valueOf(gauges.get(name).get()).intValue();
    }

    public static void calculateValue(String name, int amount) {
        Integer orig = getValue(name);
        int diff = orig - amount;
        if (diff != 0) {
            if (diff > 0) {
                decreaseValue(name, diff);
            } else {
                increaseValue(name, Math.abs(diff));
            }
        }
    }

    private final DatasetManager datasetManager;
    private final DataManagementPlanManager dataManagementPlanManager;
    private final DatasetProfileManager datasetProfileManager;

    @Autowired
    public MetricsManager(DatasetManager datasetManager, DataManagementPlanManager dataManagementPlanManager, DatasetProfileManager datasetProfileManager) {
        this.datasetManager = datasetManager;
        this.dataManagementPlanManager = dataManagementPlanManager;
        this.datasetProfileManager = datasetProfileManager;
    }

    @PostConstruct
    @Transactional
    public void init() {
        calculateValue("draftDMPs", (int) dataManagementPlanManager.countAllDrafts());
        calculateValue("finalizedDMPs", (int) dataManagementPlanManager.countAllFinalized());
        calculateValue("publishedDMPs", (int) dataManagementPlanManager.countAllFinalized());
        calculateValue("projects", (int) dataManagementPlanManager.countAllProjects());
        calculateValue("researchers", (int) dataManagementPlanManager.countAllResearchers());
        calculateValue("draftDatasets", (int) datasetManager.countAllDraft());
        calculateValue("finalizedDatasets", (int) datasetManager.countAllFinalized());
        calculateValue("publishedDatasets", (int) datasetManager.countAllPublic());
        calculateValue("totalTemplates", (int) datasetProfileManager.countAlldraft());
        calculateValue("activeTemplates", (int) datasetProfileManager.countAllFinalized());
        calculateValue("usedTemplates", (int) datasetProfileManager.countAllUsed());
    }

}