using System;

namespace Chernobyl.Switch
{
    /// <summary>
    /// Known as an "AND Gate" in boolean logic, this switch will fire the event
    /// <see cref="AndSwitch.SwitchedOn"/> when both <see cref="AndSwitch.Switch1(object, EventArgs)"/>
    /// and <see cref="AndSwitch.Switch2(object, EventArgs)"/> have been invoked.
    /// </summary>
    public class AndSwitch : ISwitch
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        public AndSwitch() {}

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="onSwitchHandlers">Methods to assign to the event 
        /// <see cref="AndSwitch.SwitchedOn"/>.</param>
        public AndSwitch(params EventHandler[] onSwitchHandlers)
        {
            foreach (EventHandler eh in onSwitchHandlers)
                SwitchedOn += eh;
        }

        /// <summary>
        /// An event handler that can be assigned to an event. When this method
        /// is invoked, it will invoke the <see cref="AndSwitch.SwitchedOn"/>
        /// event provided <see cref="AndSwitch.Switch2(object, EventArgs)"/> has been invoked
        /// as well.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The arguments for the event.</param>
        public void Switch1(object sender, EventArgs e)
        {
            Switches[0] = true;
            if(Switches[1] == true && SwitchedOn != null)
                SwitchedOn(this, e);
        }

        /// <summary>
        /// An event handler that can be assigned to an event. When this method
        /// is invoked, it will invoke the <see cref="AndSwitch.SwitchedOn"/>
        /// event provided <see cref="AndSwitch.Switch1(object, EventArgs)"/> has been invoked
        /// as well.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The argument for the event.</param>
        public void Switch2(object sender, EventArgs e)
        {
            Switches[1] = true;
            if(Switches[0] == true && SwitchedOn != null)
                SwitchedOn(this, e);
        }

        /// <summary>
        /// An event that is raised when both <see cref="AndSwitch.Switch1(object, EventArgs)"/>
        /// and <see cref="AndSwitch.Switch2(object, EventArgs)"/> have been invoked.
        /// </summary>
        public event EventHandler SwitchedOn;

        /// <summary>
        /// An event that is raised right after this switch has been switched 
        /// off (or reset).
        /// </summary>
        public event EventHandler SwitchedOff;

        /// <summary>
        /// Resets the switch to its original state or the its state after right
        /// after its creation.
        /// </summary>
        public void Reset()
        {
            Switches[0] = false;
            Switches[1] = false;

            if (SwitchedOff != null)
                SwitchedOff(this, EventArgs.Empty);
        }

        /// <summary>
        /// An event handler that can be assigned to an event. This event handler
        /// will reset the switch to its original state. It is exactly the same
        /// as calling ISwitch.Reset().
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The arguments to the event.</param>
        public void Reset(object sender, EventArgs e)
        {
            Reset();
        }

        /// <summary>
        /// The switches of this switch.
        /// </summary>
        bool[] Switches = new bool[2];
    }
}