using System;
using System.Timers;

namespace Chernobyl.Switch
{
    /// <summary>
    /// An <see cref="ISwitch"/> that repeatedly invokes an event when it is on 
    /// and stops invoking that event when it is off. This class is similar to  
    /// the <see cref="Timer"/> class but this class has event handler methods  
    /// that can be assigned to events.
    /// </summary>
    public class Repeater : ISwitch
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Repeater"/> class.
        /// </summary>
        /// <param name="repeatRateInMilliseconds">The rate, in milliseconds, 
        /// at which the <see cref="Elapsed"/> event will be fired.</param>
        public Repeater(int repeatRateInMilliseconds)
        {
            RepeatRateInMilliseconds = repeatRateInMilliseconds;
        }

        /// <summary>
        /// An event that is raised at the rate specified by 
        /// <see cref="RepeatRateInMilliseconds"/>. The invocation only happens 
        /// if one of the Start methods has been called (<see cref="Start()"/> 
        /// and <see cref="Start(object, EventArgs)"/>).
        /// </summary>
        public event EventHandler Elapsed;

        /// <summary>
        /// Starts the repeated invoking of the <see cref="Elapsed"/> event at 
        /// the repeat rate specified by <see cref="RepeatRateInMilliseconds"/>.
        /// </summary>
        public void Start()
        {
            if(Timer.Enabled != true)
            {
                Timer.Start();

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

        /// <summary>
        /// An event handler that can be assigned to an event. When invoked, 
        /// this method does the same thing as <see cref="Start()"/>.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="System.EventArgs"/> instance 
        /// containing the event data.</param>
        public void Start(object sender, EventArgs e)
        {
            Start();
        }

        /// <summary>
        /// Stops the repeated invoking of the <see cref="Elapsed"/> event.
        /// </summary>
        public void Stop()
        {
            if(Timer.Enabled != false)
            {
                Timer.Stop();

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

        /// <summary>
        /// An event handler that can be assigned to an event. When invoked, 
        /// this method does the same thing as <see cref="Stop()"/>.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="System.EventArgs"/> instance 
        /// containing the event data.</param>
        public void Stop(object sender, EventArgs e)
        {
            Stop();
        }

        /// <summary>
        /// An event that is raised when this switch has been started.
        /// </summary>
        public event EventHandler SwitchedOn;

        /// <summary>
        /// An event that is raised right after this switch has been stopped.
        /// </summary>
        public event EventHandler SwitchedOff;

        /// <summary>
        /// Resets the switch to its original state or the its state after right
        /// after its creation. Calling this method is the same as calling 
        /// <see cref="Stop()"/>
        /// </summary>
        public void Reset()
        {
            Stop();
        }

        /// <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 <see cref="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 rate, in milliseconds, at which the  <see cref="Elapsed"/> event 
        /// will be fired.
        /// </summary>
        public int RepeatRateInMilliseconds
        {
            get { return _RepeatRateInMilliseconds; }
            set
            {
                _RepeatRateInMilliseconds = value;

                bool enabled = false;
                if (Timer != null)
                {
                    enabled = Timer.Enabled;
                    Timer.Elapsed -= Timer_Elapsed;
                }

                Timer = new Timer(_RepeatRateInMilliseconds);
                Timer.Elapsed += Timer_Elapsed;

                if(enabled == true)
                    Timer.Start();
            }
        }

        /// <summary>
        /// Handles the Elapsed event of the Timer control. This method invokes 
        /// the <see cref="Elapsed"/> event on this class.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Timers.ElapsedEventArgs"/> 
        /// instance containing the event data.</param>
        void Timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            if (Elapsed != null)
                Elapsed(this, e);
        }

        /// <summary>
        /// The <see cref="Timer"/> which is used to invoke the <see cref="Elapsed"/> 
        /// event at a specified rate.
        /// </summary>
        Timer Timer { get; set; }

        /// <summary>
        /// The backing field to <see cref="RepeatRateInMilliseconds"/>
        /// </summary>
        int _RepeatRateInMilliseconds;
    }
}