using System;
using System.Timers;
using Chernobyl.Collections.Generic;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Creation;
using Chernobyl.Dependency;
using Chernobyl.DesignPatterns.Extension;
using Chernobyl.Event;
using Chernobyl.Graphics;
using Chernobyl.Graphics.Drawing;
using Chernobyl.Graphics.Polygon;
using Chernobyl.Graphics.Polygon.Buffers;
using Chernobyl.Graphics.Writing;
using Chernobyl.Input.Controls;
using Chernobyl.Mathematics;
using Chernobyl.Mathematics.Geometry;
using Chernobyl.Mathematics.Movement;
using Chernobyl.Mathematics.Vectors;
using Chernobyl.Switch;
using Chernobyl.Utility;

namespace Chernobyl.Interface.Writing
{
    /// <summary>
    /// Places a text cursor (aka, a caret) on an <see cref="IText"/> instance 
    /// and allows that cursor to be moved using the keyboard keys.
    /// </summary>
    public class TextCursor : Extension<IText>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="TextCursor"/> class.
        /// </summary>
        /// <param name="services">The <see cref="IEventCollection{T}"/> 
        /// instance that takes and gives out services.</param>
        public TextCursor(IEventCollection<object> services)
            : this(services, null)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="TextCursor"/> class and 
        /// attaches this <see cref="TextCursor"/> to the passed in 
        /// <see cref="IText"/>.
        /// </summary>
        /// <param name="services">The <see cref="IEventCollection{T}"/> 
        /// instance that takes and gives out services.</param>
        /// <param name="extended">The <see cref="IText"/> to attach to or null 
        /// if no <see cref="IText"/> should be attached to right now.</param>
        public TextCursor(IEventCollection<object> services, IText extended)
        {
            _cursorFlashRateInMilliseconds = DefaultCursorFlashRateInMilliseconds;
            Services = services;
            LeftRepeater = new Repeater(100);
            RightRepeater = new Repeater(100);
            Extended = extended;
        }

        /// <summary>
        /// An event handler that can be assigned to an event. This method moves 
        /// this text cursor left. By default, it is assigned to a 
        /// <see cref="Repeater"/> which is attached to the left arrow keyboard 
        /// key.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing 
        /// the event data.</param>
        public void MoveLeft(object sender, EventArgs e)
        {
            if(IndexLocation != Extended.MinimumDrawIndex)
                IndexLocation--;
        }

        /// <summary>
        /// An event handler that can be assigned to an event. This method moves 
        /// this text cursor right. By default, it is assigned to a 
        /// <see cref="Repeater"/> which is attached to the right arrow keyboard 
        /// key.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing 
        /// the event data.</param>
        public void MoveRight(object sender, EventArgs e)
        {
            if (IndexLocation != Extended.Writing.Length)
                IndexLocation++;
        }

        /// <summary>
        /// An event handler that can be assigned to an event. This method moves 
        /// this text cursor to the beginning of the text. By default, it is 
        /// assigned to the home keyboard key.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing 
        /// the event data.</param>
        public void MoveToBeginning(object sender, EventArgs e)
        {
            IndexLocation = 0;
        }

        /// <summary>
        /// An event handler that can be assigned to an event. This method moves 
        /// this text cursor to the end of the text. By default, it is assigned
        /// to the end keyboard key.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing 
        /// the event data.</param>
        public void MoveToEnd(object sender, EventArgs e)
        {
            IndexLocation = Extended.Writing.Length;
        }

        /// <summary>
        /// The index (zero based) location of the text cursor in the string of 
        /// the attached <see cref="IText"/>. The cursor is placed right before 
        /// this index location.
        /// </summary>
        public int IndexLocation 
        {
            get { return _indexLocation; }
            set
            {
                if(IndexLocationChanged != null)
                {
                    ValueChangedEventArgs<int> vce = new ValueChangedEventArgs<int>(_indexLocation, value);

                    _indexLocation = value;
                    TextCursorRender.IsUpdateNeeded = true;

                    IndexLocationChanged(this, vce);
                }
                else
                {
                    _indexLocation = value;
                    TextCursorRender.IsUpdateNeeded = true;
                }
            }
        }

        /// <summary>
        /// An event that is raised after the <see cref="IndexLocation"/> 
        /// property has changed.
        /// </summary>
        public event EventHandler<ValueChangedEventArgs<int>> IndexLocationChanged;

        /// <summary>
        /// The <see cref="IKeyboard"/> instance that this <see cref="TextEditor"/> 
        /// gets it's keyboard events from.
        /// </summary>
        [Inject]
        public IKeyboard Keyboard
        {
            get { return _keyboard; }
            set
            {
                // if we have a previous keyboard we are going to need to un-assign 
                // ourself from it's events and assign ourself to the events from 
                // the newest keyboard. Otherwise, we will wait till we've
                // attached to an IText before we assign ourselves to keyboard 
                // events
                if (Extended != null)
                {
                    if (_keyboard != null)
                        UnassignFromKeyboardEvents();

                    _keyboard = value;
                    AssignToKeyboardEvents();
                }
                else
                    _keyboard = value;
            }
        }

        /// <summary>
        /// The <see cref="Scene"/> used as the default Chernobyl 
        /// <see cref="Scene"/> for rendering.
        /// </summary>
        [Inject]
        public Scene DefaultScene
        {
            set
            {
                _sceneDrawLocation = value.Draw2D;

                // If the DrawBuffer is ready and does not have a parent, parent
                // it.
                if (DrawBuffer != null && DrawBuffer.DrawableParent == null)
                    DrawBuffer.DrawableParent = _sceneDrawLocation;
            }
        }

        /// <summary>
        /// The amount of time (in milliseconds) it takes for the cursor to flash 
        /// on and off.
        /// </summary>
        /// <value>The default value for this property is the value of the 
        /// <see cref="DefaultCursorFlashRateInMilliseconds"/> field.</value>
        public static int CursorFlashRateInMilliseconds 
        {
            get { return _cursorFlashRateInMilliseconds; }
            set
            {
                _cursorFlashRateInMilliseconds = value;

                // if the flashing timer has already been created, we need to 
                // recreate it
                if (FlashingTimer == null)
                    FlashingTimer = new Timer(_cursorFlashRateInMilliseconds);
            }
        }

        /// <summary>
        /// The default value of the <see cref="CursorFlashRateInMilliseconds"/>
        /// property.
        /// </summary>
        public static int DefaultCursorFlashRateInMilliseconds = 600;

        /// <summary>
        /// Attaches this extension to the passed in object so that is can be
        /// extended.
        /// </summary>
        /// <param name="extended">The object to extend.</param>
        protected override void AttachTo(IText extended)
        {
            extended.Extensions.Add(this);
            extended.WritingChanged += extended_WritingChanged;
            extended.MinimumDrawIndexChanged += extended_MinimumDrawIndexChanged;
            extended.MaximumDrawLengthChanged += extended_MaximumDrawLengthChanged;

            if (TextCursorDrawParent == null)
            {
                Services.Create<IDrawBufferFactory, IDrawBuffer,
                                Pair<IEventCollection<object>, IBuffer>>(
                                    (sender, e) => DrawBuffer = e.CreatedInstance,
                                    new Pair<IEventCollection<object>, IBuffer>(Services, VertexColor.CreateSquare(Services, ColorRgba.Black)));

                // If the DrawBuffer is ready and does not have a parent, parent
                // it.
                if (_sceneDrawLocation != null && DrawBuffer != null &&
                    DrawBuffer.DrawableParent == null)
                    DrawBuffer.DrawableParent = _sceneDrawLocation;

                // create the flashing timer, the "set" of the FlashingTimer 
                // property will properly configure the flashing timer and 
                // OnOffDrawable
                if (FlashingTimer == null)
                    FlashingTimer = new Timer(CursorFlashRateInMilliseconds);
            }

            // create a TransformRectangle of 1x1. The transform rectangle will
            // automatically adjust as we scale the sprite. Currently, the sprite
            // is using a 1x1 square mesh element to render textures to, therefore, 
            // a 1x1 TransformRectangle will only work properly with a 1x1 mesh 
            // element square.
            Rectangle rectangle = new Rectangle(-0.5f, -0.5f, 1, 1);
            Transform.MakeParentChild(extended, rectangle);

            // create a render for this instance
            TextCursorRender = new Render(Services, PrimitiveType.TriangleStrip, null, new TextCursorTransform(this), rectangle);
            TextCursorRender.DrawableParent = TextCursorDrawParent;
            Transform.MakeParentChild(extended, TextCursorRender);

            // scale the render so that it is the same height as the text we are 
            // a cursor of. Also, place the cursor at the beginning of the line 
            // of text by default
            TextCursorRender.ScaleY(extended.Height);
            IndexLocation = extended.Writing.Length;
            TextCursorRender.IsUpdateNeeded = true;

            AssignToKeyboardEvents();
        }

        /// <summary>
        /// Removes the decorator from an object so that it is no longer extended.
        /// </summary>
        /// <param name="extended">The object to remove the extension from.</param>
        protected override void DetachFrom(IText extended)
        {
            TextCursorDrawParent.DrawableChildren.Remove(TextCursorRender);
            Transform.SeperateParentChild(extended, TextCursorRender);
            extended.Extensions.Remove(this);
            extended.WritingChanged -= extended_WritingChanged;
            UnassignFromKeyboardEvents();
        }

        /// <summary>
        /// Un-assigns an instance of this class to the necessary events from the 
        /// <see cref="Keyboard"/>.
        /// </summary>
        void UnassignFromKeyboardEvents()
        {
            // setup the left arrow key
            Keyboard.Left.OnDown -= LeftRepeater.Start;
            Keyboard.Left.OnUp -= LeftRepeater.Stop;
            LeftRepeater.Elapsed -= MoveLeft;
            LeftRepeater.SwitchedOn -= MoveLeft;

            // setup the left arrow key
            Keyboard.Right.OnDown -= RightRepeater.Start;
            Keyboard.Right.OnUp -= RightRepeater.Stop;
            RightRepeater.Elapsed -= MoveRight;
            RightRepeater.SwitchedOn -= MoveRight;

            // setup the home and end keys
            Keyboard.Home.OnDown -= MoveToBeginning;
            Keyboard.End.OnDown -= MoveToEnd;
        }

        /// <summary>
        /// Assigns an instance of this class to the necessary events from the 
        /// <see cref="Keyboard"/>.
        /// </summary>
        void AssignToKeyboardEvents()
        {
            // setup the left arrow key
            Keyboard.Left.OnDown += LeftRepeater.Start;
            Keyboard.Left.OnUp += LeftRepeater.Stop;
            LeftRepeater.Elapsed += MoveLeft;
            LeftRepeater.SwitchedOn += MoveLeft;

            // setup the left arrow key
            Keyboard.Right.OnDown += RightRepeater.Start;
            Keyboard.Right.OnUp += RightRepeater.Stop;
            RightRepeater.Elapsed += MoveRight;
            RightRepeater.SwitchedOn += MoveRight;

            // setup the home and end keys
            Keyboard.Home.OnDown += MoveToBeginning;
            Keyboard.End.OnDown += MoveToEnd;
        }

        /// <summary>
        /// Handles the <see cref="IText.WritingChanged"/> event on the attached 
        /// <see cref="IText"/> instance. This method dirties the matrix of the 
        /// <see cref="TextCursorRender"/> so that it will recalculate it's position.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The event data.</param>
        void extended_WritingChanged(object sender, ValueChangedEventArgs<string> e)
        {
            TextCursorRender.IsUpdateNeeded = true;
        }

        /// <summary>
        /// Handles the MaximumDrawLengthChanged event of the extended control.
        /// This method dirties the matrix of the <see cref="TextCursorRender"/> 
        /// so that it will recalculate it's position.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="ValueChangedEventArgs{T}"/> instance 
        /// containing the event data.</param>
        void extended_MaximumDrawLengthChanged(object sender, ValueChangedEventArgs<int> e)
        {
            TextCursorRender.IsUpdateNeeded = true;
        }

        /// <summary>
        /// Handles the MinimumDrawIndexChanged event of the extended control. 
        /// This method dirties the matrix of the <see cref="TextCursorRender"/> 
        /// so that it will recalculate it's position.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="ValueChangedEventArgs{T}"/> instance 
        /// containing the event data.</param>
        void extended_MinimumDrawIndexChanged(object sender, ValueChangedEventArgs<int> e)
        {
            TextCursorRender.IsUpdateNeeded = true;
        }

        /// <summary>
        /// The <see cref="IRender"/> instance used to render and transform the 
        /// text cursor.
        /// </summary>
        IRender TextCursorRender { get; set; }

        /// <summary>
        /// The <see cref="Repeater"/> used to control the repeat rates of 
        /// several keys.
        /// </summary>
        Repeater LeftRepeater { get; set; }

        /// <summary>
        /// The <see cref="Repeater"/> used to control the repeat rates of 
        /// several keys.
        /// </summary>
        Repeater RightRepeater { get; set; }

        /// <summary>
        /// The <see cref="IEventCollection{T}"/> that was given to this class in its 
        /// constructor. When a new <see cref="IEventCollection{T}"/> instance is set on 
        /// this property the class will call 
        /// <see cref="ServiceAttributeExtensions.Inject{T}(IEventCollection{object}, T)"/>
        /// passing in 'this' instance.
        /// </summary>
        IEventCollection<object> Services 
        {
            get { return _services; }
            set
            {
                _services = value;
                _services.Inject<TextCursor>(this);
            }
        }

        /// <summary>
        /// The parent <see cref="IDrawable"/> that the text cursor 
        /// <see cref="IRender"/>s attach to.
        /// </summary>
        static IDrawable TextCursorDrawParent { get { return OnOffDrawable; } }

        /// <summary>
        /// The instance that renders the cursor geometry to the screen.
        /// </summary>
        static IDrawBuffer DrawBuffer
        {
            get { return _drawBuffer; }
            set
            {
                value.ThrowIfNull("value");

                IDrawBuffer previousValue = _drawBuffer;
                _drawBuffer = value;

                if(previousValue != null)
                {
                    if (OnOffDrawable.DrawableParent == previousValue)
                        OnOffDrawable.DrawableParent = null;
                }

                OnOffDrawable.DrawableParent = _drawBuffer;
            }
        }

        /// <summary>
        /// The <see cref="IDrawable"/> used to turn off the <see cref="IRender"/> 
        /// cursor instances.
        /// </summary>
        static OnOffDrawable OnOffDrawable
        {
            get { return _onOffDrawable ?? (_onOffDrawable = new OnOffDrawable((IDrawable)null)); }
        }

        /// <summary>
        /// The timer that is used to generate the flashing cursor. Setting this 
        /// property will cause the <see cref="OnOffDrawable"/> to no longer
        /// listen to the previous FlashingTimer's <see cref="Timer.Elapsed"/> 
        /// event and start listening to the event of the new instance. Also, 
        /// the new timer will be started using <see cref="Timer.Start()"/>.
        /// </summary>
        static Timer FlashingTimer 
        {
            get { return _flashingTimer; }
            set
            {
                if (_flashingTimer != null)
                    _flashingTimer.Elapsed -= OnOffDrawable.Toggle;

                _flashingTimer = value;
                _flashingTimer.Elapsed += OnOffDrawable.Toggle;
                _flashingTimer.Start();
            }
        }

        /// <summary>
        /// An <see cref="ITransform"/> specifically made to move the cursor 
        /// around some text.
        /// </summary>
        class TextCursorTransform : RemoveScaleTransform
        {
            /// <summary>
            /// Initializes a new instance of the <see cref="TextCursorTransform"/> 
            /// class.
            /// </summary>
            /// <param name="textCursor">The text cursor.</param>
            public TextCursorTransform(TextCursor textCursor)
            {
                TextCursor = new WeakReference<TextCursor>(textCursor);
            }

            /// <summary>
            /// Orders this transform so that it's world matrix represents it's
            /// local matrix relative to it's parent's world matrix.
            /// </summary>
            protected override void Update()
            {
                if (IsUpdateNeeded == true)
                {
                    TextCursor textCursor = TextCursor.Target;
                    IText text = textCursor.Extended;

                    string writing = text.Writing;

                    // if the location is past the end of the text, then we'll slap the 
                    // cursor on the end. Don't set the length using "IndexLocation" 
                    // though since the "set" of that property calls this method.
                    if (textCursor.IndexLocation > writing.Length)
                        textCursor.IndexLocation = writing.Length;

                    // measure the distance from the beginning of the string to the 
                    // location of the cursor and then use that distance to get the 
                    // distance from the center of the string (transform) to the 
                    // cursor's location
                    float stringWidth = (text.Font.MeasureString(writing.Substring(text.MinimumDrawIndex, textCursor.IndexLocation - text.MinimumDrawIndex))).X;
                    float distanceFromCenter = stringWidth - (text.Width * 0.5f);

                    // now place the reposition the transform of the cursor instance.
                    Vector4 row3 = LocalMatrix.Row3;
                    Matrix4 transform = LocalMatrix;
                    transform.Row3 = new Vector4(distanceFromCenter, row3.Y, row3.Z, row3.W);
                    SetTransformation(ref transform);

                    base.Update();
                }
            }

            /// <summary>
            /// The <see cref="TextCursor"/> wrapped in a <see cref="WeakReference{T}"/> 
            /// to prevent cyclical referencing (allows instances to be garbage 
            /// collected).
            /// </summary>
            WeakReference<TextCursor> TextCursor { get; set; }
        }

        /// <summary>
        /// The backing field to <see cref="DrawBuffer"/>.
        /// </summary>
        static IDrawBuffer _drawBuffer;

        /// <summary>
        /// The backing field to <see cref="OnOffDrawable"/>.
        /// </summary>
        static OnOffDrawable _onOffDrawable;

        /// <summary>
        /// The backing field to <see cref="CursorFlashRateInMilliseconds"/>.
        /// </summary>
        static int _cursorFlashRateInMilliseconds;

        /// <summary>
        /// The backing field to <see cref="FlashingTimer"/>.
        /// </summary>
        static Timer _flashingTimer;

        /// <summary>
        /// The backing field to <see cref="Services"/>.
        /// </summary>
        IEventCollection<object> _services;

        /// <summary>
        /// The backing field to <see cref="IndexLocation"/>.
        /// </summary>
        int _indexLocation;

        /// <summary>
        /// The backing field to <see cref="Keyboard"/>.
        /// </summary>
        IKeyboard _keyboard;

        /// <summary>
        /// The <see cref="IDrawable"/> that represents the location in the scene 
        /// where the cursor should be drawn.
        /// </summary>
        IDrawable _sceneDrawLocation;
    }
}