/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.0 (the "NPL"); you may not use this file except in
 * compliance with the NPL.  You may obtain a copy of the NPL at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the NPL is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
 * for the specific language governing rights and limitations under the
 * NPL.
 *
 * The Initial Developer of this code under the NPL is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
 * Reserved.
 */
package netscape.ldap;

import java.util.*;
import java.io.*;
import netscape.ldap.*;
import netscape.ldap.client.*;
import netscape.ldap.util.*;
import java.util.zip.CRC32;

/**
 * <CODE>LDAPCache</CODE> is the class that represents an
 * in-memory cache that you can use to reduce the number of
 * search requests sent to the LDAP server.
 * <P>
 *
 * Each item in the cache represents a search request and
 * its results.  Each item is uniquely identified by the
 * search criteria, which includes:
 * <P>
 *
 * <UL>
 * <LI>the host name and port number of the LDAP server
 * <LI>the base DN of the search
 * <LI>the search filter
 * <LI>the scope of the search
 * <LI>the attributes to be returned in the search results
 * <LI>the DN used to authenticate the client when binding
 *     to the server
 * <LI>the LDAP v3 controls specified in the search request
 * </UL>
 * <P>
 *
 * After a search request is cached, the results of any
 * subsequent search requests using the same criteria are 8
 * read from the cache.  Note that if any part of the
 * criteria differs (for example, if a different DN is used
 * when binding to the server or if a different set of
 * attributes to be returned is specified), the search
 * request is sent to the server.
 * <P>
 *
 * When you create the cache, you specify the maximum amount
 * of time that an item can be kept in the cache.  When an
 * item's age exceeds that time limit, the item is removed
 * from the cache.
 * <P>
 *
 * The cache also has a maximum size that you specify when
 * creating the cache.  If adding a new item exceeds the
 * maximum size of the cache, the first entries in the cache
 * are removed to make enough space for the new item.
 * <P>
 *
 * Finally, when creating the cache, you can specify a list
 * of the base DNs in search requests that you want to cache.
 * For example, if you specify <CODE>o=Airius.com</CODE> as
 * a base DN to cache, your client caches search requests
 * where the base DN is <CODE>o=Airius.com</CODE>.
 * <P>
 *
 * To specify that you want to use a cache for a particular
 * LDAP session, call the <CODE>setCache</CODE> method of
 * the <CODE>LDAPConnection</CODE> object that you are
 * working with.
 * <P>
 *
 * All clones of an <CODE>LDAPConnection</CODE> object share
 * the same <CODE>LDAPCache</CODE> object.
 * <P>
 *
 * The <CODE>LDAPCache</CODE> class includes methods for
 * getting statistics (such as hit rates) from the cache and
 * for flushing entries from the cache.
 * <P>
 *
 * @see netscape.ldap.LDAPConnection#setCache(netscape.ldap.LDAPCache)
 * @see netscape.ldap.LDAPConnection#getCache
 */
public class LDAPCache implements TimerEventListener {
    private Hashtable m_cache;
    private long m_timeToLive;
    private long m_maxSize;
    private String[] m_dns;
    private Vector m_orderedStruct;
    private long m_remainingSize = 0;
    /**
     * Delimiter used internally when creating keys
     * for the cache.
     */
    public static final String DELIM = "#";
    private Timer m_timer = null;
    private static long TIMEOUT = 60000;
    private long m_totalOpers = 0;
    private static final boolean m_debug = false;
    private long m_hits = 0;
    private long m_flushes = 0;


    /**
     * Constructs a new <CODE>LDAPCache</CODE> object, using the
     * specified maximum size of the cache (in bytes) and the maximum
     * age of cached items (in seconds).  When items in the cache
     * exceed this age, they are removed from the cache.
     * <P>
     *
     * @param ttl The maximum amount of time that an item can be cached
     *  (in seconds)
     * @param size The maximum size of the cache (in bytes)
     */
    public LDAPCache(long ttl, long size)
    {
        init(ttl, size);
    }

    /**
     * Constructs a new <CODE>LDAPCache</CODE> object, using the
     * specified maximum size of the cache (in bytes), and the maximum
     * age of cached items (in seconds), and an array of  the base DNs
     * of searches that you want to cache.  (For example,
     * if the array of base DNs includes <CODE>o=Airius.com</CODE>,
     * the cache stores search results if the base DN in the search
     * request is <CODE>o=Airius.com</CODE>.)
     * <P>
     *
     * @param ttl The maximum amount of time that an item can be cached
     *  (in seconds)
     * @param size The maximum size of the cache (in bytes)
     * @param dns The list of base DNs of searches that you want to cache.
     */
    public LDAPCache(long ttl, long size, String[] dns)
    {
        init(ttl, size);

        m_dns = new String[dns.length];
        if ((dns != null) && (dns.length > 0))
            for (int i=0; i<dns.length; i++) {
                m_dns[i] = (new DN(dns[i])).toString();
        }
    }

    /**
     * Gets the maximum size of the cache (in bytes).
     * <P>
     *
     * @return The maximum size of the cache (in bytes)
     */
    public long getSize()
    {
        return m_maxSize;
    }

    /**
     * Gets the maximum age allowed for cached items (in
     * seconds).  (Items that exceed this age are
     * removed from the cache.)
     * <P>
     *
     * @return The maximum age of items in the cache (in
     *  seconds).
     */
    public long getTimeToLive()
    {
        return m_timeToLive/1000;
    }

    /**
     * Gets the array of base DNs of searches to be cached.
     * (Search requests with these base DNs are cached.)
     * <P>
     *
     * @return The array of base DNs.
     */
    public String[] getBaseDNs()
    {
        return m_dns;
    }

    /**
     * Flush the entries identified by DN and scope from the cache.
     * <P>
     *
     * @param dn The distinguished name (or base DN) of the entries
     *  to be removed from the cache. Use this parameter in conjunction
     *  with <CODE>scope</CODE> to identify the entries that you want
     *  removed from the cache.  If this parameter is <CODE>null</CODE>,
     *  the entire cache is flushed.
     * @param scope The scope identifying the entries that you want
     *  removed from the cache. The value of this parameter can be
     *  one of the following:
     *  <UL>
     *  <LI><CODE>LDAPv2.SCOPE_BASE</CODE> (to remove the entry identified
     *      by <CODE>dn</CODE>)
     *  <LI><CODE>LDAPv2.SCOPE_ONE</CODE> (to remove the entries that
     *      have <CODE>dn</CODE> as their parent entry)
     *  <LI><CODE>LDAPv2.SCOPE_SUB</CODE> (to remove the entries in the
     *      subtree under <CODE>dn</CODE> in the directory)
     *  </UL>
     * <P>
     * @return <CODE>true</CODE> if the entry is removed from the cache,
     *  or <CODE>false</CODE> if the entry is not removed.
     */
    public synchronized boolean flushEntries(String dn, int scope) {

        if (m_debug)
            System.out.println("DEBUG: User request for flushing entry: dn "+
            dn+" and scope "+scope);
        // if the dn is null, invalidate the whole cache
        if (dn == null)
        {
            // reclaim all the cache spaces
            m_remainingSize = m_maxSize;
            m_cache.clear();
            m_orderedStruct.removeAllElements();
            return true;
        }

        DN dn2 = new DN(dn);

        Enumeration e = m_cache.keys();

        while(e.hasMoreElements()) {
            Long key = (Long)e.nextElement();
            Vector val = (Vector)m_cache.get(key);

            int j=1;
            int size2=val.size();

            for (; j<size2; j++) {
                String d = ((LDAPEntry)val.elementAt(j)).getDN();
                DN dn1 = new DN(d);

                if (dn1.equals(dn2))
                    break;
                if (scope == LDAPConnection.SCOPE_ONE) {
                    DN parentDN1 = dn1.getParent();
                    if (parentDN1.equals(dn2)) {
                        break;
                    }
                }
                if ((scope == LDAPConnection.SCOPE_SUB) && (dn1.contains(dn2))) {
                    break;
                }
            }

            if (j < size2) {
                for (int k=0; k<m_orderedStruct.size(); k++) {
                    Vector v = (Vector)m_orderedStruct.elementAt(k);
                    if (key.equals((Long)v.elementAt(0))) {
                        m_orderedStruct.removeElementAt(k);
                        break;
                    }
                }
                m_cache.remove(key);
                if (m_debug)
                    System.out.println("DEBUG: Successfully removed entry ->"+key);

                return true;
            }
        }

        if (m_debug)
            System.out.println("DEBUG: The number of keys in the cache is "
            +m_cache.size());

        return false;
    }

    /**
     * Gets invoked when the timer expires.
     * @param e The timer event containing the timer itself.
     */
    public void timerExpired(TimerEvent e)
    {
        flushEntries();

        Timer t = (Timer)e.getSource();
        t.start();
    }

    /**
     * Gets the amount of available space (in bytes) left in the cache.
     * <P>
     *
     * @return The available space (in bytes) in the cache.
     */
    public long getAvailableSize() {
        return m_remainingSize;
    }

    /**
     * Gets the total number of requests for retrieving items from
     * the cache.  This includes both items successfully found in
     * the cache and items not found in the cache.
     * <P>
     *
     * @return The total number of requests for retrieving items from
     * the cache.
     */
    public long getTotalOperations() {
        return m_totalOpers;
    }

    /**
     * Gets the total number of requests which failed to find and
     * retrieve an item from the cache.
     * <P>
     *
     * @return The number of requests that did not find and retrieve
     *  an item in the cache.
     */
    public long getNumMisses() {
        return (m_totalOpers - m_hits);
    }

    /**
     * Gets the total number of requests which successfully found and
     * retrieved an item from the cache.
     * @return The number of requests that successfully found and
     *  retrieved an item from the cache.
     */
    public long getNumHits() {
        return m_hits;
    }

    /**
     * Gets the total number of entries that are flushed when timer expires
     *  and <CODE>flushEntries</CODE> is called.
     * <P>
     *
     * @return The total number of entries that are flushed when timer
     *  expires.
     */
    public long getNumFlushes() {
        return m_flushes;
    }

    /**
     * Create a key for a cache entry by concatenating all input parameters
     * @return The key for a cache entry
     * @exception LDAPException Thrown when failed to create key.
     */
    Long createKey(String host, int port, String baseDN, String filter,
      int scope, String[] attrs, String bindDN, LDAPSearchConstraints cons)
      throws LDAPException {

        DN dn = new DN(baseDN);
        baseDN = dn.toString();

        if (m_dns != null) {
            int i=0;
            for (; i<m_dns.length; i++) {
                if (baseDN.equals(m_dns[i]))
                    break;
            }

            if (i >= m_dns.length)
                throw new LDAPException(baseDN+" is not a cached base DN",
                LDAPException.OTHER);
        }

        String key = null;

        key = appendString(baseDN);
        key = key+appendString(scope);
        key = key+appendString(host);
        key = key+appendString(port);
        key = key+appendString(filter);
        key = key+appendString(attrs);
        key = key+appendString(bindDN);

        LDAPControl[] serverControls = null;
        LDAPControl[] clientControls = null;

        // get server and client controls
        if (cons != null)
        {
            serverControls = cons.getServerControls();
            clientControls = cons.getClientControls();
        }

        if ((serverControls != null) && (serverControls.length > 0))
        {
            String[] objID = new String[serverControls.length];

            for (int i=0; i<serverControls.length; i++) {
                long val = getCRC32(serverControls[i].getValue());
                objID[i] = new Long(val).toString();
            }
            key = key + appendString(objID);
        }
        else
            key = key+appendString(0);

        if ((clientControls != null) && (clientControls.length > 0))
        {
            String[] objID = new String[clientControls.length];

            for (int i=0; i<clientControls.length; i++) {
                long val = getCRC32(clientControls[i].getValue());
                objID[i] = new Long(val).toString();
            }
            key = key + appendString(objID);
        }
        else
            key = key+appendString(0);

        long val = getCRC32(key.getBytes());
        return new Long(val);
    }

    /**
     * Gets the cache entry based on the specified key.
     * @param key The key for the cache entry.
     * @return The cache entry
     */
    synchronized Object getEntry(Long key) {
        Object obj = null;

        obj = m_cache.get(key);
        m_totalOpers++;

        if (m_debug) {
            if (obj == null)
                System.out.println("DEBUG: Entry whose key -> "+key+
                    " not found in the cache.");
            else
                System.out.println("DEBUG: Entry whose key -> "+key+
                    " found in the cache.");
        }

        if (obj != null)
            m_hits++;


        return obj;
    }

    /**
     * Flush entries which stays longer or equal to the time-to-live.
     */
    synchronized void flushEntries()
    {
        Vector v = null;
        boolean delete = false;

        Date date = new Date();
        long currTime = date.getTime();

        m_flushes = 0;
        while(true) {
            if (m_orderedStruct.size() <= 0)
                break;

            v = (Vector)m_orderedStruct.firstElement();
            long diff = currTime-((Long)v.elementAt(1)).longValue();
            if (diff >= m_timeToLive) {
                Long key = (Long)v.elementAt(0);

                if (m_debug)
                    System.out.println("DEBUG: Timer flush entry whose key is "+key);

                Vector entry = (Vector)m_cache.remove(key);
                m_remainingSize = m_remainingSize + ((Long)entry.firstElement()).longValue();

                // always delete the first one
                m_orderedStruct.removeElementAt(0);

                m_flushes++;
            }
            else
            break;
        }

        if (m_debug)
            System.out.println("DEBUG: The number of keys in the cache is "
                +m_cache.size());
    }

    /**
     * Add the entry to the hashtable cache and to the vector respectively.
     * The vector is used to keep track of the order of the entries being added.
     * @param key The key for the cache entry.
     * @param value The cache entry being added to the cache for the specified
     *        key.
     * @exception LDAPException Get thrown when failed to add the entry.
     */
    synchronized void addEntry(Long key, Object value) throws LDAPException
    {
        // if entry exists, dont perform add operation
        if (m_cache.get(key) != null)
            return;

        Vector v = (Vector)value;

        // assume the size of the key is 4 bytes
        long size = ((Long)v.elementAt(0)).longValue()+4;

        if (size > m_maxSize) {
            throw new LDAPException("Failed to add an entry to the cache since the new entry exceeds the cache size", LDAPException.OTHER);
        }

        v.setElementAt(new Long(size), 0);

        // if the size of entry being added is bigger than the spare space in the
        // cache
        if (size > m_remainingSize) {
            while (true) {
                Vector element = (Vector)m_orderedStruct.firstElement();
                Long str = (Long)element.elementAt(0);
                Vector val = (Vector)m_cache.remove(str);
                if (m_debug)
                    System.out.println("DEBUG: The spare size of the cache is not big enough "+
                        "to hold the new entry, deleting the entry whose key -> "+str);

                // always remove the first one
                m_orderedStruct.removeElementAt(0);
                m_remainingSize = m_remainingSize +
                    ((Long)val.elementAt(0)).longValue();
                if (m_remainingSize >= size)
                    break;
            }
        }

        m_remainingSize = m_remainingSize - size;
        m_cache.put(key, v);
        Vector element = new Vector();
        element.addElement(key);
        Date date = new Date();
        element.addElement(new Long(date.getTime()));
        m_orderedStruct.addElement(element);

        if (m_debug)
        {
            System.out.println("DEBUG: Adding a new entry whose key -> "+key);
            System.out.println("DEBUG: The current number of keys in the cache "+
            m_cache.size());
        }
    }

    /**
     * Gets the number of entries being cached.
     * @return The number of entries being cached.
     */
    int size()
    {
        return m_cache.size();
    }

    /**
     * Clean up
     */
    void cleanup() {
        m_timer.stop();
    }

    /**
     * Initialize the instance variables.
     */
    private void init(long ttl, long size)
    {
        m_cache = new Hashtable();
        m_timeToLive = ttl*1000;
        m_maxSize = size;
        m_remainingSize = size;
        m_dns = null;
        m_orderedStruct = new Vector();
        m_timer = new Timer(TIMEOUT);
        m_timer.addTimerExpiredEventListener((TimerEventListener)this);
        m_timer.start();
    }

    /**
     * Concatenate the specified integer with the delimiter.
     * @param str The string which concatenate with the delimiter.
     * @return The concatenated string
     */
    private String appendString(String str) {
        if (str == null)
            return "null"+DELIM;
        else
            return str.trim()+DELIM;
    }

    /**
     * Concatenate the specified integer with the delimiter.
     * @param num The integer which concatenate with the delimiter.
     * @return The concatenated string
     */
    private String appendString(int num) {
        return num+DELIM;
    }

    /**
     * Concatenate the specified string array with the delimiter.
     * @param str A string array.
     * @return The concatenated string
     */
    private String appendString(String[] str) {

        if ((str == null) || (str.length < 1))
            return "0"+DELIM;
        else {
            sortStrings(str);

            String s = str.length+DELIM;
            for (int i=0; i<str.length; i++)
                s = s+str[i].trim()+DELIM;
            return s;
        }
    }

    /**
     * Sorts the array of strings using bubble sort.
     * @param str The array of string being sorted. The str parameter contains
     * the sorted result.
     */
    private void sortStrings(String[] str) {

        for (int i=0; i<str.length; i++)
            str[i] = str[i].trim();

        for (int i=0; i<str.length-1; i++)
            for (int j=i+1; j<str.length; j++)
            {
                if (str[i].compareTo(str[j]) > 0)
                {
                    String t = str[i];
                    str[i] = str[j];
                    str[j] = t;
                }
            }
    }

    /**
     * Create a 32 bits CRC from the given byte array.
     */
    private long getCRC32(byte[] barray) {
        CRC32 crcVal = new CRC32();
        crcVal.update(barray);
        return crcVal.getValue();
    }
}

/**
 * Represents a timer which will timeout for every certain interval. It
 * provides methods to start, stop, or restart timer. It also provides
 * methods to register/deregister the event listeners.
 */
class Timer {

    private long m_timeout;
    private Thread t = null;
    private TimerEventListener listener;
    protected TimerEventListener stopListener = null;

    /**
     * Constructor with the specified timout.
     * @param timeout The timeout value in milliseconds.
     */
    Timer(long timeout) {
        m_timeout = timeout;
    }

    /**
     * Start the timer.
     */
    void start() {
        TimerRunnable trun = new TimerRunnable(this);
        t = new Thread(trun);
        t.start();
    }

    /**
     * Suspend the timer.
     */
    void suspend() {
        t.suspend();
    }

    /**
     * Stop the timer.
     */
    void stop() {
        t.stop();
    }

    /**
     * Restart the timer.
     */
    void restart() {
        t.resume();
    }

    /**
     * Get the timeout value.
     * @return the timeout value.
     */
    long getTimeout() {
        return m_timeout;
    }

    /**
     * Notify the listener when the timer expires.
     */
    void fireExpiredEvent() {
        TimerEvent event;

        if (stopListener != null)
        {
            event = new TimerEvent(this);
            stopListener.timerExpired(event);
        }
    }

    /**
     * Add the listener to the queue who wants to be notified when the timer
     * expires.
     */
    void addTimerExpiredEventListener(TimerEventListener listener) {
        stopListener = listener;
    }

    /**
     * Remove the listener from the queue who will not get notified when the
     * timer expires.
     */
    void removeTimerExpiredEventListener(TimerEventListener listener) {
        stopListener = null;
    }
}

/**
 * Represents the starting point for the timer thread to execute.
 */
class TimerRunnable implements Runnable {
    Timer m_timer;

    /**
     * Constructor with the specified timer object.
     * @param t The timer
     */
    TimerRunnable(Timer t) {
        m_timer = t;
    }

    /**
     * The runnable waits until the timeout period has elapsed. It then notify
     * the registered listener who listens for the timeout event.
     */
    public void run() {

        synchronized(this) {
            try {
                this.wait(m_timer.getTimeout());
            } catch (InterruptedException e) {
                System.out.println("Timer get interrupted");
            }
        }

        m_timer.fireExpiredEvent();
    }
}

/**
 * Represents the timer event. When the timer expires, it will notify
 * all the registered listeners which receive the timer event. The
 * listener can retrieve the source of the event from the timer event.
 */
class TimerEvent extends EventObject {

    /**
     * Constructor with the specified source of the timer event.
     * @param source The source of the timer event.
     */
    TimerEvent(Object source) {
        super(source);
    }
}

/**
 * The timer client needs to implement this interface if it wants to
 * receive the timeout event.
 */
interface TimerEventListener extends EventListener {
    /**
     * Gets invoked when the timer expires.
     * @param timeout Timeout event contains the source of the event which is
     *        the timer.
     */
    void timerExpired(TimerEvent timeout);
}