/**
 * Copyright (C) 2015 - 2018 Kosmos contact@kosmos.fr
 *
 * Projet: eprivacy
 * Version: 2.07.02
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.kosmos.eprivacy.configuration.properties.service;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;

import com.jsbsoft.jtf.core.ApplicationContextManager;
import com.jsbsoft.jtf.exception.ErreurApplicative;
import com.kosmos.eprivacy.configuration.model.bean.ConsentConfigurationAbstractBean;
import com.kosmos.eprivacy.configuration.model.predicate.ConsentConfigurationPredicate;
import com.kosmos.eprivacy.configuration.properties.dao.ConsentConfigurationDAO;
import com.kosmos.service.impl.ServiceManager;
import com.kosmos.usinesite.service.impl.ServiceInfosSiteProcessus;
import com.univ.multisites.InfosSite;
import com.univ.multisites.bean.impl.InfosSiteImpl;
import com.univ.multisites.service.ServiceInfosSite;

/**
 * Service de configuration de consentement.
 * Fournis plusieurs méthodes pouvant manipuler les configurations.
 */
public class ConsentConfigurationService {

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

    /**
     * DAO pour écrire et lire des configurations.
     */
    private ConsentConfigurationDAO consentConfigurationDAO;

    /**
     * Récupère une configuration à partir du code.
     *
     * @param codeConfiguration le code de configuration
     * @return un bean de configuration.
     */
    public ConsentConfigurationAbstractBean getByCode(final String codeConfiguration) {
        return consentConfigurationDAO.getByCode(codeConfiguration);
    }

    /**
     * Récupère une configuration à partir du code du site.
     *
     * @param codeSite le code du site.
     * @return un bean de configuration.
     */
    @Cacheable(value = "ConsentConfigurationService.getPromotedByCodeSite", key = "#codeSite", unless = "#result == null")
    public ConsentConfigurationAbstractBean getPromotedByCodeSite(final String codeSite) {
        LOGGER.info("getPromotedByCodeSite {} ", codeSite);
        final List<ConsentConfigurationAbstractBean> allConfigsBeans = getAllActive();
        LOGGER.debug("Liste des configurations eprivacy trouvées : {}", allConfigsBeans.stream().map(ConsentConfigurationAbstractBean::toString).collect(Collectors.toList()));
        //@formatter:off
            return allConfigsBeans.stream()
                .filter(b -> getConsentConfigurationPredicate(b).map(configurationPredicate -> configurationPredicate.test(b, codeSite)).orElse(false) )
                .min(Comparator.comparingInt(ConsentConfigurationAbstractBean::getOrder)).orElse(null);
        //@formatter:on
    }

    /**
     * Récupère l'évaluateur lié au bean.
     *
     * @param bean un bean.
     * @return l'évaluateur lié au type du bean.
     */
    public Optional<ConsentConfigurationPredicate> getConsentConfigurationPredicate(final ConsentConfigurationAbstractBean bean) {
        final Map<String, ConsentConfigurationPredicate> consentConfigurationPredicateMap = ApplicationContextManager.getAllBeansOfType(ConsentConfigurationPredicate.class);
        LOGGER.debug("consentConfigurationPredicateMap : {} ", new ArrayList<>(consentConfigurationPredicateMap.entrySet()));
        return consentConfigurationPredicateMap.values().stream().filter(c -> c.supports(bean)).findFirst();
    }

    /**
     * Récupère toutes les configurations.
     *
     * @return une liste de toutes les configurations, sans filtrage.
     */
    public List<ConsentConfigurationAbstractBean> getAll() {
        return consentConfigurationDAO.getAllWithStatus(null);
    }

    /**
     * Récupère toutes les configurations actives.
     *
     * @return une liste de toutes les configurations actives.
     */
    public List<ConsentConfigurationAbstractBean> getAllActive() {
        return consentConfigurationDAO.getAllWithStatus(true);
    }

    /**
     * Créé une configuration à partir du bean.
     *
     * @param bean le bean dont on souhaite créé le fichier correspondant.
     * @throws ErreurApplicative si une erreur est survenue lors de la création.
     */
    public void create(ConsentConfigurationAbstractBean bean) throws ErreurApplicative {
        consentConfigurationDAO.create(bean);
        getCodesSiteEligibles(bean).forEach(this::refresh);
    }


    private Set<String> getCodesSiteEligibles(final ConsentConfigurationAbstractBean bean){
        final ServiceInfosSite serviceInfosSite = ServiceManager.getServiceForBean(InfosSiteImpl.class);

        Collection<InfosSite> infosSites = serviceInfosSite.getListeInfosSitesActifs();
        return infosSites.stream().filter(site -> test(bean, site)).map(InfosSite::getAlias).collect(Collectors.toSet());
    }

    public boolean test(final ConsentConfigurationAbstractBean bean, InfosSite infosSite){
        final String httpHostname = infosSite.getHttpHostname();
        LOGGER.info("Domaines du bean '{}' : {}, httpHostname = {}", bean.getName(), bean.getDomains(), httpHostname);
        return bean.getDomains().stream().anyMatch(d -> test(d, httpHostname));
    }

    /**
     * Met à jour une configuration.
     *
     * @param bean le bean avec les nouvelles informations.
     * @throws ErreurApplicative si une erreur est survenue lors de la mise à jour.
     */
    public void update(ConsentConfigurationAbstractBean bean) throws ErreurApplicative {
        consentConfigurationDAO.update(bean);
        getCodesSiteEligibles(bean).forEach(this::refresh);
    }

    @CacheEvict(cacheNames = "ConsentConfigurationService.getPromotedByCodeSite", key = "#codeSite")
    public void refresh(String codeSite){
        // Ne fait rien - Invalide le cache pour que le code site en paramètre.
    }

    /**
     * Supprime une configuration.
     *
     * @param codeConfiguration code de la configuration à supprimer.
     */
    public void delete(String codeConfiguration) {
        //TODO charger bean
        consentConfigurationDAO.delete(codeConfiguration);
        getCodesSiteEligibles(bean).forEach(this::refresh);
    }

    public ConsentConfigurationDAO getConsentConfigurationDAO() {
        return consentConfigurationDAO;
    }

    public void setConsentConfigurationDAO(final ConsentConfigurationDAO consentConfigurationDAO) {
        this.consentConfigurationDAO = consentConfigurationDAO;
    }
}