import java.util.Collection;
import java.util.Comparator;
import java.util.NoSuchElementException;
import java.util.TreeSet;

import io.vertigo.lang.Assertion;

/**
 * Un facet custom est un facet permettant de sélectionner plusieurs critère (facet value) pour un seul et même facet, ce que ne permet pas vertigo.
 * La valeur de ce facet est calculée 'manuellement' après la recherche effectuée suivant les filtres fournis.
 *
 * @param <T> Type de la valeur de la facet value (string, date, int, long, ...).
 */
public class CustomFacet<T extends Comparable<T>> {

        public static final Comparator<CustomFacetValue<String>> CUSTOM_FACET_STRING_VALUE_COMPARATOR = new Comparator<CustomFacetValue<String>>() {
                @Override
                public int compare(final CustomFacetValue<String> left, final CustomFacetValue<String> right) {
                        return left.getValue().compareTo(right.getValue());
                }
        };

        /**
         * Type du custom facet.
         */
        public enum CustomFacetType {
                /**
                 * Multiple check box permettant de sélectionner plusieurs valeurs dans une liste.
                 */
                MULTI_SELECT_CHECKBOX,

                /**
                 * Intervalle de date.
                 */
                DATE_RANGE,

                /**
                 * Checkbox + inputtext
                 */
                CHECK_BOX_WITH_INPUT,
                /**
                 * Checkbox + inputtext + autre checkbox pour voir si on veut le input text exact ou contient
                 */
                CHECK_BOX_WITH_INPUT_EXACT_CONTIENT;
        }

        private final String title;
        private final String id;
        private final Collection<CustomFacetValue<T>> values;
        private final CustomFacetType type;

        /**
         * Valeur d'un facet. Correspond à une ligne de filtrage sélectionnable dans le facet.
         * Possède un libellé, un comptage et une valeur (identifiant, clef, ..., permettant le filtrage dans l'index ES).
         *
         * @param <T> Type de la valeur de la facet value (string, date, int, long, ...).
         */
        public static class CustomFacetValue<T extends Comparable<T>> implements Comparable<CustomFacetValue<T>> {
                private final T value;
                private final String label;
                private final String rawLabel;
                private final Long count;

                /**
                 * Contructeur par défaut.
                 *
                 * @param value identifiant, valeur, clef de la ligne de facet.
                 * @param label libellé de la ligne de facet.
                 * @param count le comptage du nombre d'élément pour ce facet.
                 */
                public CustomFacetValue(final T value, final String label, final Long count) {
                        Assertion.checkNotNull(label);
                        Assertion.checkNotNull(count);
                        this.count = count;
                        this.value = value;
                        this.label = label;
                        rawLabel = label;
                }

                /**
                 * Get label property.
                 *
                 * @return the label property.
                 */
                public String getLabel() {
                        return label;
                }

                /**
                 * Get the value property.
                 *
                 * @return the value property.
                 */
                public T getValue() {
                        return value;
                }

                /**
                 * @return the rawLabel
                 */
                public String getRawLabel() {
                        return rawLabel;
                }

                /**
                 * @return the count
                 */
                public Long getCount() {
                        return count;
                }

                @Override
                public int compareTo(final CustomFacetValue<T> o) {
                        // Pour un tri alphabétique.
                        return this.label.compareTo(o.getLabel());
                }

                @Override
                public int hashCode() {
                        final int prime = 31;
                        int result = 1;
                        result = prime * result + ((value == null) ? 0 : value.hashCode());
                        return result;
                }

                @Override
                public boolean equals(final Object obj) {
                        if (this == obj) {
                                return true;
                        }
                        if (obj == null) {
                                return false;
                        }
                        if (getClass() != obj.getClass()) {
                                return false;
                        }
                        @SuppressWarnings("unchecked")
                        final CustomFacetValue<T> other = (CustomFacetValue<T>) obj;
                        if (value == null) {
                                if (other.value != null) {
                                        return false;
                                }
                        } else if (!value.equals(other.value)) {
                                return false;
                        }
                        return true;
                }

        }

        /**
         * Constructeur par défaut.
         * <p>
         * Type de facet à {@code CustomFacetType.MULTI_SELECT_VALUES} par défaut;
         *
         * @param title titre du facet qui sera utilisé pour le display UI (= label).
         * @param id identifiant qui sera transmis dans le customObject lors de la recherche.
         */
        public CustomFacet(final String title, final String id) {
                this(title, id, CustomFacetType.MULTI_SELECT_CHECKBOX);
        }

        /**
         * Constructeur avec comparateur si l'ordering des facets values n'est pas par ordre alphabétique des labels.
         * <p>
         * Type de facet à {@code CustomFacetType.MULTI_SELECT_VALUES} par défaut;
         *
         * @param title titre du facet qui sera utilisé pour le display UI (= label).
         * @param id identifiant qui sera transmis dans le customObject lors de la recherche.
         * @param comparator comparateur pour ordonner les facets values (si différent de l'ordre alphabétique des labels).
         */
        public CustomFacet(final String title, final String id, final Comparator<CustomFacetValue<T>> comparator) {
                this(title, id, CustomFacetType.MULTI_SELECT_CHECKBOX, comparator);
        }

        /**
         * Constructeur paramétré.
         *
         * @param title titre du facet qui sera utilisé pour le display UI (= label).
         * @param id identifiant qui sera transmis dans le customObject lors de la recherche.
         * @param type type de facet (intervalle de date, choix multiple).
         */
        public CustomFacet(final String title, final String id, final CustomFacetType type) {
                this(title, id, type, null);
        }

        /**
         * Constructeur avec comparateur si l'ordering des facets values n'est pas par ordre alphabétique des labels.
         *
         * @param title titre du facet qui sera utilisé pour le display UI (= label).
         * @param id identifiant qui sera transmis dans le customObject lors de la recherche.
         * @param type type de facet (intervalle de date, choix multiple).
         * @param comparator comparateur pour ordonner les facets values (si différent de l'ordre alphabétique des labels).
         */
        public CustomFacet(final String title, final String id, final CustomFacetType type, final Comparator<CustomFacetValue<T>> comparator) {
                super();
                this.title = title;
                this.id = id;
                this.type = type;
                values = new TreeSet<>(comparator);
        }

        /**
         * @return the title
         */
        public String getTitle() {
                return title;
        }

        /**
         * @return the id
         */
        public String getId() {
                return id;
        }

        /**
         * @return the type
         */
        public CustomFacetType getType() {
                return type;
        }

        /**
         * Ajoute une valeur de facet au facet.
         *
         * @param customFacetValue la ligne de facet.
         *
         * @return {@code true}, toujours.
         */
        public boolean addFacetValue(final CustomFacetValue<T> customFacetValue) {
                return values.add(customFacetValue);
        }

        /**
         * Détermine si la valeur d'un facet est présent dans ce facet.
         *
         * @param value value (identifiant) de la ligne de facet à tester.
         *
         * @return {@code true} si la valeur existe, {@code false} sinon.
         */
        public boolean isFacetValueExists(final String value) {
                for (final CustomFacetValue<T> cfv : values) {
                        if (cfv.getValue().equals(value)) {
                                return true;
                        }
                }

                return false;
        }

        /**
         * Récupère une ligne de facet custom par sa valeur.
         *
         * @param value la valeur de la ligne de facet.
         *
         * @return la ligne de facet ou une exception {@link NoSuchElementException} si non trouvé.
         */
        public CustomFacetValue<T> getCustomFacetValue(final String value) {
                for (final CustomFacetValue<T> cfv : values) {
                        if (cfv.getValue().equals(value)) {
                                return cfv;
                        }
                }

                throw new NoSuchElementException("Le custom facet value avec pour valeur '" + value + "' n'existe pas.");
        }

        /**
         * @return the values
         */
        public Collection<CustomFacetValue<T>> getValues() {
                return values;
        }

}