package com.megatim.fdxconsultation.service.impl.startup;

import com.bekosoftware.genericdaolayer.dao.tools.RestrictionsContainer;
import com.megatim.fdxcommons.core.ifaces.helper.DataInMemoryHandler;
import com.megatim.fdxcommons.model.enumeration.TypeOperation;
import com.megatim.fdxcommons.tools.context.AppContext;
import com.megatim.fdxconsultation.tools.CommonTools;
import com.megatim.fdxconsultation.core.ifaces.administration.ActionManager;
import com.megatim.fdxconsultation.core.ifaces.administration.RoleManager;
import com.megatim.fdxconsultation.core.ifaces.administration.UserManager;
import com.megatim.fdxconsultation.core.ifaces.configuration.CodeStatutHttpManager;
import com.megatim.fdxconsultation.model.administration.Action;
import com.megatim.fdxconsultation.model.administration.Role;
import com.megatim.fdxconsultation.model.administration.User;
import com.megatim.fdxconsultation.model.configuration.CodeStatutHttp;
import com.megatim.file.model.enumeration.TypeSauvegarde;
import com.megatim.file.tools.entites.context.FileModuleAppContextEntity;
import com.mgt.rs.security.core.common.Secured;
import com.mgt.rs.security.core.common.SecuredClass;
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.ejb.Singleton;
import javax.ejb.Startup;
import javax.inject.Inject;
import com.megatim.fdxconsultation.core.ifaces.integration.AppColumnDeleter;
import com.megatim.fdxconsultation.core.impl.dataproductionworker.DataProductionWorkerGroup;

/**
 *
 * @author lenovo
 */
@Singleton
@Startup
public class StartupBean {

    @Inject
    protected ActionManager actionManager;

    @Inject
    protected RoleManager roleManager;

    @Inject
    protected UserManager userManager;

    @Inject
    protected CodeStatutHttpManager codeStatutHttpManager;

    @Inject
    private DataInMemoryHandler dataInMemoryHandler;

    @Inject
    private AppColumnDeleter appColumnDeleter;

    @Inject
    private DataProductionWorkerGroup dataProductionWorkerGroup;

    @PostConstruct
    public void init() {
        dataInMemoryHandler.initializeDataInMemory();
        addNewActions();
        addAdmins();
        ajouterCodeStatusHttp();
        initializeFileModule();
        appColumnDeleter.delete();
        dataProductionWorkerGroup.start();
    }

    private void initializeFileModule() {

        /* Variabless */
        List<String> extensionsAutorises = Arrays.asList("pdf", "docx", "rar");

        /* Précise le mode de sauvegarde */
        FileModuleAppContextEntity.configuration.setModeSauvegarde(TypeSauvegarde.DISQUE);

        /* Précise la taille max des fichiers */
        FileModuleAppContextEntity.configuration.setTailleUploadMax(10);

        /* Précise la liste des extentations autoriséess */
        FileModuleAppContextEntity.configuration.setExtensionsAutorisees(extensionsAutorises);

    }

    /**
     * Methode permettant de charger les codes statuts http
     */
    private void ajouterCodeStatusHttp() {

        /* Variables */
        List<CodeStatutHttp> liste = codeStatutHttpManager.findAll();

        /* On vide le registre */
        AppContext.registre_codes_http.clear();

        /* Si liste non vide */
        if (liste == null || liste.isEmpty()) {

            /* On initialise la liste */
            liste = new ArrayList<CodeStatutHttp>();

            /* 1xx - Informations */
            liste.add(new CodeStatutHttp("100", "Le serveur a reçu les en-têtes et attend le corps de la requête"));
            liste.add(new CodeStatutHttp("101", "Le client a demandé un changement de protocole, accepté par le serveur"));
            liste.add(new CodeStatutHttp("102", "La requête est en cours de traitement"));

            /* 2xx - Succès */
            liste.add(new CodeStatutHttp("200", "La requête a réussi"));
            liste.add(new CodeStatutHttp("201", "La requête a abouti à la création d'une ressource"));
            liste.add(new CodeStatutHttp("202", "La requête a été acceptée, mais le traitement est en cours"));
            liste.add(new CodeStatutHttp("203", "La réponse contient des informations provenant d'une source tierce"));
            liste.add(new CodeStatutHttp("204", "La requête a réussi, mais il n'y a pas de contenu à retourner"));
            liste.add(new CodeStatutHttp("205", "La requête a réussi, le client doit réinitialiser l'interface utilisateur"));
            liste.add(new CodeStatutHttp("206", "Une partie de la ressource a été envoyée"));

            /* 3xx - Redirections */
            liste.add(new CodeStatutHttp("300", "Plusieurs options sont disponibles pour la ressource"));
            liste.add(new CodeStatutHttp("301", "La ressource a été déplacée de manière permanente"));
            liste.add(new CodeStatutHttp("302", "La ressource a été temporairement déplacée"));
            liste.add(new CodeStatutHttp("303", "La ressource est disponible à une autre URL"));
            liste.add(new CodeStatutHttp("304", "La ressource n'a pas été modifiée depuis la dernière requête"));
            liste.add(new CodeStatutHttp("307", "Redirection temporaire avec conservation de la méthode HTTP"));
            liste.add(new CodeStatutHttp("308", "Redirection permanente avec conservation de la méthode HTTP"));

            /* 4xx - Erreurs du client */
            liste.add(new CodeStatutHttp("400", "La requête est mal formée ou invalide"));
            liste.add(new CodeStatutHttp("401", "L'authentification est requise pour accéder à la ressource"));
            liste.add(new CodeStatutHttp("403", "Le client n'a pas les permissions nécessaires pour accéder à la ressource"));
            liste.add(new CodeStatutHttp("404", "La ressource demandée n'existe pas"));
            liste.add(new CodeStatutHttp("405", "La méthode HTTP utilisée n'est pas autorisée pour cette ressource"));
            liste.add(new CodeStatutHttp("406", "La ressource n'est pas disponible dans un format acceptable pour le client"));
            liste.add(new CodeStatutHttp("408", "Le serveur a expiré en attente de la requête"));
            liste.add(new CodeStatutHttp("409", "Un conflit a été détecté"));
            liste.add(new CodeStatutHttp("410", "La ressource n'est plus disponible et n'a pas d'adresse de redirection"));
            liste.add(new CodeStatutHttp("411", "La requête doit spécifier la longueur de son contenu"));
            liste.add(new CodeStatutHttp("412", "Une précondition dans les en-têtes de la requête a échoué"));
            liste.add(new CodeStatutHttp("413", "La taille de la requête est trop grande"));
            liste.add(new CodeStatutHttp("414", "L'URI fourni est trop long pour être traité"));
            liste.add(new CodeStatutHttp("415", "Le format de la requête n'est pas supporté"));
            liste.add(new CodeStatutHttp("422", "La requête est bien formée mais ne peut pas être traitée"));
            liste.add(new CodeStatutHttp("429", "Trop de requêtes ont été envoyées dans un court laps de temps"));

            /* 5xx - Erreurs du serveur */
            liste.add(new CodeStatutHttp("500", "Une erreur inattendue s'est produite sur le serveur"));
            liste.add(new CodeStatutHttp("501", "La méthode HTTP demandée n'est pas supportée par le serveur"));
            liste.add(new CodeStatutHttp("502", "Une réponse invalide a été reçue d'un serveur en amont"));
            liste.add(new CodeStatutHttp("503", "Le serveur est temporairement indisponible"));
            liste.add(new CodeStatutHttp("504", "Le serveur en amont a mis trop de temps à répondre"));
            liste.add(new CodeStatutHttp("505", "La version HTTP utilisée n'est pas supportée"));

            /* On save en bd */
            for (CodeStatutHttp codeStatutHttp : liste) {

                /* On save */
                codeStatutHttpManager.add(codeStatutHttp, null);

            }

        }

        /* On ajoute dans la map */
        for (CodeStatutHttp codeStatutHttp : liste) {

            /* On ajoute à la map */
            AppContext.registre_codes_http.put(codeStatutHttp.getCode(), codeStatutHttp.getLibelle());

        }

    }

    private void addAdmins() {

        List<User> users = userManager.findAll();

        //Pas d'admin
        if (!users.stream().filter(u -> u.getRole().getAdmin()).findAny().isPresent()) {
            Role role = new Role();
            role.setLibelle("Admin");
            role.setDescription("Admin");
            role.setAdmin(true);
            Role newRole = roleManager.save(role);
            addUser("adminc", "P@ssw0rd", newRole);
        }

        //pas de super admin
        if (!users.stream().filter(u -> u.getRole().getSuperAdmin()).findAny().isPresent()) {
            Role role = new Role();
            role.setLibelle("Super Admin");
            role.setDescription("Super Admin");
            role.setSuperAdmin(true);
            Role newRole = roleManager.save(role);
            addUser("adminv", "P@ssw0rd", newRole);
        }

        //Pas de mega admin
        if (!users.stream().filter(u -> u.getRole().getMegaAdmin()).findAny().isPresent()) {
            Role role = new Role();
            role.setLibelle("Hyper Admin");
            role.setDescription("Hyper Admin");
            role.setMegaAdmin(true);
            Role newRole = roleManager.save(role);
            addUser("admincontrol", "P@ssw0rd", newRole);
        }

    }

    private void addUser(String userName, String password, Role role) {
        User user = new User();
        user.setUserName(userName);
        user.setDelaiInactivite(10);
        user.setPwd(CommonTools.encryptPassword(password));
        user.setRole(role);
        //user.getRoles().add(role);
        userManager.save(user);
    }

    private void addNewActions() {

        List<Class<?>> classes = CommonTools.getAnnotatedClasses("com.megatim.fdxconsultation.service", "com.mgt.rs.security.core.common.SecuredClass");

        classes.forEach(clazz -> {

            SecuredClass securedClass = clazz.getAnnotation(SecuredClass.class);
            Method[] methods = clazz.getMethods();

            for (Method method : methods) {

                Secured secured = getInheritedAnnotation(Secured.class, method);
                if (secured != null && secured.action() != null && !secured.action().isEmpty() && !secured.action().equals("*")) {
                    //On crée l'action ici
                    Action action = new Action();
                    action.setModule(securedClass.module());
                    action.setPath(securedClass.path());
                    action.setDescription(securedClass.description());
                    action.setName(secured.action());

                    RestrictionsContainer requeteur = RestrictionsContainer.newInstance();

                    //On ajoute les criteres
                    requeteur.addEq("name", action.getName());
                    requeteur.addEq("path", action.getPath());
                    requeteur.addEq("module", action.getModule());
                    requeteur.addEq("typeOperation", TypeOperation.AJOUTER);

                    List<Action> datas = actionManager.filter(requeteur.getPredicats(), null, null, 0, -1);
                    if (datas.isEmpty()) {
                        actionManager.save(action);
                    }

                }
            }

        });

    }

    public static <A extends Annotation> A getInheritedAnnotation(Class<A> annotationClass, AnnotatedElement element) {
        A annotation = element.getAnnotation(annotationClass);
        if (annotation == null && element instanceof Method) {
            annotation = getOverriddenAnnotation(annotationClass, (Method) element);
        }
        return annotation;
    }

    private static <A extends Annotation> A getOverriddenAnnotation(Class<A> annotationClass, Method method) {
        final Class<?> methodClass = method.getDeclaringClass();
        final String name = method.getName();
        final Class<?>[] params = method.getParameterTypes();
        // prioritize all superclasses over all interfaces
        final Class<?> superclass = methodClass.getSuperclass();
        if (superclass != null) {
            final A annotation = getOverriddenAnnotationFrom(annotationClass, superclass, name, params);
            if (annotation != null) {
                return annotation;
            }
        }
        // depth-first search over interface hierarchy
        for (final Class<?> intf : methodClass.getInterfaces()) {
            final A annotation = getOverriddenAnnotationFrom(annotationClass, intf, name, params);
            if (annotation != null) {
                return annotation;
            }
        }
        return null;
    }

    private static <A extends Annotation> A getOverriddenAnnotationFrom(Class<A> annotationClass, Class<?> searchClass, String name, Class<?>[] params) {
        try {
            final Method method = searchClass.getMethod(name, params);
            final A annotation = method.getAnnotation(annotationClass);
            if (annotation != null) {
                return annotation;
            }
            return getOverriddenAnnotation(annotationClass, method);
        } catch (final NoSuchMethodException e) {
            return null;
        }
    }
}