using System;
using System.Text;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Event;
using Chernobyl.Input.Controls;
using Microsoft.Xna.Framework.Input;

namespace Chernobyl.Input.Xna.Controls.Keyboard
{
    /// <summary>
    /// Represents an XNA keyboard
    /// </summary>
    public class XnaKeyboard : Control, IKeyboard
    {
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="services">The object to use to inject dependencies
        /// into this instance.</param>
        public XnaKeyboard(IEventCollection<object> services)
        {
            Services = services;

            if(WKI == null)
                WKI = new WindowsKeyboardInput(services);
            
            EnteredText = new StringBuilder();
            WKI.CharEntered += OnTextEntered;
        }

        /// <summary>
        /// Gets the <see cref="IButtonControl"/> with the specified key name.
        /// </summary>
        public IButtonControl this[string keyName]
        {
            get 
            {
                object obj = Enum.Parse(typeof(Keys), keyName);
                if (obj == null)
                    return null;

                return new KeyboardKey(Services, (Keys)obj, this);
            }
        }

        /// <summary>
        /// An event that is raised when text has been "entered" or typed on
        /// the keyboard.
        /// </summary>
        public event EventHandler<ItemsEventArgs<char>> TextEntered;

        /// <summary>
        /// Updates this keyboard. Grabs the recently pressed keys and 
        /// </summary>
        /// <param name="deltaTime">The amount of time that has
        /// passed since this update was last called.</param>
        public override void Update(TimeSpan deltaTime)
        {
            if(EnteredText.Length != 0 && TextEntered != null)
            {
                TextEntered(this, new ItemsEventArgs<char>(EnteredText.ToString().ToCharArray()));
                EnteredText.Remove(0, EnteredText.Length);
            }
            
            base.Update(deltaTime);
        }

        #region Keys

        /// <summary>
        /// The backspace key or null if it does not exist on the keyboard.
        /// </summary>
        public IButtonControl Backspace { get { return GetKey(ref _Backspace, Keys.Back); } }

        /// <summary>
        /// The delete key or null if it does not exist on the keyboard.
        /// </summary>
        public IButtonControl Delete { get { return GetKey(ref _Delete, Keys.Delete); } }

        /// <summary>
        /// The down arrow or null if it does not exist on the keyboard.
        /// </summary>
        public IButtonControl Down { get { return GetKey(ref _Down, Keys.Down); } }

        /// <summary>
        /// The End key or null if it does not exist on the keyboard.
        /// </summary>
        public IButtonControl End { get { return GetKey(ref _End, Keys.End); } }

        /// <summary>
        /// The Home key or null if it does not exist on the keyboard.
        /// </summary>
        public IButtonControl Home { get { return GetKey(ref _Home, Keys.Home); } }

        /// <summary>
        /// The up arrow or null if it does not exist on the keyboard.
        /// </summary>
        public IButtonControl Up { get { return GetKey(ref _Up, Keys.Up); } }

        /// <summary>
        /// The up arrow or null if it does not exist on the keyboard.
        /// </summary>
        public IButtonControl Left { get { return GetKey(ref _Left, Keys.Left); } }

        /// <summary>
        /// The right arrow or null if it does not exist on the keyboard.
        /// </summary>
        public IButtonControl Right { get { return GetKey(ref _Right, Keys.Right); } }

        #endregion // Keys

        /// <summary>
        /// Due to the fact that the engineers at Microsoft are spastic retards 
        /// who got their degrees by attending English classes, XNA cannot 
        /// handle buffered input. Therefore, this event handler is provided to  
        /// allow "third party" applications to inform this class when text has 
        /// been entered.
        /// </summary>
        public void OnTextEntered(object sender, ItemsEventArgs<char> e)
        {
            EnteredText.Append(e.Items);
        }

        /// <summary>
        /// The <see cref="StringBuilder"/> that receives input from the 
        /// <see cref="OnTextEntered(object, ItemsEventArgs{char})"/> method.
        /// </summary>
        StringBuilder EnteredText { get; set; }

        /// <summary>
        /// Gets the specified <see cref="KeyboardKey"/>.
        /// </summary>
        /// <param name="key">The <see cref="KeyboardKey"/> that should be assigned 
        /// to.</param>
        /// <param name="xnaKey">The XNA key enum that matches the key you want 
        /// to get.</param>
        /// <returns>The key requested</returns>
        IButtonControl GetKey(ref IButtonControl key, Keys xnaKey)
        {
            if (key == null) 
                key = new KeyboardKey(Services, xnaKey, this);
            return key;
        }

        /// <summary>
        /// Checks the content of two <see cref="char"/> arrays for equality.
        /// </summary>
        /// <param name="values1">The first array.</param>
        /// <param name="values2">The second array.</param>
        /// <returns>True if the arrays contain the same objects, false if 
        /// otherwise.</returns>
        bool Equals(char[] values1, char[] values2)
        {
            if (values1 == values2)
                return true;

            if (values1 == null || values2 == null)
                return false;

            if (values1.Length != values2.Length)
                return false;

            for (int i = 0; i < values1.Length; ++i)
            {
                if (values1[i] != values2[i])
                    return false;
            }

            return true;
        }

        /// <summary>
        /// The object to use to inject dependencies into this instance.
        /// </summary>
        IEventCollection<object> Services { get; set; }

        /// <summary>
        /// The class that injects Window's keyboard input into Chernobyl.
        /// </summary>
        static WindowsKeyboardInput WKI { get; set; }

#region Keyboard Key Backing Fields
        /// <summary>
        /// The backing field to <see cref="Backspace"/>.
        /// </summary>
        IButtonControl _Backspace;

        /// <summary>
        /// The backing field to <see cref="Delete"/>
        /// </summary>
        IButtonControl _Delete;

        /// <summary>
        /// The backing field to <see cref="Down"/>.
        /// </summary>
        IButtonControl _Down;

        /// <summary>
        /// The backing field to <see cref="End"/>.
        /// </summary>
        IButtonControl _End;

        /// <summary>
        /// The backing field to <see cref="Home"/>.
        /// </summary>
        IButtonControl _Home;

        /// <summary>
        /// The backing field to <see cref="Up"/>.
        /// </summary>
        IButtonControl _Up;

        /// <summary>
        /// The backing field to <see cref="Left"/>.
        /// </summary>
        IButtonControl _Left;

        /// <summary>
        /// The backing field to <see cref="Right"/>.
        /// </summary>
        IButtonControl _Right;
#endregion
    }
}