package eu.dnetlib.repo.manager.service.controllers;

import eu.dnetlib.api.functionality.ValidatorServiceException;
import eu.dnetlib.domain.functionality.validator.StoredJob;
import eu.dnetlib.repo.manager.service.utils.OaiTools;
import eu.dnetlib.repo.manager.shared.InterfaceInformation;
import eu.dnetlib.repo.manager.shared.ValidationServiceException;
import gr.uoa.di.driver.util.ServiceLocator;
import eu.dnetlib.domain.functionality.validator.JobForValidation;
import eu.dnetlib.domain.functionality.validator.RuleSet;
import eu.dnetlib.repo.manager.shared.Constants;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import eu.dnetlib.api.functionality.ValidatorService;
import org.apache.log4j.Logger;
import org.json.JSONException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.PathVariable;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;


@Component
public class ValidatorApiImpl implements ValidatorApi{

    @Autowired
    private MonitorApiImpl monitorApi;

    @Resource(name = "validatorServiceLocator")
    private ServiceLocator<ValidatorService> validatorServiceLocator;

    private ValidatorService getValidationService() {
        return this.validatorServiceLocator.getService();
    }

    public ServiceLocator<ValidatorService> getValidatorServiceLocator() {
        return validatorServiceLocator;
    }

    public void setValidatorServiceLocator(ServiceLocator<ValidatorService> validatorServiceLocator) {
        this.validatorServiceLocator = validatorServiceLocator;
    }

    private Map<String, List<RuleSet>> rulesetMap = new ConcurrentHashMap<String, List<RuleSet>>();

    private static final Logger LOGGER = Logger
            .getLogger(ValidatorApiImpl.class);

    @PostConstruct
    private void loadRules(){
        LOGGER.debug("PostConstruct method! Load rules!");
        try {
            for (RuleSet ruleSet : getValidationService().getRuleSets()) {
                if (ruleSet.getVisibility() != null && ruleSet.getVisibility().contains("development")) {
                    String key = "";
                    if (ruleSet.getGuidelinesAcronym().matches("^openaire[1-9].0_data$"))
                        key = Constants.VALIDATION_MODE_DATA;
                    else if (ruleSet.getGuidelinesAcronym().matches("^openaire[1-9].0$") || ruleSet.getGuidelinesAcronym().equals("driver"))
                        key = Constants.VALIDATION_MODE_LITERATURE;
                    else if (ruleSet.getGuidelinesAcronym().matches("^openaire[1-9].0_cris$"))
                        key = Constants.VALIDATION_MODE_CRIS;

                    if (rulesetMap.containsKey(key))
                        rulesetMap.get(key).add(ruleSet);
                    else {
                        List<RuleSet> ruleSets = new ArrayList<RuleSet>();
                        ruleSets.add(ruleSet);
                        rulesetMap.put(key, ruleSets);
                    }
                }
            }
        } catch (ValidatorServiceException e) {
            e.printStackTrace();
        }

    }

    @Override
    public void submitJobForValidation(JobForValidation jobForValidation) {
        LOGGER.debug("Submit job for validation with id : " + jobForValidation.getDatasourceId());
        try {
            this.getValidationService().submitValidationJob(jobForValidation);
        } catch (ValidatorServiceException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void reSubmitJobForValidation(String jobId) throws JSONException {
        LOGGER.debug("Resubmit validation job with id : " + jobId);
        StoredJob job = monitorApi.getJobSummary(jobId,"all");
        Set<Integer> contentRules = new HashSet<Integer>();
        Set<Integer> usageRules = new HashSet<Integer>();

        RuleSet ruleSet = null;
        for (List<RuleSet> ruleSets : this.rulesetMap.values()) {
            for (RuleSet rSet : ruleSets)
                if (rSet.getGuidelinesAcronym().equals(job.getDesiredCompatibilityLevel())) {
                    ruleSet = rSet;
                    break;
                }
        }

        for (int ruleId : job.getRules()) {
            if (ruleSet.getContentRulesIds().contains(ruleId))
                contentRules.add(ruleId);
            else if (ruleSet.getUsageRulesIds().contains(ruleId))
                usageRules.add(ruleId);
        }
        if (!contentRules.isEmpty())
            job.setSelectedContentRules(contentRules);
        if (!usageRules.isEmpty())
            job.setSelectedUsageRules(usageRules);
        this.submitJobForValidation(job);
    }

    @Override
    public List<RuleSet> getRuleSets(@PathVariable("mode") String mode) {
        LOGGER.info("Getting rulesets for mode: " + mode);
        return rulesetMap.get(mode);
    }

    @Override
    public List<String> getSetsOfRepository(@PathVariable("url") String url) {
        LOGGER.debug("Getting sets of repository with url : " + url);
        try {
            return OaiTools.getSetsOfRepo(url);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public boolean identifyRepo(@PathVariable("url") String url) {
        LOGGER.debug("Identify repository with url : " + url);
        try {
            return OaiTools.identifyRepository(url);
        } catch (Exception e) {
            LOGGER.error("Error while identifying repository with url: " + url, e);
            return false;
        }
    }

    @Override
    public RuleSet getRuleSet(@PathVariable("acronym") String acronym) {
        LOGGER.debug("Getting ruleset with acronym : " + acronym);
        RuleSet ruleSet = null;
        try {
            for (List<RuleSet> ruleSets : this.rulesetMap.values()) {
                for (RuleSet rSet : ruleSets)
                    if (rSet.getGuidelinesAcronym().equals(acronym)) {
                        ruleSet = rSet;
                        break;
                    }
            }
            return ruleSet;
        } catch (Exception e) {
            LOGGER.error("Error getting ruleset", e);
            return null;
        }
    }

    @Override
    public List<StoredJob> getStoredJobsNew(String user, String jobType, Integer offset, Integer limit, String dateFrom,
                                            String dateTo, String validationStatus) throws ValidatorServiceException {
        return getValidationService().getStoredJobsNew(user, jobType, offset, limit, dateFrom, dateTo, validationStatus);
    }

    @Override
    public int getStoredJobsTotalNumberNew(String user, String jobType, String validationStatus) throws  ValidatorServiceException {
        return getValidationService().getStoredJobsTotalNumberNew(user, jobType, validationStatus);
    }

    @Override
    public InterfaceInformation getInterfaceInformation(@PathVariable("baseUrl") String baseUrl) throws ValidationServiceException {
        try {
            LOGGER.debug("Getting interface information with url: " + baseUrl);
            InterfaceInformation interfaceInformation = new InterfaceInformation();
            interfaceInformation.setIdentified(this.identifyRepo(baseUrl));
            if (interfaceInformation.isIdentified())
                interfaceInformation.setSets(this.getSetsOfRepository(baseUrl));

            return interfaceInformation;
        } catch (Exception e) {
            LOGGER.error("Error getting interface information with url: " + baseUrl, e);
//            emailUtils.reportException(e);
            throw new ValidationServiceException("login.generalError", ValidationServiceException.ErrorCode.GENERAL_ERROR);
        }
    }


}