package eu.eudat.logic.managers;

import io.prometheus.client.Gauge;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.transaction.Transactional;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@Component
public class MetricsManager {
    private final static Logger logger = LoggerFactory.getLogger(MetricsManager.class);
    private static Map<String, Gauge> gauges = Stream.of( new Object[][]{
            {"argos_managed_dmps", Gauge.build().name("argos_managed_dmps").help("Number of managed DMPs").labelNames("status").register()},

            {"argos_funders", Gauge.build().name("argos_funders").help("Number of registered Funders").register()},
            {"argos_grants", Gauge.build().name("argos_grants").help("Number of registered Grants").register()},
            {"argos_projects", Gauge.build().name("argos_projects").help("Number of registered Projects").register()},
            {"argos_researchers", Gauge.build().name("argos_researchers").help("Number of Colaborators/Researchers").register()},

            {"argos_managed_dataset_descriptions", Gauge.build().name("argos_managed_dataset_descriptions").help("Number of managed Dataset Descriptions").labelNames("status").register()},

            {"argos_dataset_templates", Gauge.build().name("argos_dataset_templates").help("Number of dataset Templates").labelNames("status").register()},

            {"argos_users", Gauge.build().name("argos_users").help("Number of users").labelNames("type").register()},

            {"argos_languages", Gauge.build().name("argos_languages").help("Number of Languages").register()},

    }).collect(Collectors.toMap(data -> (String)data[0], data -> (Gauge) data[1]));
    
    public static void increaseValue(String name, int amount,  String label) {

        if(label != null) {
            gauges.get(name).labels(label).inc(amount);
        } else {
            gauges.get(name).inc(amount);
        }
    }
    
    public static void decreaseValue(String name, int amount, String label) {
        if(label != null) {
            gauges.get(name).labels(label).dec(amount);
        } else {
            gauges.get(name).dec(amount);
        }
    }

    public static Integer getValue(String name, String label) {
        if(label != null) {
            return Double.valueOf(gauges.get(name).labels(label).get()).intValue();
        } else {
            return Double.valueOf(gauges.get(name).get()).intValue();
        }
    }

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

    private final DatasetManager datasetManager;
    private final DataManagementPlanManager dataManagementPlanManager;
    private final DatasetProfileManager datasetProfileManager;
    private final UserManager userManager;
    private final Environment environment;

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

    @PostConstruct
    @Transactional
    @Scheduled(initialDelay = 1000 * 60 * 60, fixedDelay = 1000 * 60 * 60)
    public void init() throws IOException {
        logger.info("Start calculating Metrics");
        calculateValue("argos_managed_dmps", (int) dataManagementPlanManager.countAllDrafts(), "draft");
        calculateValue("argos_managed_dmps", (int) dataManagementPlanManager.countAllFinalized(), "finalized");
        calculateValue("argos_managed_dmps", (int) dataManagementPlanManager.countAllPublished(), "published");
        calculateValue("argos_managed_dmps", (int) dataManagementPlanManager.countAllDoied(), "doied");

        calculateValue("argos_funders", (int) dataManagementPlanManager.countAllFunders(), null);
        calculateValue("argos_grants", (int) dataManagementPlanManager.countAllGrants(), null);
        calculateValue("argos_projects", (int) dataManagementPlanManager.countAllProjects(), null);
        calculateValue("argos_researchers", (int) dataManagementPlanManager.countAllResearchers(), null);

        calculateValue("argos_managed_dataset_descriptions", (int) datasetManager.countAllDraft(), "draft");
        calculateValue("argos_managed_dataset_descriptions", (int) datasetManager.countAllFinalized(), "finalized");
        calculateValue("argos_managed_dataset_descriptions", (int) datasetManager.countAllPublic(), "published");
        calculateValue("argos_managed_dataset_descriptions", (int) datasetManager.countAllWithDoi(), "doied");

        calculateValue("argos_dataset_templates", (int) datasetProfileManager.countAlldraft(), "total");
        calculateValue("argos_dataset_templates", (int) datasetProfileManager.countAllFinalized(), "active");
        calculateValue("argos_dataset_templates", (int) datasetProfileManager.countAllUsed(), "used");

        calculateValue("argos_users", (int) userManager.countActiveUsers().intValue(), "loggedin");
        calculateValue("argos_users", (int) userManager.countAllUsers().intValue(), "total");

        long files = Files.list(Paths.get(this.environment.getProperty("userguide.path"))).count();
        calculateValue("argos_languages", (int) files, null);

        logger.info("Metrics calculation Completed");
    }

}