package jpos.config.simple;

///////////////////////////////////////////////////////////////////////////////
//
// This software is provided "AS IS".  The JavaPOS working group (including
// each of the Corporate members, contributors and individuals)  MAKES NO
// REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE SOFTWARE,
// EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED 
// WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
// NON-INFRINGEMENT. The JavaPOS working group shall not be liable for
// any damages suffered as a result of using, modifying or distributing this
// software or its derivatives. Permission to use, copy, modify, and distribute
// the software and its documentation for any purpose is hereby granted. 
//
// The JavaPOS Config/Loader (aka JCL) is now under the CPL license, which 
// is an OSS Apache-like license.  The complete license is located at:
//    http://oss.software.ibm.com/developerworks/opensource/license-cpl.html
//
///////////////////////////////////////////////////////////////////////////////

import java.util.*;
import java.io.*;

import jpos.config.*;

import jpos.util.tracing.Tracer;
import jpos.util.tracing.TracerFactory;

/**
 * This is a simple implementation for the JposEntryRegistry using a Hashtable 
 * to collect the entries.  The entry's logicalName property value is used as 
 * the key to the table and the entry itself as the value
 * @since 0.1 (Philly 99 meeting)
 * @author E. Michael Maximilien (maxim@us.ibm.com)
 */
public class SimpleEntryRegistry extends Object implements JposEntryRegistry 
{
    /**
     * Default ctor
     * @deprecated no longer used, see the 1 argument ctor 
     * @since 0.1 (Philly 99 meeting)
     */
    public SimpleEntryRegistry() {}

    /**
     * One-argument constructor
     * @param populator the JposRegPopulator used by the registry
     * @since 1.2 (NY 2K meeting)
     */
    public SimpleEntryRegistry( JposRegPopulator populator ) 
    { regPopulator = populator; }

    //--------------------------------------------------------------------------
    // Public methods implementing the JposEntryRegistry interface
    //

    /**
     * @return true if there is an JposEntry with the specified logical name
     * @param logicalName the logical name for the service
     * @since 0.1 (Philly 99 meeting)
     */
    public boolean hasJposEntry( String logicalName ) 
    { return jposEntries.containsKey( logicalName ); }

    /**
     * @return an enumeration of JposEntry objects 
     * @since 0.1 (Philly 99 meeting)
     */
    public Enumeration getEntries() 
	{
		Vector vector = new Vector();
		Enumeration entries = jposEntries.elements(); 

		while( entries.hasMoreElements() )
			vector.addElement( entries.nextElement() );

		return vector.elements();
	}

    /**
     * @return the JposEntry for the logicalName specified
     * @param logicalName the logical name of the JposEntry to find
     * @since 0.1 (Philly 99 meeting)
     */
    public JposEntry getJposEntry( String logicalName ) 
    { return (JposEntry)jposEntries.get( logicalName ); }

    /**
     * Modify the JposEntry with logicalName with the new entry indicated
     * @param logicalName the JposEntry's logical name
     * @param newEntry the new JposEntry
     * @since 0.1 (Philly 99 meeting)
     */
    public void modifyJposEntry( String logicalName, JposEntry newEntry )
    {
        jposEntries.put( logicalName, newEntry ); 
        
		tracer.println( "Modified entry.logicalName = " + logicalName );                							    		                 

		fireJposEntryRegistryEventModified( new JposEntryRegistryEvent( 
											this, newEntry ) );
    }   

    /**
     * Add an JposEntry for the service with logical name specified
     * @param logicalName the logicalName of the service
     * @since 0.1 (Philly 99 meeting)
     */
    public void addJposEntry( String logicalName, JposEntry entry ) 
    { 
        jposEntries.put( logicalName, entry );
        		
		tracer.println( "Added entry.logicalName = " + logicalName );                							    		         

		fireJposEntryRegistryEventAdded( new JposEntryRegistryEvent( 
										 this, entry ) );
    }

    /**
     * Add an JposEntry for the service.  The logical name is obtained 
     * from the entry
	 * @param entry the JposEntry to add
	 * @see jpos.config.JposEntry#getLogicalName()
     * @since 1.3 (Washington DC 2001 meeting)
     */
    public void addJposEntry( JposEntry entry )
	{
		addJposEntry( entry.getLogicalName(), entry );
	}

    /**
     * Removes the specified JposEntry 
     * @param entry the entry to remove
     * @since 0.1 (Philly 99 meeting)
     */
    public void removeJposEntry( JposEntry entry ) 
    {
        Enumeration entries = jposEntries.elements();

        while( entries.hasMoreElements() )
        {
            JposEntry jposEntry = (JposEntry)entries.nextElement();

            if( jposEntry.hasPropertyWithName( JposEntry.
            								   LOGICAL_NAME_PROP_NAME ) )
            {
                JposEntry removedEntry = (JposEntry)jposEntries.
                remove( entry.getPropertyValue( JposEntry.
                							    LOGICAL_NAME_PROP_NAME ) );

		        tracer.println( "Removed entry.logicalName = " + 
                                entry.getLogicalName() );                							    
                							    
                fireJposEntryRegistryEventRemoved( new JposEntryRegistryEvent( 
                								   this, removedEntry ) );				
				
                return;
            }
        }
        
        tracer.println( "Could not find entry to remove entry.logicalName = " + 
                        entry.getLogicalName() );
    }

    /**
     * Removes the JposEntry with the logicalName specified 
     * @param logicalName the JposEntry's logical name
     * @since 0.1 (Philly 99 meeting)
     */
    public void removeJposEntry( String logicalName ) 
    {
        JposEntry entry = (JposEntry)jposEntries.get( logicalName );

        if( entry != null )
        {
            jposEntries.remove( logicalName ); 

            fireJposEntryRegistryEventRemoved( new JposEntryRegistryEvent( 
            								   this, entry ) );
        }
    }

    /**
     * Adds a new JposEntryRegistryListener to the list of listeners
     * @param l the JposEntryRegistryListener object
     * @since 0.1 (Philly 99 meeting)
     */
    public void addJposEntryRegistryListener( JposEntryRegistryListener l ) 
    { listeners.addElement( l ); }
                                    
    /**
     * Removes a new JposEntryRegistryListener to the list of listeners
     * @param l the JposEntryRegistryListener object
     * @since 0.1 (Philly 99 meeting)
     */
    public void removeJposEntryRegistryListener( JposEntryRegistryListener l ) 
    { listeners.removeElement( l ); }
   
    /**
     * Tell the JposEntryRegistry to save the current entries 
     * NOTE: the actual implementation will save it in dependent manner
     * @since 0.1 (Philly 99 meeting)
     * @throws java.lang.Exception if any error occurs while saving
     */
    public void save() throws Exception 
    { getRegPopulator().save( getEntries() ); }
    
    /**
     * Tell the JposEntryRegistry to save the current entries to the file 
     * specified.  Depending on the current JposEntryPopulator the file might
     * be an XML or serialized or other file.
     * @since 2.1.0
     * @throws java.lang.Exception if any error occurs while saving or if the
     * current populator does not support saving in a file
     */
    public void saveToFile( File file ) throws Exception
    { getRegPopulator().save( getEntries(), file.getCanonicalPath() ); }

    /**
     * @return the JposRegPopulator for this registry
     * @since 1.2 (NY 2K meeting)
     */
    public JposRegPopulator getRegPopulator() { return regPopulator; }

    /**
     * Loads the JposEntryRegistry using the current populator
     * NOTE: if no entries are found or an error occurs then the 
     * registry is empty
     * @since 1.2 (NY 2K meeting)
     */
    public void load() 
    { 
        getRegPopulator().load();
        jposEntries.clear();

        Enumeration entries = getRegPopulator().getEntries();

        while( entries.hasMoreElements() )
        {
            try
            {
                JposEntry jposEntry = (JposEntry)entries.nextElement();

                jposEntries.put( jposEntry.
                				 getPropertyValue( JposEntry.
                				 				   LOGICAL_NAME_PROP_NAME ),
				                                   jposEntry );
            }
            catch( Exception e ) { tracer.print( e ); }
        }

		loaded = true;
    }

	/**
	 * @return the current size of the registry 
	 * @since 1.3 (Tokyo 2001 meeting)
	 */
	public int getSize() { return jposEntries.size(); }

	/**
	 * @return true if the registry has already been loaded or false otherwise
	 * @since 1.3 (Washington DC 2001 meeting)
	 */
	public boolean isLoaded() { return loaded; }

	//-------------------------------------------------------------------------
	// Public methods
	//

	/**
	 * @return a String with a list of all logical name of entries in the registry
	 * as well as the registry size and populator name
	 */
	public String toString()
	{
		StringBuffer sb = new StringBuffer();

		sb.append( "<SimpleEntryRegistry>\n" );

		sb.append( "<size=\"" + getSize() + "\"\n/>" );
		sb.append( "<populatorUniqueId=\"" + getRegPopulator().
											 getUniqueId() + "\"\n/>" );
		sb.append( "numberOfListeners=\"" + listeners.size() + "\"\n/>" );

		sb.append( "<entries>\n" );

		Enumeration entries = getEntries();
		int count = 0;

		while( entries.hasMoreElements() )
		{
			sb.append( "<entry" + count + ".LogicalName=\"" + 
			           ( (JposEntry)entries.nextElement() ).
			           getLogicalName() + "\"\n/>" );
			count++;
		}

		sb.append( "</entries>\n" );

		sb.append( "</SimpleEntryRegistry>\n" );

		return sb.toString();
	}

    //-------------------------------------------------------------------------
    // Protected methods
    //

    /**
     * Fires a new JposEntryRegistry event when a new JposEntry is added
     * @param e the JposEntryRegistryEvent object to fire
     * @since 0.1 (Philly 99 meeting)
     */
    protected void fireJposEntryRegistryEventAdded( JposEntryRegistryEvent e )
    {
    	tracer.println( "fireJposEntryRegistryEventAdded: " + 
    	                "e.getJposEntry().logicalName = " + 
    	                e.getJposEntry().getLogicalName() );    	
    	
        Vector listenersClone = (Vector)listeners.clone();

        synchronized( listenersClone )
        {
            for( int i = 0; i < listenersClone.size(); ++i )
                ((JposEntryRegistryListener)listenersClone.elementAt( i ) ).
                jposEntryAdded( e );
        }
    }

    /**
     * Fires a new JposEntryRegistry event when a new JposEntry is added
     * @param e the JposEntryRegistryEvent object to fire
     * @since 0.1 (Philly 99 meeting)
     */
    protected void fireJposEntryRegistryEventRemoved( JposEntryRegistryEvent e )
    {
    	tracer.println( "fireJposEntryRegistryEventRemoved: " + 
    	                "e.getJposEntry().logicalName = " + 
    	                e.getJposEntry().getLogicalName() );
    	
        Vector listenersClone = (Vector)listeners.clone();

        synchronized( listenersClone )
        {
            for( int i = 0; i < listenersClone.size(); ++i )
                ((JposEntryRegistryListener)listenersClone.elementAt( i ) ).
                jposEntryRemoved( e );
        }
    }

    /**
     * Fires a new JposEntryRegistry event when a JposEntry is modified
     * @param e the JposEntryRegistryEvent object to fire
     * @since 0.1 (Philly 99 meeting)
     */
    protected void fireJposEntryRegistryEventModified( JposEntryRegistryEvent e )
    {
    	tracer.println( "fireJposEntryRegistryEventModified: " + 
    	                "e.getJposEntry().logicalName = " + 
    	                e.getJposEntry().getLogicalName() );    	
    	
        Vector listenersClone = (Vector)listeners.clone();

        synchronized( listenersClone )
        {
            for( int i = 0; i < listenersClone.size(); ++i )
                ((JposEntryRegistryListener)listenersClone.elementAt( i ) ).
                jposEntryModified( e );
        }
    }

    //--------------------------------------------------------------------------
    // Instance variables
    //

    public Hashtable jposEntries = new Hashtable();
    private Vector listeners = new Vector();
    private JposRegPopulator regPopulator = null;
	private boolean loaded = false;
	
	private Tracer tracer = TracerFactory.getInstance().
	                         createTracer( "SimpleEntryRegistry" );
}