using System.Collections.Generic;
using System.Linq;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.DesignPatterns.Extension;
using Chernobyl.Event;
using Chernobyl.Graphics.Writing;
using Chernobyl.Mathematics;
using Chernobyl.Mathematics.Geometry;
using Chernobyl.Mathematics.Vectors;

namespace Chernobyl.Interface.Writing
{
    /// <summary>
    /// An <see cref="IExtension{TExtended}"/> that can be applied to 
    /// <see cref="IText"/> instances. This extension causes the text of the 
    /// extended  <see cref="IText"/> instance to only be displayed within the 
    /// constraints of the <see cref="Rectangle"/> passed in.
    /// </summary>
    public class TextConstraint : Extension<IText>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="TextConstraint"/> class.
        /// </summary>
        /// <param name="services">The <see cref="IEventCollection{T}"/> instance that 
        /// takes and gives out services.</param>
        /// <param name="constrainTo">The <see cref="IShape"/> to constrain 
        /// the text of the extended <see cref="IText"/> instance to.</param>
        public TextConstraint(IEventCollection<object> services, IShape constrainTo)
            : this(services, constrainTo, null)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="TextConstraint"/> class.
        /// </summary>
        /// <param name="services">The <see cref="IEventCollection{T}"/> instance that 
        /// takes and gives out services.</param>
        /// <param name="constrainTo">The <see cref="IShape"/> to constrain 
        /// the text of the extended <see cref="IText"/> instance to.</param>
        /// <param name="extended">The <see cref="IText"/> instance to extend or 
        /// null if the instance will be attached to (<see cref="AttachTo(IText)"/>) 
        /// later on.</param>
        public TextConstraint(IEventCollection<object> services, IShape constrainTo, IText extended)
        {
            Services = services;
            IsTextCursorFollowingEnabled = DefaultIsTextCursorFollowingEnabledValue;
            ConstrainTo = constrainTo;
            Extended = extended;
        }

        /// <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 (IsTextCursorFollowingEnabled == true && TextCursor == null)
            {
                IEnumerable<TextCursor> textCursors = extended.Extensions.OfType<TextCursor>();
                if (textCursors.Count() != 0)
                    TextCursor = textCursors.First();
                else
                    TextCursor = new TextCursor(Services, extended);

                TextCursor.IndexLocationChanged += TextCursor_IndexLocationChanged;
            }

            extended.Extensions.Add(this);
            extended.WritingChanged += extended_WritingChanged;

            RepositionText();
        }

        

        /// <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.WritingChanged -= extended_WritingChanged;
            extended.Extensions.Remove(this);

            if (TextCursor != null)
                TextCursor.IndexLocationChanged -= TextCursor_IndexLocationChanged;
        }

        /// <summary>
        /// An event handler for the <see cref="IText.WritingChanged"/> event of 
        /// the <see cref="Extension{TExtended}.Extended"/> (<see cref="IText"/>) 
        /// instance.
        /// </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_WritingChanged(object sender, ValueChangedEventArgs<string> e)
        {
            RepositionText();
        }

        void TextCursor_IndexLocationChanged(object sender, ValueChangedEventArgs<int> e)
        {
            IText text = Extended;

            // first get the displaying string up to the text cursor's index
            // then grab it's width; this width will be the distance from the 
            // text's left side to the cursor
            if(e.NewValue > e.OldValue)
            {
                string textToCursor = text.Writing.Substring(text.MinimumDrawIndex, e.NewValue - text.MinimumDrawIndex);
                float textCursorsDistanceFromTextsLeftSide = text.Font.MeasureString(textToCursor).X;

                // if the distance from the left side of the text to the cursor is 
                // larger than the constraint, we will need to move the displaying 
                // text to the left to ensure the cursor stays within the bounds of 
                // the constraint.
                if (textCursorsDistanceFromTextsLeftSide >= ConstrainTo.Width)
                {
                    // remove one character from the front of the text's writing until 
                    // it is of the correct size. As we do so, increase the minimum 
                    // index to "move" the displaying to the left.
                    float newWidth = 0.0f;
                    int minDrawIndex = text.MinimumDrawIndex;
                    do
                    {
                        minDrawIndex++;
                        textToCursor = textToCursor.Remove(0, 1);
                        newWidth = text.Font.MeasureString(textToCursor).X;

                    } while (newWidth > ConstrainTo.Width);

                    text.MaximumDrawLength = textToCursor.Length;
                    text.MinimumDrawIndex = minDrawIndex;
                }
            }
            else
            {
                if (text.MinimumDrawIndex != 0)
                    text.MinimumDrawIndex--;
            }
        }

        /// <summary>
        /// Repositions the <see cref="Text"/> so that it fits within the 
        /// rectangle constraint.
        /// </summary>
        void RepositionText()
        {
            IText text = Extended;

            // check if the width of the text needs is larger than the constraint
            if(IsTextCursorFollowingEnabled == false)
            {
                if (text.Width > ConstrainTo.Width)
                {
                    // remove one character from the end of the text's writing until 
                    // it is of the correct size.
                    string writing = text.Writing;
                    float newWidth = 0.0f;
                    do
                    {
                        writing = writing.Remove(writing.Length - 1, 1);
                        newWidth = text.Font.MeasureString(writing).X;

                    } while (newWidth > ConstrainTo.Width);

                    text.MaximumDrawLength = writing.Length;
                }
            }

            // snap to the edge of the text to the left edge of the constraint

            // grab the text's distance from the left edge of the constraint
            float distance = (text.Width * 0.5f) - (ConstrainTo.Width * 0.5f);

            // now create a matrix that will pin the text instance to the left 
            // edge of the constraint
            Matrix4 local = text.LocalMatrix;
            local.Row3 = new Vector4(distance, local.Row3.Y, local.Row3.Z, local.Row3.W);
            text.SetTransformation(ref local);
        }

        /// <summary>
        /// The <see cref="TextCursor"/> instance to follow with regard to text 
        /// being viewed. If this property is set to null then TextCursor 
        /// following is turned off. By default, <see cref="TextConstraint"/> 
        /// instances will attempt to locate a <see cref="TextCursor"/> within 
        /// the <see cref="IExtendable.Extensions"/> list of the extended 
        /// <see cref="IText"/> instance and use it; if none is available, 
        /// an <see cref="TextCursor"/> instance will automatically be attached 
        /// to the extended <see cref="IText"/> instance. Note that, regardless
        /// of the value of this property, if the 
        /// <see cref="IsTextCursorFollowingEnabled"/> property is false, then 
        /// <see cref="TextCursor"/> following is disabled.
        /// </summary>
        public TextCursor TextCursor { get; set; }

        /// <summary>
        /// True if <see cref="TextCursor"/> following (see the 
        /// <see cref="TextCursor"/> property for more information) is enabled, 
        /// false if otherwise. If this property is true, the <see cref="TextCursor"/> 
        /// property is null, and there is no <see cref="TextCursor"/> extension 
        /// on the extended <see cref="IText"/> instance, instances of this class 
        /// will automatically add a <see cref="TextCursor"/> instance to the 
        /// extended <see cref="IText"/> instance. By default, the default value 
        /// of this property is the value of the 
        /// <see cref="DefaultIsTextCursorFollowingEnabledValue"/> field.
        /// </summary>
        public bool IsTextCursorFollowingEnabled { get; set; }

        /// <summary>
        /// The default value (true) of the <see cref="IsTextCursorFollowingEnabled"/> 
        /// property.
        /// </summary>
        public bool DefaultIsTextCursorFollowingEnabledValue = true;

        /// <summary>
        /// The <see cref="IShape"/> to constrain the text of the extended 
        /// <see cref="IText"/> instance to.
        /// </summary>
        IShape ConstrainTo { get; set; }

        /// <summary>
        /// The <see cref="IEventCollection{T}"/> instance that takes and gives 
        /// out services.
        /// </summary>
        IEventCollection<object> Services { get; set; }
    }
}