using System;
using System.Collections.Generic;
using System.Linq;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Dependency;
using Chernobyl.DesignPatterns.Extension;
using Chernobyl.Event;
using Chernobyl.Graphics.Writing;
using Chernobyl.Input.Controls;
using Chernobyl.Switch;

namespace Chernobyl.Interface.Writing
{
    /// <summary>
    /// Controls the editing of an <see cref="IText"/> instance through the use 
    /// of a keyboard.
    /// </summary>
    public class TextEditor : Extension<IText>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="TextEditor"/> class.
        /// </summary>
        /// <param name="services">The <see cref="IEventCollection{T}"/> instance that 
        /// takes and gives out services.</param>
        public TextEditor(IEventCollection<object> services)
            : this(services, null)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="TextEditor"/> class.
        /// </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 TextEditor(IEventCollection<object> services, IText extended) : this(services, extended, null)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="TextEditor"/> class.
        /// </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>
        /// <param name="textCursor">The <see cref="TextCursor"/> instance used 
        /// to mark the text being edited or null if this class should search the 
        /// <see cref="IText"/> instance that this class is attached to for the 
        /// <see cref="TextCursor"/> extension. If a <see cref="TextCursor"/> 
        /// extension is not found, then this instance will add one to the 
        /// <see cref="IText"/> instance being extended.</param>
        public TextEditor(IEventCollection<object> services, IText extended, TextCursor textCursor)
        {
            Services = services;
            services.Inject<TextEditor>(this);
            BackspaceRepeater = new Repeater(100);
            DeleteRepeater = new Repeater(100);

            TextCursor = textCursor;
            Extended = extended;
        }

        /// <summary>
        /// An event handler that can be assigned to an event. This method removes 
        /// characters behind the cursor. By default, it is assigned to a 
        /// <see cref="Repeater"/> which is attached to the backspace keyboard 
        /// key.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing 
        /// the event data.</param>
        public void OnBackspace(object sender, EventArgs e)
        {
            if(TextCursor.IndexLocation != Extended.MinimumDrawIndex)
            {
                IText text = Extended;
                text.Writing = text.Writing.Remove(TextCursor.IndexLocation - 1, 1);

                // if we just removed the end of the writing then we don't need 
                // to reduce the index location
                if (TextCursor.IndexLocation != text.Writing.Length)
                    TextCursor.IndexLocation--;
            }
        }

        /// <summary>
        /// An event handler that can be assigned to an event. This method removes 
        /// characters in front of the cursor. By default, it is assigned to a 
        /// <see cref="Repeater"/> which is attached to the delete keyboard 
        /// key.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing 
        /// the event data.</param>
        public void OnDelete(object sender, EventArgs e)
        {
            IText text = Extended;
            if(TextCursor.IndexLocation < text.Writing.Length)
                text.Writing = text.Writing.Remove(TextCursor.IndexLocation, 1);
        }

        /// <summary>
        /// An event handler that can be assigned to an event. This method appends 
        /// characters to the extended <see cref="IText"/> instance at the  
        /// index location of the <see cref="IText"/> instances 
        /// <see cref="TextCursor"/>.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="ItemsEventArgs{T}"/> instance 
        /// containing the event data.</param>
        public void OnTextEntered(object sender, ItemsEventArgs<char> e)
        {
            IText text = Extended;
            text.Writing = text.Writing.Insert(TextCursor.IndexLocation, new string(e.Items));
            TextCursor.IndexLocation += e.Items.Length;
        }

        /// <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)
        {
            if (TextCursor == null)
            {
                IEnumerable<TextCursor> textCursors = extended.Extensions.OfType<TextCursor>();

                // if there is no TextCursor on the IText instance, then we are 
                // going to add one.
                if (textCursors.Count() == 0)
                    TextCursor = new TextCursor(Services, extended);
                else 
                    TextCursor = textCursors.First();
            }
            extended.Extensions.Add(this);

            // assign ourselves to the necessary keys in the keyboard
            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)
        {
            extended.Extensions.Remove(this);
            TextCursor = null;

            // un-assign ourselves from any keyboard events
            UnassignFromKeyboardEvents();
        }

        /// <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>
        /// Un-assigns an instance of this class to the necessary events from the 
        /// <see cref="Keyboard"/>.
        /// </summary>
        void UnassignFromKeyboardEvents()
        {
            Keyboard.TextEntered -= OnTextEntered;

            // un-setup backspace events
            Keyboard.Backspace.OnDown -= BackspaceRepeater.Start;
            Keyboard.Backspace.OnUp -= BackspaceRepeater.Stop;
            Keyboard.Backspace.OnDown -= OnBackspace;
            BackspaceRepeater.SwitchedOn -= OnBackspace;

            // un-setup delete events
            Keyboard.Delete.OnDown -= DeleteRepeater.Start;
            Keyboard.Delete.OnUp -= DeleteRepeater.Stop;
            DeleteRepeater.Elapsed -= OnDelete;
            DeleteRepeater.SwitchedOn -= OnDelete;
        }

        /// <summary>
        /// Assigns an instance of this class to the necessary events from the 
        /// <see cref="Keyboard"/>.
        /// </summary>
        void AssignToKeyboardEvents()
        {
            Keyboard.TextEntered += OnTextEntered;

            // setup backspace events
            Keyboard.Backspace.OnDown += BackspaceRepeater.Start;
            Keyboard.Backspace.OnUp += BackspaceRepeater.Stop;
            BackspaceRepeater.Elapsed += OnBackspace;
            BackspaceRepeater.SwitchedOn += OnBackspace;

            // setup delete events
            Keyboard.Delete.OnDown += DeleteRepeater.Start;
            Keyboard.Delete.OnUp += DeleteRepeater.Stop;
            DeleteRepeater.Elapsed += OnDelete;
            DeleteRepeater.SwitchedOn += OnDelete;
        }

        /// <summary>
        /// The <see cref="TextCursor"/> that points to the location where text 
        /// should be edited.
        /// </summary>
        TextCursor TextCursor { get; set; }

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

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

        /// <summary>
        /// The services instance that can take and give out services.
        /// </summary>
        IEventCollection<object> Services { get; set; }

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