/*
 *  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.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import javax.naming.Binding;
import javax.naming.NameClassPair;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.directory.Attribute;
import javax.naming.directory.Attributes;
import javax.naming.directory.SearchControls;
import javax.naming.directory.SearchResult;
import javax.naming.ldap.Control;
import javax.naming.ldap.InitialLdapContext;
import javax.naming.ldap.LdapContext;
import javax.naming.ldap.PagedResultsControl;
import javax.naming.ldap.PagedResultsResponseControl;

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;

/**
 * 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.hasMoreElements())
            {
                String attrId = iDs.nextElement();
                Attribute attribute = attributes.get(attrId);
                for (int i = 0; i < attribute.size(); i++)
                {
                    String value = (String) attribute.get(i);
                    
                    Map<String, String> returnedAttribute = new HashMap<>();
                    returnedAttribute.put("name", attrId);
                    returnedAttribute.put("value", value);
                    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);
        }
        
        try
        {
            LdapContext context = null;
            NamingEnumeration<Binding> listBindings = null;
            try
            {
                // Connect to the LDAP server.
                context = new InitialLdapContext(_getContextEnv(), null);
                
                if (StringUtils.isEmpty(dn))
                {
                    // Root node
                    int count = _count(context);
                    return Collections.singletonList(new DN(_ldapBaseDN, _ldapBaseDN + (count > 0 ? " (" + count + ")" : ""), count > 0));
                }
                else
                {
                    // Sub nodes
                    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)) : "";
                    LdapContext subContext = (LdapContext) context.lookup(subDN);
                    
                    int nodeSize = limit < Integer.MAX_VALUE ? limit : _count(subContext);
                    
                    final int levelNeeded = (int) Math.floor(Math.log10(nodeSize - 1) / Math.log10(__LEVEL_SIZE));
                    
                    if (levelNeeded <= 0)
                    {
                        // a few entries are sent directly
                        int index = 0;
                        listBindings = subContext.listBindings("");
                        while (listBindings.hasMore())
                        {
                            Binding next = listBindings.next();
                            index++;
                            if (index >= offset)
                            {
                                if (index < offset + limit)
                                {
                                    int count = _count((LdapContext) next.getObject());
                                    childrenDN.add(new DN(next.getName(), next.getName() + (count > 0 ? " (" + count + ")" : ""), count > 0));
                                }
                                else
                                {
                                    break;
                                }
                            }
                        }
                    }
                    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;
                }
            }
            finally
            {
                // Close connection resources
                _cleanup(context, listBindings);
            }
        }
        catch (NamingException e)
        {
            throw new ProcessingException(e);
        }
    }
    
    /**
     * Count the number of results
     * @param pageSize The number of entries in a page
     * @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(int pageSize, String name, String filter, Object[] filterArgs, SearchControls searchControls) throws NamingException
    {
        long countLimit = searchControls.getCountLimit();
        searchControls.setCountLimit(1);
        
        try
        {
            return _count(pageSize, name, filter, filterArgs, searchControls) > 0;
        }
        finally
        {
            searchControls.setCountLimit(countLimit);
        }
    }

    /**
     * Ccount the child node of a cocntext
     * @param context The context
     * @return The number of children
     * @throws NamingException if an error occurred
     */
    protected int _count(LdapContext context) throws NamingException
    {
        int count = 0;
        NamingEnumeration<NameClassPair> list = null;
        try
        {
            list = context.list("");
            while (list.hasMore())
            {
                list.next();
                count++;
            }
        }
        finally 
        {
            _cleanup(null, list);
        }
        return count;
    }
    
    /**
     * Count the number of results
     * @param pageSize The number of entries in a page
     * @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 int _count(int pageSize, String name, String filter, Object[] filterArgs, SearchControls searchControls) throws NamingException
    {
        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);
            byte[] cookie = null;
            
            _setPagingIfSupported(pageSize, context);
            
            do
            {
                // Perform the search
                tmpResults = context.search(name, filter, filterArgs, searchControls);
                
                // Iterate over a batch of search results
                while (tmpResults != null && tmpResults.hasMoreElements())
                {
                    tmpResults.nextElement();
                    
                    count++;
                    
                    // Examine the paged results control response
                    Control[] controls = context.getResponseControls();
                    if (controls != null)
                    {
                        for (int i = 0; i < controls.length; i++)
                        {
                            if (controls[i] instanceof PagedResultsResponseControl)
                            {
                                PagedResultsResponseControl prrc = (PagedResultsResponseControl) controls[i];
                                cookie = prrc.getCookie();
                            }
                        }
                    }
                    
                    // Re-activate paged results
                    if (isPagingSupported())
                    {
                        try
                        {
                            context.setRequestControls(new Control[]{new PagedResultsControl(pageSize, cookie, Control.NONCRITICAL)});
                        }
                        catch (IOException ioe)
                        {
                            getLogger().error("Error setting the PagedResultsControl in the LDAP context.", ioe);
                        }
                    }
                }
            }
            while (cookie != null);
        }
        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;
        }
    }
}