/**
 * $RCSfile$
 * $Revision$
 * $Date$
 *
 * Copyright (C) 2005 Jive Software. All rights reserved.
 *
 * This software is published under the terms of the GNU Public License (GPL),
 * a copy of which is included in this distribution.
 */

package org.jivesoftware.messenger.ldap;

import org.jivesoftware.util.*;
import org.jivesoftware.messenger.user.*;
import org.jivesoftware.messenger.group.*;
import org.xmpp.packet.JID;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Collection;
import java.util.Iterator;
import java.util.StringTokenizer;
import java.text.MessageFormat;

import javax.naming.Context;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.directory.*;
import javax.naming.ldap.InitialLdapContext;
import javax.naming.ldap.LdapContext;

/**
 * LDAP implementation of the GroupProvider interface.  All data in the directory is
 * treated as read-only so any set operations will result in an exception.
 *
 * @author Greg Ferguson
 */
public class LdapGroupProvider implements GroupProvider 
{

    private LdapManager manager;
    private UserProvider userProvider;
    private int groupCount;
    private long expiresStamp;

    /**
     * Constructor of the LdapGroupProvider class.
     * Gets an LdapManager instance from the LdapManager class.
     *
     */
    public LdapGroupProvider() {
        manager = LdapManager.getInstance();
        userProvider = UserManager.getUserProvider();
        groupCount = -1;
        expiresStamp = System.currentTimeMillis();
    }

    /**
     * Always throws UnsupportedOperationException because
     * LDAP operations are treated as read only.
     *
     * @param group Name of the group to be created.
     * @throws UnsupportedOperationException when called.
     */
    public Group createGroup (String group)
    	throws UnsupportedOperationException
    {
	    throw new UnsupportedOperationException();
    }

    /**
     * Always throws UnsupportedOperationException because
     * LDAP operations are treated as read only.
     *
     * @param group Group that should be deleted.
     * @throws UnsupportedOperationException when called.
     */
    public void deleteGroup (Group group)
    	throws UnsupportedOperationException
    {
	    throw new UnsupportedOperationException();
    }

    /**
     * Always throws UnsupportedOperationException because
     * LDAP operations are treated as read only.
     *
     * @param group Group that should be deleted.
     * @throws UnsupportedOperationException when called.
     */
    public void deleteGroup (String group)
    	throws UnsupportedOperationException
    {
	    throw new UnsupportedOperationException();
    }

    /**
     * Will populate a group object based on the group name
     * that is given.
     *
     * @param group Name of group that should be retrieved.
     * @return a populated group based on the name provided.
     */
    public Group getGroup (String group)
    {
        String filter = MessageFormat.format(manager.getGroupSearchFilter(),"*");
        String searchFilter = "(&"+filter+"("+
                              manager.getGroupNameField()+"="+group+"))";
        Collection<Group> groups = getGroupBasedOnFilter(searchFilter);
        if (groups.size() > 1)
            return null; //if multiple groups found return null
        for (Group g : groups)
            return g; //returns the first group found
        return null;
    }

    /**
     * Always throws UnsupportedOperationException because
     * LDAP operations are treated as read only.
     *
     * @param name Current name of group.
     * @param s Desired name of group.
     * @throws UnsupportedOperationException when called.
     */
    public void setName(String name, String s)
    	throws UnsupportedOperationException
    {
	    throw new UnsupportedOperationException();
    }

    /**
     * Always throws UnsupportedOperationException because
     * LDAP operations are treated as read only.
     *
     * @param description Current description of group.
     * @param s Desired description of group.
     * @throws UnsupportedOperationException when called.
     */
    public void setDescription(String description,String s)
    	throws UnsupportedOperationException
    {
	    throw new UnsupportedOperationException();
    }

    /**
     * Will return the current number of groups in the 
     * LDAP server.
     *
     * @return the number of groups in the LDAP server.
     */
    public int getGroupCount()
    {
        // Cache group count for 5 minutes.
        if (groupCount != -1 && System.currentTimeMillis() < expiresStamp) {
            return groupCount;
        }
        int count = 0;

        if (manager.isDebugEnabled()) {
            Log.debug("Trying to get the number of groups in the system.");
        }
        DirContext ctx = null;
        NamingEnumeration answer = null;
        String searchFilter = MessageFormat.format(manager.getGroupSearchFilter(),"*");
        try
        {
           ctx = manager.getContext();
           if (manager.isDebugEnabled()) {
              Log.debug("Starting LDAP search...");
              Log.debug("Using groupSearchFilter: "+searchFilter);
           }

           // Search for the dn based on the groupname.
           answer = ctx.search("",searchFilter,new SearchControls());
 
           if (manager.isDebugEnabled()) {
              Log.debug("... search finished");
           }
        }
        catch (Exception e)
        {
           if (manager.isDebugEnabled())
              Log.debug("Error while searching for groups.",e);
        }
        try 
        {
           while (answer.hasMoreElements())
           {
              count++;
              answer.next();
           }
        }
        catch (Exception e){ }

        this.groupCount = count;
        this.expiresStamp = System.currentTimeMillis() + JiveConstants.MINUTE *5;
        return count;
    }

    /**
     * Will return a collecion of all groups in the system.
     *
     * @return collection of all groups in the system.
     */
    public Collection<Group> getGroups()
    {
        String filter = MessageFormat.format(manager.getGroupSearchFilter(),"*");
        return getGroupBasedOnFilter(filter);
    }

    /**
     * Will return a collecion of groups in the system 
     * based on the start index and end index.  Useful when 
     * displaying a certain number of groups per page 
     * on a webpage.
     *
     * @param start starting index
     * @param end ending index
     * @return collection of groups.
     */
    public Collection<Group> getGroups(int start, int end)
    {
        ArrayList<Group> returnCollection = new ArrayList<Group>();
    	Collection<Group> groups = getGroups();
        Iterator<Group> it = groups.iterator();
        for (int i = 0; i < groups.size(); i++)
        {
           Group g = it.next();
           if (i >= start && i <= end)
              returnCollection.add(g);
           if (i > end)
              break;
        }
        return returnCollection;
    }

    /**
     * Will return a collection of groups in the  
     * system that the user provided belongs to.
     *
     * @param user a user
     * @return collection of groups.
     */
    public Collection<Group> getGroups(User user)
    {
        String username = JID.unescapeNode(user.getUsername());
        if (!manager.getPosixEnabled())
        {
           try
           {
              username = manager.findUserDN(username) + "," +
                         manager.getBaseDN();
           }
           catch (Exception e)
           {
              return new ArrayList<Group>();
           }
        }
        
        String filter = MessageFormat.format(manager.getGroupSearchFilter(),username);
        return getGroupBasedOnFilter(filter);
    }

    /**
     * Always throws UnsupportedOperationException because
     * LDAP operations are treated as read only.
     *
     * @param groupName Name of a group.
     * @param username Name of a user.
     * @param administrator True if is an administrator.
     * @throws UnsupportedOperationException when called.
     */
    public void addMember(String groupName, String username, boolean administrator)
    	throws UnsupportedOperationException
    {
	    throw new UnsupportedOperationException();
    }

    /**
     * Always throws UnsupportedOperationException because
     * LDAP operations are treated as read only.
     *
     * @param groupName Name of a group.
     * @param username Name of a user.
     * @param administrator True if is an administrator.
     * @throws UnsupportedOperationException when called.
     */
    public void updateMember(String groupName, String username, boolean administrator)
    	throws UnsupportedOperationException
    {
	    throw new UnsupportedOperationException();
    }

    /**
     * Always throws UnsupportedOperationException because
     * LDAP operations are treated as read only.
     *
     * @param groupName Name of a group.
     * @param username Name of a user.
     * @throws UnsupportedOperationException when called.
     */
    public void deleteMember(String groupName, String username) 
    	throws UnsupportedOperationException
    {
        throw new UnsupportedOperationException();
    }

    /**
     * Always returns true because all LDAP operations
     * are treated as read only.
     *
     * @return true always because all LDAP functions are read only.
     */
    public boolean isReadOnly() 
    {
        return true;
    }

    /**
     * An auxilary method used to perform LDAP queries based on a 
     * provided LDAP search filter.
     *
     * @return a collection of groups.
     * @param searchFilter LDAP search filter used to query.
     */
    public Collection<Group> getGroupBasedOnFilter (String searchFilter)
    {
       ArrayList<Group> groups = new ArrayList<Group>();
       boolean debug = Log.isDebugEnabled();
       if (debug) {
           Log.debug("Trying to find all groups in the system.");
       }
       DirContext ctx = null;
       NamingEnumeration answer = null;
       try
       {
          ctx = manager.getContext();
          if (manager.isDebugEnabled()) {
             Log.debug("Starting LDAP search...");
             Log.debug("Using groupSearchFilter: "+searchFilter);
          }

          // Search for the dn based on the groupname.
          answer = ctx.search("",searchFilter,new SearchControls());

          if (manager.isDebugEnabled()) {
             Log.debug("... search finished");
             Log.debug("Starting to populate groups with users.");
          }
       }
       catch (Exception e)
       {
          if (manager.isDebugEnabled())
             Log.debug("Error while searching for groups.",e);
          return groups;
       }

       while (answer.hasMoreElements())
       {
          String groupName = "";
          try
          {
             Attributes a = (((SearchResult)answer.next()).getAttributes());
             String name = ((String)((a.get(manager.getNameField())).get()));
             groupName = name;
             String description;
             try
             {
                name = ((String)((a.get(manager.getNameField())).get()));
                description = ((String)((a.get(manager.getGroupDescriptionField())).get()));
             }
             catch (Exception e)
             {
                description = "";
             }
             ArrayList<String> members = new ArrayList<String>();
             Attribute member = a.get(manager.getGroupMemberField());
             NamingEnumeration ne = member.getAll();
             while (ne.hasMore())
             {
                String userName = (String)ne.next();
                if (!manager.getPosixEnabled())
                {   //userName is full dn if not posix
                    StringTokenizer st = new StringTokenizer(userName,",");
                    Attributes attrs = ctx.getAttributes(st.nextToken(), 
                                       new String[]{manager.getUsernameField()});
                    Attribute a1 = attrs.get(manager.getUsernameField());
                    if (a1 != null)
                       userName = (String)a1.get();
                }
                if (userName != null)
                {    
                    try
                    {
                        members.add(JID.escapeNode(userName));
                    }
                    catch (Exception e)
                    {
                        if (manager.isDebugEnabled())
                            Log.debug("Error loading user: "+userName,e);
                    }
                }
             }
             Group g = new Group(this,name,description,members,new ArrayList<String>());
             groups.add(g);
          }
          catch (Exception e)
          {
             if (manager.isDebugEnabled())
                Log.debug("Error while populating group, "+groupName+".",e);
          }
       }
       if (manager.isDebugEnabled())
          Log.debug("Finished populating group(s) with users.");

       try
       {
          ctx.close();
       }
       catch (Exception e) { }

       return groups;
    }
}