/*
    ~ Copyright 2006-2007 Nicolas De Loof.
    ~
    ~ Licensed under the Apache License, Version 2.0 (the "License");
    ~ you may not use this file except in compliance with the License.
    ~ You may obtain a copy of the License at
    ~
    ~      http://www.apache.org/licenses/LICENSE-2.0
    ~
   ~ Unless required by applicable law or agreed to in writing, software
   ~ distributed under the License is distributed on an "AS IS" BASIS,
   ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   ~ See the License for the specific language governing permissions and
   ~ limitations under the License.
   */
  package org.jmonit.monitors;
  
  import java.util.Collections;
  import java.util.Set;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.ConcurrentMap;
  import java.util.concurrent.CopyOnWriteArraySet;
  
  import org.jmonit.Monitor;
  import org.jmonit.events.DataMonitoredEvent;
  import org.jmonit.events.DefaultMonitoringEventBus;
  import org.jmonit.events.MonitoringEvent;
  import org.jmonit.events.MonitoringEventBus;
  import org.jmonit.events.MonitoringEventListener;
  import org.jmonit.spi.Plugin;
  
  /**
   * A Monitor implementation that delegates to multiple monitors. Each monitor in
   * the composite has a ROLE and can retrieve other monitors from the composite
   * based on it. By convention, defaults monitors are registered using class name
   * as role (or public interface class name)
   * 
   * @author <a href="mailto:nicolas.deloof@gmail.com">Nicolas De Loof</a>
   */
  public abstract class AbstractMonitor
      implements Monitor, MonitoringEventBus
  {
      protected String name;
  
      protected Set<String> tags = new CopyOnWriteArraySet<String>();
  
      /**
       * Components of the composite, with public "feature" API class name as key
       */
      protected ConcurrentMap<Class<?>, Plugin> components =
          new ConcurrentHashMap<Class<?>, Plugin>();
  
      public AbstractMonitor( String name )
      {
          super();
          this.name = name;
      }
  
      /**
       * {@inheritDoc}
       * 
       * @see org.jmonit.Monitor#add(long)
       */
      public void add( long value )
      {
          DataMonitoredEvent event = new DataMonitoredEvent( value );
          bus.fireMonitoringEvent( event );
      }
  
      /**
       * {@inheritDoc}
       * 
       * @see org.jmonit.Monitor#fireEvent(MonitoringEvent)
       */
      public void fireMonitoringEvent( MonitoringEvent event )
      {
          bus.fireMonitoringEvent( event );
      }
  
      /**
       * {@inheritDoc}
       * 
       * @see org.jmonit.Monitor#clear()
       */
      public void clear()
      {
          // fireEvent( new RefreshEvent() );
      }
  
      public Plugin get( Class role )
      {
          if ( role == null )
          {
              return null;
          }
          return components.get( role );
      }
  
      public boolean isFeatureSupported( Class clazz )
     {
         return hasFeatures( new Class[] { clazz } );
     }
 
     /**
      * {@inheritDoc}
      * 
      * @see org.jmonit.Monitor#hasFeatures(java.lang.Class[])
      */
     public boolean hasFeatures( Class[] features )
     {
         for ( Class feature : features )
         {
             if ( !components.containsKey( feature ) )
             {
                 return false;
             }
         }
         return true;
     }
 
     /**
      * {@inheritDoc}
      * 
      * @see org.jmonit.Monitor#getFeature(Class)
      */
     public <T> T getFeature( Class<T> clazz )
     {
         Plugin<T> feature = components.get( clazz );
         if ( feature != null )
         {
             return feature.getFeature();
         }
         return null;
     }
 
     /**
      * {@inheritDoc}
      * 
      * @see org.jmonit.Monitor#getFeatures()
      */
     public Set<Class> getFeatures()
     {
         return Collections.<Class> unmodifiableSet( components.keySet() );
     }
 
     public void register( Plugin plugin, Class role )
     {
         plugin.setMonitoringEventBus( bus );
         plugin.setMonitor( this );
         components.putIfAbsent( role, plugin );
     }
 
     public void remove( Class role )
     {
         components.remove( role );
     }
 
     /**
      * @return the name
      */
     public String getName()
     {
         return name;
     }
 
     /**
      * {@inheritDoc}
      * 
      * @see org.jmonit.Monitor#getTags()
      */
     public Set<String> getTags()
     {
         return Collections.unmodifiableSet( tags );
     }
 
     /**
      * {@inheritDoc}
      * 
      * @see org.jmonit.Monitor#isTagged(java.lang.String)
      */
     public boolean isTagged( String tag )
     {
         return tags.contains( tag );
     }
 
     /**
      * {@inheritDoc}
      * 
      * @see org.jmonit.Monitor#tag(java.lang.String)
      */
     public Monitor tag( String tag )
     {
         boolean added = tags.add( tag );
         if ( added )
         {
             onMonitorTaggedEvent( tag );
         }
         return this;
     }
 
     /**
      * @param tag
      */
     protected abstract void onMonitorTaggedEvent( String tag );
 
     /**
      * Event bus for MonitoringEvents related to this monitor
      */
     private DefaultMonitoringEventBus bus = new DefaultMonitoringEventBus();
 
     public void addListener( MonitoringEventListener listener )
     {
         bus.addListener( listener );
     }
 
     public boolean hasListener( MonitoringEventListener listener )
     {
         return bus.hasListener( listener );
     }
 
     public void removeListener( MonitoringEventListener listener )
     {
         bus.removeListener( listener );
     }
 
 }