package org.sadun.util.polling;

import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.StringTokenizer;

import javax.management.InstanceNotFoundException;
import javax.management.ListenerNotFoundException;
import javax.management.MBeanException;
import javax.management.MBeanNotificationInfo;
import javax.management.MBeanRegistration;
import javax.management.MBeanServer;
import javax.management.MBeanServerFactory;
import javax.management.Notification;
import javax.management.NotificationBroadcaster;
import javax.management.NotificationFilter;
import javax.management.NotificationListener;
import javax.management.ObjectName;

import org.sadun.util.RegexpFilenameFilter;

/**
 * A JMX managed subclass of directory poller, exposing the
 * {@link ManagedDirectoryPollerMBean ManagedDirectoryPollerMBean}
 * interface.
 * <p>
 * From v1.5, JMX notifications are also emitted together with the 
 * existing {@link org.sadun.util.polling.BasePollerEvent events}. 
 * <p>
 * One or more listeners may be registered to the Poller, allowing MBeans in 
 * @author cris
 */
public class ManagedDirectoryPoller
    extends DirectoryPoller
	implements ManagedDirectoryPollerMBean, MBeanRegistration, NotificationListener, NotificationBroadcaster  {
	
	/**
	 * The thread in which the {@link DirectoryPoller DirectoryPoller}
	 * is actually run.
	 */	
	private Thread managedThread;
	
	private boolean usingJMXTimer;
	
	private String JMXTimerObjectName;
	
	/**
	 * The MBean name, as notified in preRegister();
	 */
	private ObjectName pollerMBeanName;
	
    /**
	 * If JMX timing is used, there's no real thread running - the
	 * cycles are triggered by receiving timer events.
	 * <p>
	 * In that case, "running" just means "listening to timing events"
	 */
	private boolean isListeningToTimingEvents;
	
	/**
	 * The poll manager factory class name, if any
	 */
	private String pollManagerFactoryClsName;

	
	/**
	 * The poll manager factory instance, if any
	 */
	private PollManagerFactory pollManagerFactory;

	
	/**
	 * The filename filter factory class name, if any
	 */
	private String filenameFilterFactoryClsName;
	
	
	/**
	 * The filename filter factory instance, if any
	 */
	private FilenameFilterFactory filenameFilterFactory;

	private String currentPattern;
	
    
    /**
     * The sequence number generator for JMX events.
     */
    private SequenceNumberGenerator sqg;
    
    /**
     * The sequence number generator for JMX events.
     */
    private String JMXsequenceNumberGeneratorClass = CoreSequenceNumberGenerator.class.getName();
    
    private JMXNotificationsPollManager jmxNotificationsPollManager;
    
	/**
	 * Constructor for ManagedDirectoryPoller.
	 * @param dirs
	 * @param filter
	 */
	public ManagedDirectoryPoller(File[] dirs, FilenameFilter filter) {
		super(dirs, filter);
	}

	/**
	 * Constructor for ManagedDirectoryPoller.
	 * @param dirs
	 */
	public ManagedDirectoryPoller(File[] dirs) {
		super(dirs);
	}

	/**
	 * Constructor for ManagedDirectoryPoller.
	 * @param directory
	 * @param filter
	 */
	public ManagedDirectoryPoller(File directory, FilenameFilter filter) {
		super(directory, filter);
	}

	/**
	 * Constructor for ManagedDirectoryPoller.
	 * @param directory
	 */
	public ManagedDirectoryPoller(File directory) {
		super(directory);
	}

	/**
	 * Constructor for ManagedDirectoryPoller.
	 * @param filter
	 */
	public ManagedDirectoryPoller(FilenameFilter filter) {
		super(filter);
	}

	/**
	 * Constructor for ManagedDirectoryPoller.
	 */
	public ManagedDirectoryPoller() {
		super();
	}

	/**
	 * Constructor for ManagedDirectoryPoller.
	 * @param dirs
	 * @param filter
	 * @param timeBased
	 */
	public ManagedDirectoryPoller(
		File[] dirs,
		FilenameFilter filter,
		boolean timeBased) {
		super(dirs, filter, timeBased);
	}

	/**
	 * Constructor for ManagedDirectoryPoller.
	 * @param directory
	 * @param filter
	 * @param timeBased
	 */
	public ManagedDirectoryPoller(
		File directory,
		FilenameFilter filter,
		boolean timeBased) {
		super(directory, filter, timeBased);
	}

	/**
	 * Constructor for ManagedDirectoryPoller.
	 * @param filter
	 * @param timeBased
	 */
	public ManagedDirectoryPoller(FilenameFilter filter, boolean timeBased) {
		super(filter, timeBased);
	}

	/**
	 * @see javax.management.MBeanRegistration#postDeregister()
	 */
	public void postDeregister() {
	}

	/**
	 * @see javax.management.MBeanRegistration#postRegister(java.lang.Boolean)
	 */
	public void postRegister(Boolean registrationDone) {
        try {
            sqg =(SequenceNumberGenerator)Class.forName(JMXsequenceNumberGeneratorClass).newInstance();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally  {
            // Ensure we have a valid sqg
            if (sqg==null) {
                sqg=new CoreSequenceNumberGenerator();
                JMXsequenceNumberGeneratorClass=CoreSequenceNumberGenerator.class.getName();
            }
        }
        
        // Set up the pollmanager in charge of JMX event notifications
        //System.out.println("Adding JMX notifications pollmanager");
        jmxNotificationsPollManager = new JMXNotificationsPollManager(pollerMBeanName, sqg);
        addPollManager(jmxNotificationsPollManager);
	}

	/**
	 * @see javax.management.MBeanRegistration#preDeregister()
	 */
	public void preDeregister() throws Exception {
		if (isAlive()) shutdown();
	}

	/**
	 * @see javax.management.MBeanRegistration#preRegister(javax.management.MBeanServer, javax.management.ObjectName)
	 */
	public ObjectName preRegister(MBeanServer server, ObjectName name)
		throws Exception {
		pollerMBeanName=name;
		return name;
	}

	/**
	 * Starts a thread for the poller
	 * @see java.lang.Runnable#run()
	 */ 
	public void startUp() {
		if (getDirectories().length==0) 
			throw new IllegalStateException("No directories to poll");
		if (managedThread != null) 
			throw new IllegalStateException("the directory poller is already running");
			
		if (usingJMXTimer) {
			isListeningToTimingEvents=true;
		} else {	
			managedThread = new Thread(this, "Managed directory poller");
			managedThread.setDaemon(true);
			managedThread.start();
		}
	}	
	
	public void shutDown() {
		if (usingJMXTimer) {
			isListeningToTimingEvents=false;
		} else {	
			if (managedThread==null) 
				throw new IllegalStateException("Directory poller is not started");
			super.shutdown();
			managedThread=null;
		}
	}
	
	public String getAutoMoveDirectoryPath(String directory) {
		if(directory==null)
			throw new IllegalArgumentException("No directory specified");
		if("".equals(directory.trim()))
			throw new IllegalArgumentException("No directory specified");	
		try {
			return this.getAutoMoveDirectory(new File(directory)).getCanonicalPath();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}
	
    /**
	 * Remove one directory from the controlled set. It can be called
     * only if the poller thread hasn't started yet.
	 * @param dir the directory to remove 
	 * @exception IllegalStateException if the poller has already started.
     * @exception IllegalArgumentException if the directory is not among the controlled ones
	 */    
    public void removeControlledDirectory(String dir) {
	    	super.removeDirectory(new File(dir));
    }
     
   	/**
	 * Add one directory to the controlled set. It can be called
     * only if the poller thread hasn't started yet.
	 * @param dir the directory to add
	 * @exception IllegalStateException if the poller has already started.
     * @exception IllegalArgumentException if String does not contain a directory path
	 */    
    public void addControlledDirectory(String dir) {
    	super.addDirectory(new File(dir));
    }
	
	/**
	 * @see org.sadun.util.polling.ManagedDirectoryPollerMBean#countControlledDirectories()
	 */
	public int countControlledDirectories() {
		return getDirectories().length;
	}
	
	public boolean isRunning() {
		if (managedThread==null) return false;
		if (usingJMXTimer) return isListeningToTimingEvents;
		return managedThread.isAlive();
	}
	
	/**
	 * @see org.sadun.util.polling.ManagedDirectoryPollerMBean#getControlledDirectory(int)
	 */
	public String getControlledDirectory(int i) {
		if (i < 0 || i >= getDirectories().length) 
			throw new IllegalArgumentException("Index out of range");
		try {
			return getDirectories()[i].getCanonicalPath();
		} catch(IOException e) {
			throw new RuntimeException(e);
		}
	}
	
	public void setBaseTime(String directory, long time) {
		File dir = new File(directory);
		super.setBaseTime(dir, time);
	}
	
	public long getBaseTime(String directory) {
		File dir = new File(directory);
		return super.getBaseTime(dir);
	}
	
	public String listControlledDirectories() {
		StringWriter sw=new StringWriter();
		PrintWriter pw = new PrintWriter(sw);
		File [] dirs = getDirectories();
		pw.println("Total of "+dirs.length+" controlled directories");
		pw.println();
		for(int i=0;i<dirs.length;i++) {
			pw.print("["+i+"] ");
			pw.println(dirs[i]);
		}
		return sw.toString();
	}
	
	public String getControlledDirectories() {
		StringWriter sw=new StringWriter();
		PrintWriter pw = new PrintWriter(sw);
		File [] dirs = getDirectories();
		for(int i=0;i<dirs.length;i++) {
			pw.print(dirs[i]);
			if (i<dirs.length-1) pw.print(",");
		}
		return sw.toString();
	}
	
	public void setControlledDirectories(String dirList) {
		StringTokenizer st = new StringTokenizer(dirList,",");
		while(st.hasMoreTokens()) {
			addControlledDirectory(st.nextToken());
		}
	}
	
	public String listInstalledPollManagers() {
		if (pollManagersList.size()==0)
			return "No poll managers installed";
		StringWriter sw=new StringWriter();
		PrintWriter pw = new PrintWriter(sw);
		for(Iterator i=pollManagersList.iterator();i.hasNext();) {
		 	PollManager pm = (PollManager)i.next();
            // Hide the JMX notification pollmanager
            if (pm instanceof JMXNotificationsPollManager) continue;
		 	pw.println(pm.toString());
		}
		return sw.toString();
	}