/*
 *  Copyright 2016 Anyware Services
 *
 *  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 org.ametys.plugins.contentio.synchronize.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import javax.naming.Context;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.directory.Attribute;
import javax.naming.directory.SearchControls;
import javax.naming.directory.SearchResult;

import org.apache.avalon.framework.component.Component;
import org.apache.cocoon.ProcessingException;
import org.slf4j.Logger;

import org.ametys.core.util.ldap.AbstractLDAPConnector;
import org.ametys.core.util.ldap.ScopeEnumerator;
import org.ametys.plugins.contentio.synchronize.SynchronizableContentsCollection;

/**
 * Helper component for {@link SynchronizableContentsCollection}s which need to access a LDAP
 */
public class LDAPCollectionHelper extends AbstractLDAPConnector implements Component
{
    /** Avalon Role */
    public static final String ROLE = LDAPCollectionHelper.class.getName();
    
    private int _nbError;
    private boolean _hasGlobalError;
    
    @Override
    public void _delayedInitialize(String dataSourceId) throws Exception
    {
        super._delayedInitialize(dataSourceId);
    }
    
    /**
     * Search over the LDAP the data from the filter.
     * After calling this method, call the methods {@link #getNbErrors()} and {@link #hasGlobalError()} to know about error which occured.
     * @param collectionId The id of the collection being synchronized
     * @param pageSize The page size for the search
     * @param relativeDN the name of the context or object to search
     * @param filter the filter expression to use for the search
     * @param searchScope The search scope
     * @param offset Begin of the search
     * @param limit Number of results
     * @param mapping The mapping for retrieving the remote values (keys are metadata paths)
     * @param idKey The key where to search the id value of the content
     * @param logger The logger
     * @return A map containing the content ids (keys) to import with their remote values (key is attribute, value is the remote value).
     */
    public Map<String, Map<String, Object>> search(String collectionId, int pageSize, String relativeDN, String filter, String searchScope, int offset, int limit, Map<String, List<String>> mapping, String idKey, Logger logger)
    {
        Map<String, Map<String, Object>> result = new LinkedHashMap<>();
        _nbError = 0;
        _hasGlobalError = false;
        
        try
        {
            for (SearchResult searchResult : _search(pageSize, relativeDN, filter, null, _getSearchControls(mapping, searchScope), offset, limit))
            {
                String idValue = (String) _getIdValue(idKey, searchResult, logger);
                if (idValue == null)
                {
                    _nbError++;
                    logger.warn("The id value '{}' for '{}' was null ", idKey, searchResult.getName());
                }
                else if (!result.keySet().contains(idValue))
                {
                    try
                    {
                        Map<String, Object> values = new HashMap<>();
                        NamingEnumeration<? extends Attribute> attributes = searchResult.getAttributes().getAll();
                        while (attributes.hasMoreElements())
                        {
                            Attribute attribute = attributes.nextElement();
                            values.put(attribute.getID(), _getLDAPValues(attribute));
                        }
                        result.put(idValue, values);
                    }
                    catch (Exception e)
                    {
                        _nbError++;
                        logger.warn("Failed to import the content '{}'", idValue, e);
                    }
                }
                else
                {
                    logger.warn("Cannot import '{}' because its id value '{}={}' is already an id value for another content", searchResult.getName(), idKey, idValue);
                }
            }
        }
        catch (Exception e)
        {
            _hasGlobalError = true;
            _nbError++;
            logger.error("Failed to populate contents from synchronizable collection of id '{}'", collectionId, e);
        }
        
        return result;
    }

    private List<Object> _getLDAPValues(Attribute attribute) throws NamingException
    {
        List<Object> ldapValues = new ArrayList<>();
        
        NamingEnumeration< ? > values = attribute.getAll();
        while (values.hasMoreElements())
        {
            ldapValues.add(values.nextElement());
        }
        
        return ldapValues;
    }
    
    /**
     * Returns the number of errors which occured {@link #search(String, int, String, String, String, int, int, Map, String, Logger)}
     * @return the number of errors which occured {@link #search(String, int, String, String, String, int, int, Map, String, Logger)}
     */
    public int getNbErrors()
    {
        return _nbError;
    }
    
    /**
     * Returns true if the a global error occured during {@link #search(String, int, String, String, String, int, int, Map, String, Logger)}
     * @return true if the a global error occured during {@link #search(String, int, String, String, String, int, int, Map, String, Logger)}
     */
    public boolean hasGlobalError()
    {
        return _hasGlobalError;
    }
    
    /**
     * Get the LDAP search controls.
     * @param mapping The mapping
     * @param searchScope The search scope
     * @return the search controls.
     * @throws ProcessingException if the scope is not valid
     */
    protected SearchControls _getSearchControls(Map<String, List<String>> mapping, String searchScope) throws ProcessingException
    {
        SearchControls controls = new SearchControls();
        
        List<String> attributes = new ArrayList<>();
        for (List<String> attribute : mapping.values())
        {
            attributes.addAll(attribute);
        }
        String[] attrArray = attributes.toArray(new String[attributes.size()]);
        
        controls.setReturningAttributes(attrArray);
        
        controls.setSearchScope(_getScope(searchScope));
        
        return controls;
    }
    
    /**
     * Get the scope as an integer (handlable by the SearchControls) from the scope string.
     * @param scopeStr the scope string.
     * @return the scope as an integer.
     * @throws ProcessingException if the given scope is not valid
     */
    protected int _getScope(String scopeStr) throws ProcessingException
    {
        try
        {
            return ScopeEnumerator.parseScope(scopeStr);
        }
        catch (IllegalArgumentException e)
        {
            throw new ProcessingException("Unable to parse scope", e);
        }
    }
    
    /**
     * Gets id value from a ldap entry
     * @param idKey The key where to search the id value
     * @param entry The ldap entry
     * @param logger The logger
     * @return The attribute value
     * @throws NamingException if a ldap query error occurred
     */
    protected Object _getIdValue(String idKey, SearchResult entry, Logger logger) throws NamingException
    {
        Attribute ldapAttr = entry.getAttributes().get(idKey);
        
        if (ldapAttr == null)
        {
            logger.warn("LDAP attribute not found: '{}'", idKey);
        }
        return ldapAttr != null ? ldapAttr.get() : null;
    }
    
    /**
     * Clean a connection to a ldap server.
     * 
     * @param context The connection to the database to close.
     * @param result The result to close.
     * @param logger The logger
     */
    protected void _cleanup(Context context, NamingEnumeration result, Logger logger)
    {
        if (result != null)
        {
            try
            {
                result.close();
            }
            catch (NamingException e)
            {
                _nbError++;
                logger.error("Error while closing ldap result", e);
            }
        }
        if (context != null)
        {
            try
            {
                context.close();
            }
            catch (NamingException e)
            {
                _nbError++;
                logger.error("Error while closing ldap connection", e);
            }
        }
    }
}