/*
 *  Copyright 2017 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.datasourcesexplorer;

import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.PartialResultException;
import javax.naming.SizeLimitExceededException;
import javax.naming.directory.Attribute;
import javax.naming.directory.Attributes;
import javax.naming.directory.SearchControls;
import javax.naming.directory.SearchResult;
import javax.naming.ldap.InitialLdapContext;
import javax.naming.ldap.LdapContext;

import org.apache.avalon.framework.component.Component;
import org.apache.cocoon.ProcessingException;
import org.apache.commons.lang3.StringUtils;

import org.ametys.core.util.ldap.AbstractLDAPConnector;
import org.ametys.core.util.ldap.IncompleteLDAPResultException;

/**
 * Connection stuff to read ldap
 */
public class LDAPConnector extends AbstractLDAPConnector implements Component
{
    /** The compoent role */
    public static final String ROLE = LDAPConnector.class.getName();

    private static final int __LEVEL_SIZE = 100;

    /**
     * Get the ldap attributes of a node
     * @param ldapDatasourceId The ldap datasource id
     * @param dn The dn of the ldap node to get
     * @return The attributes
     * @throws ProcessingException If an error occurred with ldap
     */
    public List<Map<String, String>> getAttributes(String ldapDatasourceId, String dn) throws ProcessingException
    {
        try
        {
            _delayedInitialize(ldapDatasourceId);
        }
        catch (Exception e)
        {
            throw new ProcessingException(e);
        }
        
        LdapContext context = null;
        NamingEnumeration<String> ids = null;
        try
        {
            // Connect to the LDAP server.
            context = new InitialLdapContext(_getContextEnv(), null);
            Attributes attributes = context.getAttributes(StringUtils.substringBefore(dn, "," + _ldapBaseDN));
           
            List<Map<String, String>> returnedAttributes = new ArrayList<>();
            
            ids = attributes.getIDs();
            while (ids.hasMore())
            {
                String attrId = ids.next();
                Attribute attribute = attributes.get(attrId);
                for (int i = 0; i < attribute.size(); i++)
                {
                    String valueAsString;
                    
                    try
                    {
                        Object value = attribute.get(i);
                        if (value instanceof byte[])
                        {
                            byte[] valueAsBytes = (byte[]) value;
                            valueAsString = new String(valueAsBytes, StandardCharsets.UTF_8);
                        }
                        else
                        {
                            valueAsString = value.toString();
                        }
                        
                        if (valueAsString.length() > 255)
                        {
                            valueAsString = valueAsString.substring(0, 255) + "…";
                        }
                    }
                    catch (Throwable t)
                    {
                        valueAsString = "Error retrieving: " + t.getMessage();
                        getLogger().error("Cannot display value n°" + i + " of LDAP attribute '" + attrId + "' at " + (dn + "," + _ldapBaseDN), t);
                    }
                    
                    Map<String, String> returnedAttribute = new HashMap<>();
                    returnedAttribute.put("name", attrId);
                    returnedAttribute.put("value", valueAsString);
                    returnedAttributes.add(returnedAttribute);
                }
            }
            
            return returnedAttributes;
        }
        catch (NamingException e)
        {
            throw new ProcessingException(e);
        }
        finally
        {
            // Close connection resources
            _cleanup(context, ids);
        }
    }
    
    /**
     * Get children DN
     * @param ldapDatasourceId The ldap datasource id
     * @param dn The parent DN. Can be empty to get root DN.
     * @return The children DNs
     * @throws ProcessingException If an exception occurred while reading the ldap
     */ 
    public Collection<DN> getChildren(String ldapDatasourceId, String dn) throws ProcessingException
    {
        try
        {
            _delayedInitialize(ldapDatasourceId);
        }
        catch (Exception e)
        {
            throw new ProcessingException(e);
        }
        
        String filter = "(objectClass=*)";
        SearchControls constraints = new SearchControls();
        constraints.setSearchScope(SearchControls.ONELEVEL_SCOPE);

        try
        {
            if (StringUtils.isEmpty(dn))
            {
                int count;
                boolean incomplete;
                
                try
                {
                    count = _count("", filter, new Object[0], constraints);
                    incomplete = false;
                }
                catch (IncompleteLDAPResultException e)
                {
                    count = e.getPartialResults();
                    incomplete = true;
                    getLogger().warn("LDAP refused to return more than " + count + " results");
                }
                return Collections.singletonList(new DN(_ldapBaseDN, _ldapBaseDN + (count > 0 ? " (" + count + (incomplete ? "+" : "") + ")" : ""), count > 0));
            }
            else
            {
                Collection<DN> childrenDN = new ArrayList<>();
                
                int offset = 0;
                int limit = Integer.MAX_VALUE;
                if (dn.startsWith("#"))
                {
                    // limited subpart
                    String count = StringUtils.substringBefore(dn, ",").substring(1);
                    offset = Integer.parseInt(StringUtils.substringBefore(count, "-")) - 1;
                    limit = Integer.parseInt(StringUtils.substringAfter(count, "-")) - offset;
                }
                
                // Remove the pseudo-nodes
                String finalDN = Arrays.stream(StringUtils.split(dn, ",")).filter(s -> !s.startsWith("#")).collect(Collectors.joining(","));
                
                String subDN = finalDN.length() > _ldapBaseDN.length() ? finalDN.substring(0, finalDN.length() - (_ldapBaseDN.length() + 1)) : "";
                String prefixedSubDN = subDN.length() > 0 ? "," + subDN : "";
                
                int nodeSize;
                if (limit < Integer.MAX_VALUE)
                {
                    nodeSize = limit;
                }
                else
                {
                    try
                    {
                        nodeSize = _count(subDN, filter, new Object[0], constraints);
                    }
                    catch (IncompleteLDAPResultException e)
                    {
                        nodeSize = e.getPartialResults();
                        getLogger().warn("LDAP refused to return more than " + nodeSize + " results");
                    }
                }
                
                final int levelNeeded = (int) Math.floor(Math.log10(nodeSize - 1) / Math.log10(__LEVEL_SIZE));
                
                if (levelNeeded <= 0)
                {
                    // a few entries are sent directly
                    // TODO sort
                    List<SearchResult> results;
                    try
                    {
                        results = _search(subDN, filter, new Object[0], constraints, offset, limit);
                    }
                    catch (IncompleteLDAPResultException e)
                    {
                        results = e.getPartialResults();
                        getLogger().warn("LDAP refused to return more than " + results.size() + " results");
                        e.printStackTrace();
                    }
                    for (Iterator<SearchResult> iterator = results.iterator(); iterator.hasNext();)
                    {
                        SearchResult searchResult = iterator.next();
                        int count;
                        boolean incomplete;
                        try
                        {
                            count = _count(searchResult.getName() + prefixedSubDN, filter, new Object[0], constraints);
                            incomplete = false;
                        }
                        catch (IncompleteLDAPResultException e)
                        {
                            count = e.getPartialResults();
                            incomplete = true;
                            getLogger().warn("LDAP refused to return more than " + count + " results");
                        }
                        childrenDN.add(new DN(searchResult.getName(), searchResult.getName() + (count > 0 ? " (" + count + (incomplete ? "+" : "") + ")" : ""), count > 0));
                    }
                }
                else
                {
                    final int step = (int) Math.pow(__LEVEL_SIZE, levelNeeded);
                    int done = 0;
                    while (done < nodeSize)
                    {
                        int grow = Math.min(step, nodeSize - done);
                        childrenDN.add(new DN("#" + (done + 1) + "-" + (done + grow), "[" + (done + 1) + "..." + (done + grow) + "]", true));
                        done += grow;
                    }
                }
    
                return childrenDN;
            }
        }
        catch (NamingException e)
        {
            throw new ProcessingException(e);
        }
    }
    
    /**
     * Count the number of results
     * @param name  the name of the context or object to search
     * @param filter the filter expression to use for the search
     * @param filterArgs the array of arguments to substitute for the variables in filter. Can be null.
     * @param searchControls the search controls that control the search.
     * @return The number of results
     * @throws NamingException If an error occurred
     */
    protected boolean _hasResults(String name, String filter, Object[] filterArgs, SearchControls searchControls) throws NamingException
    {
        long countLimit = searchControls.getCountLimit();
        searchControls.setCountLimit(1);
        
        try
        {
            return _count(name, filter, filterArgs, searchControls) > 0;
        }
        catch (IncompleteLDAPResultException e)
        {
            // Should never happened since we ask for only 1 result
            getLogger().error("Truncated", e);
            return false;
        }
        finally
        {
            searchControls.setCountLimit(countLimit);
        }
    }
    
    /**
     * Count the number of results
     * @param name  the name of the context or object to search
     * @param filter the filter expression to use for the search
     * @param filterArgs the array of arguments to substitute for the variables in filter. Can be null.
     * @param searchControls the search controls that control the search.
     * @return The number of results
     * @throws NamingException If an error occurred
     * @throws IncompleteLDAPResultException If results are truncated
     */
    protected int _count(String name, String filter, Object[] filterArgs, SearchControls searchControls) throws NamingException, IncompleteLDAPResultException
    {
        int count = 0;
        
        LdapContext context = null;
        NamingEnumeration<SearchResult> tmpResults = null;
        
        boolean returningObjFlag = searchControls.getReturningObjFlag();
        String[] attrs = searchControls.getReturningAttributes();
        searchControls.setReturningObjFlag(false);
        searchControls.setReturningAttributes(new String[0]);
        
        try
        {
            // Connect to the LDAP server.
            context = new InitialLdapContext(_getContextEnv(), null);
            
            _setResultsControls(context, false);
            
            do
            {
                // Perform the search
                tmpResults = context.search(name, filter, filterArgs, searchControls);
                
                // Iterate over a batch of search results
                try
                {
                    while (tmpResults != null && tmpResults.hasMore())
                    {
                        tmpResults.next();
                        
                        count++;
                    }
                }
                catch (PartialResultException e)
                {
                    // ignore
                }
            }
            while (_hasMoreEntries(context));
        }
        catch (SizeLimitExceededException e)
        {
            throw new IncompleteLDAPResultException(count, e);
        }
        finally
        {
            // Close connection resources
            _cleanup(context, tmpResults);
            searchControls.setReturningObjFlag(returningObjFlag);
            searchControls.setReturningAttributes(attrs);
        }
        
        return count;
    }

    /**
     * A DN
     */
    public static class DN 
    {
        private String _dn;
        private boolean _hasChild;
        private String _label;
        
        /**
         * Create a DN
         * @param dn The ldap dn
         * @param label The label for the dn
         * @param hasChild Has this DN children
         */
        public DN(String dn, String label, boolean hasChild)
        {
            _dn = dn;
            _label = label;
            _hasChild = hasChild;
        }
        
        /**
         * Get the dn
         * @return the dn
         */
        public String getDN()
        {
            return _dn;
        }
        
        /**
         * Get the label
         * @return the label
         */
        public String getLabel()
        {
            return _label;
        }
        
        /**
         * Has child
         * @return true if has child
         */
        public boolean hasChild()
        {
            return _hasChild;
        }
    }
}