package psl;
   
   import java.lang.management.ManagementFactory;
   import java.util.ArrayList;
   import java.util.Iterator;
   import java.util.LinkedList;
   import java.util.List;
   import java.util.concurrent.ThreadFactory;
   
  import javax.management.InstanceAlreadyExistsException;
  import javax.management.InstanceNotFoundException;
  import javax.management.MBeanRegistrationException;
  import javax.management.MBeanServer;
  import javax.management.MalformedObjectNameException;
  import javax.management.NotCompliantMBeanException;
  import javax.management.ObjectName;
  
  import ensure.Ensure;
  
  /**
   * Factory that creates dispatcher threads.
   */
  final class DispatcherThreadFactory implements ThreadFactory {
  	/**
  	 * Number of the next thread to create. Minimum value <code>1</code>.
  	 */
  	private int m_next_number;
  	
  	/**
  	 * Factory name. Never <code>null</code>.
  	 */
  	private String m_name;
  	
  	/**
  	 * The exception handler. Never <code>null</code>.
  	 */
  	private ExceptionHandler m_exception_handler;
  	
  	/**
  	 * Created threads. Never <code>null</code>.
  	 */
  	private List<DispatcherThread> m_created;
  	
  	/**
  	 * Name used for registering the MX bean. Never <code>null</code>
  	 */
  	private ObjectName m_mx_name;
  	
  	/**
  	 * Is the factory active?
  	 */
  	private boolean m_active;
  	
  	/**
  	 * Creates a thread factory with a name which will be used as a prefix
  	 * for new threads.
  	 * @param name the factory name, cannot be <code>null</code>
  	 * @param exception_handler the handler to receive exceptions, cannot
  	 * be <code>null</code>
  	 */
  	private DispatcherThreadFactory(String name,
  			ExceptionHandler exception_handler) {
  		Ensure.not_null(name, "name == null");
  		Ensure.not_null(exception_handler, "exception_handler == null");
  		
  		m_name = name;
  		m_next_number = 1;
  		m_exception_handler = exception_handler;
  		m_created = new LinkedList<>();
  		m_active = true;
  		
  		try {
  			m_mx_name = object_name(m_name);
  			DispatcherThreadFactoryMXBeanImpl mx =
  					new DispatcherThreadFactoryMXBeanImpl(this);
  			MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
  			mbs.registerMBean(mx, m_mx_name);
  		} catch (NotCompliantMBeanException | MBeanRegistrationException
  				| InstanceAlreadyExistsException e) {
  			Ensure.never_thrown(e);
  		}
  	}
  	
  	/**
  	 * Shuts down the factory.
  	 */
  	synchronized void shutdown() {
  		Ensure.is_true(m_active, "m_active == false");
  		
  		m_active = false;
  		m_created.clear();
  		
  		try {
  			MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
  			mbs.unregisterMBean(m_mx_name);
  		} catch (InstanceNotFoundException | MBeanRegistrationException e) {
  			Ensure.never_thrown(e);
  		}
  	}
 	
 	/**
 	 * Obtains the MX object name for a factory with the given name.
 	 * @param factory_name the factory name, cannot be <code>null</code>
 	 * @return the object name
 	 */
 	public static ObjectName object_name(String factory_name) {
 		Ensure.not_null(factory_name, "factory_name == null");
 		
 		try {
 			return new ObjectName(DispatcherThreadFactory.class.getName()
 					+ ":name=" + factory_name + ",info=factory");
 		} catch (MalformedObjectNameException e) {
 			return Ensure.never_thrown(e);
 		}
 	}
 	
 	/**
 	 * Creates a new dispatcher thread factory.
 	 * @param name the factory name, cannot be <code>null</code>
 	 * @param exception_handler the handler to receive exceptions, cannot
 	 * be <code>null</code>
 	 * @return the thread factory
 	 */
 	public static DispatcherThreadFactory make(String name,
 			ExceptionHandler exception_handler) {
 		Ensure.not_null(name, "name == null");
 		Ensure.not_null(exception_handler, "exception_handler == null");
 		
 		DispatcherThreadFactory factory = new DispatcherThreadFactory(name,
 				exception_handler);
 		return factory;
 	}
 	
 	@Override
 	public synchronized Thread newThread(Runnable r) {
 		Ensure.not_null(r, "r == null");
 		Ensure.is_true(m_active, "m_active == false");
 		
 		DispatcherThread t = DispatcherThread.make(r, m_name,
 				m_next_number, m_exception_handler);
 		m_next_number++;
 		clear_terminated();
 		m_created.add(t);
 		return t;
 	}
 	
 	/**
 	 * Obtains all threads created that are still alive.
 	 * @return all threads
 	 */
 	public synchronized List<DispatcherThread> threads() {
 		Ensure.is_true(m_active, "m_active == false");
 		
 		clear_terminated();
 		List<DispatcherThread> all = new ArrayList<>(m_created);
 		return all;
 	}
 	
 	/**
 	 * Clears all terminated threads from {@link #m_created}.
 	 */
 	private void clear_terminated() {
 		Iterator<DispatcherThread> it = m_created.iterator();
 		while (it.hasNext()) {
 			DispatcherThread dt = it.next();
 			if (dt.done()) {
 				it.remove();
 			}
 		}
 	}
 	
 	/**
 	 * Obtains the factory name.
 	 * @return the factory name
 	 */
 	public String name() {
 		return m_name;
 	}
 	
 	/**
 	 * Obtains the thread count.
 	 * @return the thread count
 	 */
 	public synchronized int thread_count() {
 		clear_terminated();
 		return m_created.size();
 	}
 }