package com.atlassian.plugin.event.impl;
   
   import com.atlassian.event.api.EventListener;
   import com.atlassian.event.api.EventPublisher;
   import com.atlassian.event.config.ListenerHandlersConfiguration;
   import com.atlassian.event.internal.AsynchronousAbleEventDispatcher;
   import com.atlassian.event.internal.EventExecutorFactoryImpl;
   import com.atlassian.event.internal.EventPublisherImpl;
   import com.atlassian.event.internal.EventThreadPoolConfigurationImpl;
  import com.atlassian.event.spi.EventDispatcher;
  import com.atlassian.event.spi.EventExecutorFactory;
  import com.atlassian.event.spi.ListenerHandler;
  import com.atlassian.plugin.event.NotificationException;
  import com.atlassian.plugin.event.PluginEventManager;
  import com.atlassian.plugin.scope.EverythingIsActiveScopeManager;
  import com.atlassian.plugin.scope.ScopeManager;
  
  import java.util.ArrayList;
  import java.util.List;
  
  import static com.atlassian.plugin.util.Assertions.notNull;
  
  /**
   * Simple, synchronous event manager that uses one or more method selectors to determine event listeners.
   * <p>
   * The default method selectors are {@link MethodNameListenerMethodSelector} and
   * {@link AnnotationListenerMethodSelector}.
   */
  public class DefaultPluginEventManager implements PluginEventManager {
      private final EventPublisher eventPublisher;
  
      public DefaultPluginEventManager() {
          this(defaultMethodSelectors());
      }
  
      /**
       * Uses the supplied selectors to determine listener methods.
       *
       * @param selectors used to determine which are listener methods
       */
      public DefaultPluginEventManager(final ListenerMethodSelector... selectors) {
          this(new EverythingIsActiveScopeManager(), selectors);
      }
  
      public DefaultPluginEventManager(ScopeManager scopeManager) {
          this(scopeManager, defaultMethodSelectors());
      }
  
      public DefaultPluginEventManager(ScopeManager scopeManager, final ListenerMethodSelector... selectors) {
          final ListenerHandlersConfiguration configuration = new ListenerHandlersConfiguration() {
              public List<ListenerHandler> getListenerHandlers() {
                  final List<ListenerHandler> handlers = new ArrayList<ListenerHandler>(selectors.length);
                  for (final ListenerMethodSelector selector : selectors) {
                      handlers.add(new MethodSelectorListenerHandler(selector));
                  }
                  return handlers;
              }
          };
  
          final EventExecutorFactory executorFactory = new EventExecutorFactoryImpl(new EventThreadPoolConfigurationImpl());
          final EventDispatcher eventDispatcher = new AsynchronousAbleEventDispatcher(executorFactory);
          eventPublisher = new EventPublisherImpl(eventDispatcher, configuration, scopeManager);
      }
  
      /**
       * Delegate all event publication to the supplied {@code EventPublisher}.
       */
      public DefaultPluginEventManager(final EventPublisher eventPublisher) {
          this.eventPublisher = notNull("eventPublisher", eventPublisher);
      }
  
      public void register(final Object listener) {
          eventPublisher.register(notNull("listener", listener));
      }
  
      public void unregister(final Object listener) {
          eventPublisher.unregister(notNull("listener", listener));
      }
  
      public void broadcast(final Object event) throws NotificationException {
          notNull("event", event);
          try {
              eventPublisher.publish(event);
          } catch (final RuntimeException e) {
              throw new NotificationException(e);
          }
      }
  
      public EventPublisher getEventPublisher() {
          return eventPublisher;
      }
  
      static ListenerMethodSelector[] defaultMethodSelectors() {
          final ListenerMethodSelector methodNames = new MethodNameListenerMethodSelector();
          final ListenerMethodSelector pluginEvent = new AnnotationListenerMethodSelector();
          final ListenerMethodSelector eventListener = new AnnotationListenerMethodSelector(EventListener.class);
          return new ListenerMethodSelector[]{methodNames, pluginEvent, eventListener};
      }
  }