using System;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.DesignPatterns.Extension;
using Chernobyl.Interface.Input;
using Chernobyl.Mathematics.Collision;
using Chernobyl.Mathematics.Geometry;
using Chernobyl.Mathematics.Movement;
using Chernobyl.StateMachine;

namespace Chernobyl.Interface.Tool
{
    /// <summary>
    /// An extension that attaches to a <see cref="ICollidable2D"/> instance
    /// and invokes the event <see cref="PressedDown"/> when this collidable is
    /// collided against and a button is pressed and invokes the event 
    /// <see cref="LetUp"/> when this collidable is collided against and a 
    /// button is let up.
    /// </summary>
    public class ClickableRegion : Extension<IExtendedCollidable<Point2D>>, IPointerControl, IEnableable
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ClickableRegion"/> class.
        /// </summary>
        /// <param name="services">The instance that gives out services for use 
        /// by this type and takes services from this type for use by other 
        /// systems.</param>
        public ClickableRegion(IEventCollection<object> services)
            : this(services, null)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="ClickableRegion"/> class.
        /// </summary>
        /// <param name="services">The instance that gives out services for use 
        /// by this type and takes services from this type for use by other 
        /// systems.</param>
        /// <param name="control">The control that will be doing the
        /// clicking of the <see cref="ICollidable2D"/> or null if a default
        /// control is to be retrieved from <paramref name="services"/>.</param>
        public ClickableRegion(IEventCollection<object> services, IPointerControl control)
            : this(services, control, null)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="ClickableRegion"/> class.
        /// </summary>
        /// <param name="services">The instance that gives out services for use 
        /// by this type and takes services from this type for use by other 
        /// systems.</param>
        /// <param name="control">The control that will be doing the
        /// clicking of the <see cref="ICollidable2D"/> or null if a default
        /// control is to be retrieved from <paramref name="services"/>.</param>
        /// <param name="extended">The <see cref="ICollidable2D"/> instance to
        /// extend or null if the <see cref="Extension{TExtended}.Extended"/>
        /// property will be set later.</param>
        public ClickableRegion(IEventCollection<object> services, IPointerControl control, ICollidable2D extended)
        {
            Enabled = new State();
            Enabled.ParentState = new State();
            Enabled.Entered += (sender, args) => Configure(_control);
            Enabled.Left += (sender, args) => Unconfigure(_control);

            if (control != null)
                Control = control;
            else
                services.OfType<PointerControlCollection>(service => Control = service);

            Extended = extended;
        }

        /// <summary>
        /// Attaches to an <see cref="ICollidable2D"/> so that, when the 
        /// <see cref="Button"/> is pressed and the <paramref name="extended"/>
        /// collidable is collided with, the event <see cref="PressedDown"/> 
        /// is invoked. when the <see cref="Button"/> is let up and the 
        /// <paramref name="extended"/> collidable is collided with, the event 
        /// <see cref="LetUp"/> is invoked
        /// </summary>
        /// <param name="extended">The <see cref="ICollidable2D"/> that will be
        /// interacting with the cursor.</param>
        protected override void AttachTo(IExtendedCollidable<Point2D> extended)
        {
            extended.Extensions.Add(this);
        }

        /// <summary>
        /// Detaches from the <see cref="ICollidable2D"/> so that the
        /// <see cref="PressedDown"/> or <see cref="LetUp"/> events are no longer 
        /// invoked when this collidable is collided with.
        /// </summary>
        /// <param name="extended">The <see cref="ICollidable2D"/> that was 
        /// previously attached to that should now be detached from.</param>
        protected override void DetachFrom(IExtendedCollidable<Point2D> extended)
        {
            extended.Extensions.Remove(this);
        }

        /// <summary>
        /// An event that is raised when the collidable has collided with an
        /// object and the primary button is pushed down.
        /// </summary>
        public event EventHandler<PointerEventArgs> PressedDown;

        /// <summary>
        /// An event that is raised when the collidable has collided with an
        /// object and the primary button is let up.
        /// </summary>
        public event EventHandler<PointerEventArgs> LetUp;

        /// <summary>
        /// Active if the functionality of the object is enabled, inactive if
        /// otherwise.
        /// </summary>
        public IState Enabled { get; private set; }

        /// <summary>
        /// The control which will be doing the clicking.
        /// </summary>
        public IPointerControl Control
        {
            get { return _control; }
            private set
            {
                IPointerControl previousValue = _control;
                _control = value;

                // We won't need to do the unconfiguration/configuring of the
                // controls if we've been disabled since the previous control
                // will have already been disabled and the new control will be
                // configured once this region is re-enabled.
                if (Enabled.IsActive())
                {
                    if (previousValue != null)
                        Unconfigure(previousValue);

                    // Start listening
                    if (_control != null)
                        Configure(_control);   
                }
            }
        }

        /// <summary>
        /// An event handler that is invoked by the 
        /// <see cref="IPointerControl.PressedDown"/> event of the 
        /// <see cref="Control"/> instance. This method checks if this instance
        /// <see cref="PressedDown"/> event should be invoked.
        /// </summary>
        /// <param name="sender">The instance that generated the event.</param>
        /// <param name="e">The <see cref="PointerEventArgs"/> instance containing 
        /// the event data.</param>
        void ControlPressedDown(object sender, PointerEventArgs e)
        {
            IExtendedCollidable<Point2D> extened = Extended;

            // Need a point to do collisions against.
            Point2D collidingPoint = new Point2D();
            Transform.MakeParentChild(e.Pointer, collidingPoint);

            // If no one other pointer is already clicking on the region and
            // the pointer is in the region than the region has been "pressed
            // down on".
            if (_clickingTransform == null &&
                extened.IsColliding(collidingPoint) == true)
            {
                _clickingTransform = e.Pointer;

                // TODO: we need a way to detect when the pointer has moved off
                // the region and handle that as a LetUp event. Right now, if
                // you click on and hold down, say, a button and then move the
                // cursor off the button, the LetUp event will not get invoked
                // and the button will still be pressed down.

                if (PressedDown != null)
                    PressedDown(this, e);
            }
        }

        /// <summary>
        /// An event handler that is invoked by the 
        /// <see cref="IPointerControl.LetUp"/> event of the 
        /// <see cref="Control"/> instance. This method checks if this instance
        /// <see cref="LetUp"/> event should be invoked.
        /// </summary>
        /// <param name="sender">The instance that generated the event.</param>
        /// <param name="e">The <see cref="PointerEventArgs"/> instance containing 
        /// the event data.</param>
        void ControlLetUp(object sender, PointerEventArgs e)
        {
            // If this is the pointer that previously pressed down on the region
            // and the pointer is still within the region's bounds, then the
            // region has been "let up on".
            if (_clickingTransform == e.Pointer)
            {
                if (Extended.IsColliding(new Point2D(e.Pointer.Position.Xy)) == true)
                {
                    _clickingTransform = null;

                    if (LetUp != null)
                        LetUp(this, e);
                }
            }
        }

        /// <summary>
        /// Ensures this instance listens to the events of the passed in
        /// <paramref name="control"/>.
        /// </summary>
        /// <param name="control">The <see cref="IPointerControl"/> to listen to
        /// for click events.</param>
        void Configure(IPointerControl control)
        {
            control.PressedDown += ControlPressedDown;
            control.LetUp += ControlLetUp;
        }

        /// <summary>
        /// Ensures this instance non longer listens to the events of the passed
        /// in <paramref name="control"/>.
        /// </summary>
        /// <param name="control">The <see cref="IPointerControl"/> to stop
        /// listening to for click events.</param>
        void Unconfigure(IPointerControl control)
        {
            control.PressedDown -= ControlPressedDown;
            control.LetUp -= ControlLetUp;
        }

        /// <summary>
        /// The <see cref="ITransform"/> that is currently clicking on the
        /// region or null if no pointer is clicking on the region.
        /// </summary>
        ITransform _clickingTransform;

        /// <summary>
        /// The backing field to <see cref="Control"/>.
        /// </summary>
        IPointerControl _control;
    }
}