using System;

namespace Chernobyl.Event
{
    /// <summary>
    /// An interface for working with types that can block invocation of events 
    /// from passing threw them based on some predicate. To use, just assign
    /// <see cref="Enter"/> to the event that could be blocked and then assign
    /// the other event handlers to <see cref="Exit"/>.
    /// </summary>
    /// <typeparam name="TEventArgs">The <see cref="EventArgs"/> type that is
    /// generated from the invocation of the event that may be blocked.</typeparam>
    public interface IEventPredicate<TEventArgs> where TEventArgs : EventArgs
    {
        /// <summary>
        /// An event handler that can be assigned to an event. This method will
        /// invoke <see cref="Exit"/> if the internal predicate is true. If it
        /// is false, the <see cref="Exit"/> event will not be invoked. If
        /// <see cref="Exit"/> is invoked, <paramref name="e"/> will be passed
        /// through <see cref="Exit"/>.
        /// </summary>
        /// <param name="sender">The instance that generated the event.</param>
        /// <param name="e">The <typeparamref name="TEventArgs"/>  instance 
        /// containing the event data.</param>
        void Enter(object sender, TEventArgs e);

        /// <summary>
        /// The event that will be invoked if the 
        /// <see cref="Enter(object, TEventArgs)"/> is invoked and the internal
        /// predicate resolves to true. The <typeparamref name="TEventArgs"/> 
        /// instance that is passed along with this event is the same 
        /// <typeparamref name="TEventArgs"/> that was passed to
        /// <see cref="Enter"/>.
        /// </summary>
        event EventHandler<TEventArgs> Exit;
    }
}