using System;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Dependency;
using Chernobyl.Event;
using Chernobyl.Graphics.Drawing;
using Chernobyl.Graphics.Writing;
using Chernobyl.Mathematics.Collision;
using Chernobyl.Mathematics.Geometry;
using Chernobyl.Mathematics.Movement;
using Chernobyl.Resources;
using Microsoft.Xna.Framework.Graphics;

namespace Chernobyl.Graphics.Xna.Writing
{
    /// <summary>
    /// A representation of XNA text that is drawn to the screen.
    /// </summary>
    public class XnaText : DrawableTransformCollidable2D, IText
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The services instance that will give its 
        /// services to this instance and/or receive services from this instance.</param>
        /// <param name="font">The font to apply to this XNA text.</param>
        public XnaText(IEventCollection<object> services, IFont font)
        {
            _drawableImplementer = new Drawable();
            _decoratedTransform = new MatrixTransform();

            _maximumDrawLength = int.MaxValue;
            services.Inject<XnaText>(this);
            
            if (font != null)
                Font = font;    
            else
                Resource.FromNamed<IFont>(services, FontProcessedCallback, "default");
            
            Rectangle rectangle = new Rectangle();
            CollisionVolume = rectangle;
            Transform.MakeParentChild(this, rectangle);

            ViewportHeight = SpriteBatch.GraphicsDevice.Viewport.Height;
        }

        /// <summary>
        /// Called when this drawable should be drawn.
        /// </summary>
        public override uint Draw() 
        {
            SpriteBatch.Begin();

            // we want the text to be positioned relative to it's center to match
            // the standard set by other Chernobyl 2D objects. To do this, we subtract 
            // half the width and height from the text's position. We also want 
            // the text to be positioned in the Y relative to the bottom of the 
            // screen (again, as is standard in Chernobyl). To do this, we subtract
            // the position's Y from the viewport's height.
            Microsoft.Xna.Framework.Vector2 pos = new Microsoft.Xna.Framework.Vector2();
            float halfWidth = CollisionVolume.Width * 0.5f;
            float halfHeight = CollisionVolume.Height * 0.5f;
            pos.X = Position.X - halfWidth;
            pos.Y = (ViewportHeight - Position.Y) - halfHeight;

            SpriteBatch.DrawString(XnaFont, DrawnString, pos, _color);
            SpriteBatch.End();

            return base.Draw();
        }

        /// <summary>
        /// An event handler that is invoked after the <see cref="Writing"/> 
        /// property has been changed.
        /// </summary>
        public event EventHandler<ValueChangedEventArgs<string>> WritingChanged;

        /// <summary>
        /// The text that is rendered to the screen.
        /// </summary>
        public string Writing 
        {
            get { return _writing; }
            set 
            {
                if (WritingChanged != null)
                {
                    ValueChangedEventArgs<string> vce = new ValueChangedEventArgs<string>(_writing, value);

                    _writing = value;
                    DrawnStringDirty = true;

                    WritingChanged(this, vce);
                }
                else
                {
                    _writing = value;
                    DrawnStringDirty = true;
                }
            }
        }

        /// <summary>
        /// The zero based index at which drawing of this text starts from. For  
        /// example, if the <see cref="Writing"/> is set to "Hello!" and the 
        /// <see cref="MinimumDrawIndex"/> property is set to 2 then the text that 
        /// would be drawn would be "llo!". The default value of this property is 
        /// zero.
        /// </summary>
        public int MinimumDrawIndex 
        {
            get { return _minimumDrawIndex; }
            set
            {
                if (value < 0)
                    throw new ArgumentException("The MinimumDrawIndex cannot be " +
                    "less than zero. You specified: " + value, "value");

                if (MinimumDrawIndexChanged != null)
                {
                    ValueChangedEventArgs<int> vce = new ValueChangedEventArgs<int>(_minimumDrawIndex, value);

                    _minimumDrawIndex = value;
                    DrawnStringDirty = true;

                    MinimumDrawIndexChanged(this, vce);
                }
                else
                {
                    _minimumDrawIndex = value;
                    DrawnStringDirty = true;
                }
            }
        }

        /// <summary>
        /// The maximum number of characters in the text to draw. For example,   
        /// if the <see cref="Writing"/> is set to "Hello!" and the 
        /// <see cref="MaximumDrawLength"/> property is set to 3 then the text that 
        /// would be drawn would be "Hel". The default value of this property is 
        /// <see cref="uint.MaxValue"/>.
        /// </summary>
        public int MaximumDrawLength 
        {
            get { return _maximumDrawLength; }
            set
            {
                if (value < 0)
                    throw new ArgumentException("The MaximumDrawLength cannot be " +
                    "less than zero. You specified: " + value, "value");

                if (MaximumDrawLengthChanged != null)
                {
                    ValueChangedEventArgs<int> vce = new ValueChangedEventArgs<int>(_maximumDrawLength, value);

                    _maximumDrawLength = value;
                    DrawnStringDirty = true;

                    MaximumDrawLengthChanged(this, vce);
                }
                else
                {
                    _maximumDrawLength = value;
                    DrawnStringDirty = true;
                }
            }
        }

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

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

        /// <summary>
        /// The <see cref="IFont"/> associated with this text.
        /// </summary>
        public IFont Font 
        { 
            get { return _font; } 
            set 
            {
                _font = value;

                // get the XNA font
                XnaFont xnaFont = null;
                IFont nextFont = _font;
                while (xnaFont == null)
                {
                    xnaFont = nextFont as XnaFont;
                    nextFont = nextFont.Controller;
                }

                XnaFont = xnaFont.XnaSpriteFont;
            } 
        }

        /// <summary>
        /// The color of the rendered text.
        /// </summary>
        public Color Color { get { return Utility.ToChernobylColor(_color); } set { _color = Utility.ToXnaColor(value); } }

        /// <summary>
        /// The sprite batch to render the text with.
        /// </summary>
        [Inject]
        public SpriteBatch SpriteBatch { get; set; }

        /// <summary>
        /// The IText instance that is used to control the text created by a 
        /// graphics API like XNA, OpenGL, DirectX, etc. This property is null,
        /// by default, for the XnaText.
        /// </summary>
        public IText Controller { get; protected set; }

        /// <summary>
        /// The collidable that implements the collision of this object.
        /// </summary>
        protected override ICollidable2D CollidableImplementer { get { return CollisionVolume; } }

        /// <summary>
        /// The drawable that implements the drawing of this object.
        /// </summary>
        protected override IDrawable DrawableImplementer { get { return _drawableImplementer; } }

        /// <summary>
        /// The transform that provides this transforms capabilities.
        /// </summary>
        protected override ITransform DecoratedTransform { get { return _decoratedTransform; } }

        /// <summary>
        /// The <see cref="IShape"/> that implements the <see cref="IShape"/> 
        /// interface for this object.
        /// </summary>
        protected override IShape ShapeImplementer { get { return CollisionVolume; } }

        /// <summary>
        /// The XNA SpriteFont used to render this text.
        /// </summary>
        SpriteFont XnaFont { get; set; }

        /// <summary>
        /// The height of the viewport that we are rendering to. The viewport
        /// height is used to ensure the Y position of the text is relative to
        /// the bottom. In XNA, it is relative to the top so we subtract the 
        /// text's Y position from the height to make it relative to the bottom.
        /// </summary>
        float ViewportHeight { get; set; }

        /// <summary>
        /// Grabs the latest version of the <see cref="DrawnString"/> from the 
        /// <see cref="Writing"/> string and then calls <see cref="RemeasureWritingBounds()"/>.
        /// </summary>
        void RetakeDrawnString()
        {
            int maxDrawLength = Math.Min(MaximumDrawLength, Writing.Length - MinimumDrawIndex);
            int minDrawIndex = Math.Min(MinimumDrawIndex, Writing.Length);

            if (minDrawIndex == Writing.Length || maxDrawLength == 0)
                DrawnString = String.Empty;
            else
                DrawnString = Writing.Substring(minDrawIndex, maxDrawLength);

            // collision shape needs to be recalculated
            CollisionVolumeDirty = true;
            
            // the drawn string is now up to date
            DrawnStringDirty = false;
        }

        /// <summary>
        /// Remeasures the writing of this text and applies the new measurements
        /// to the collision bounds of this text.
        /// </summary>
        void RemeasureWritingBounds()
        {
            // don't measure anything if we haven't been initialized
            if(_writing != null && Font != null)
            {
                Microsoft.Xna.Framework.Vector2 textSize = XnaFont.MeasureString(DrawnString);

                Mathematics.Vector2 chernobylTextSize;
                Utility.ToChernobylVector(out chernobylTextSize, ref textSize);

                _collidableImplementer.SetWidthHeight(chernobylTextSize.X, chernobylTextSize.Y);

                // the collision shape has been recalculated
                CollisionVolumeDirty = false;
            }
        }

        /// <summary>
        /// Invoked when the font is properly loaded.
        /// </summary>
        /// <param name="result">The result of the font processing.</param>
        void FontProcessedCallback(IResourceProcessResult<IFont> result)
        {
            Font = result.Resource;
        }

        /// <summary>
        /// The Rectangle that implements the collision for this object.
        /// </summary>
        Rectangle CollisionVolume
        {
            get 
            {
                if(CollisionVolumeDirty == true)
                    RemeasureWritingBounds();

                return _collidableImplementer; 
            }
            set { _collidableImplementer = value; }
        }

        /// <summary>
        /// The string that is drawn for this <see cref="IText"/> instance. This 
        /// string represents the <see cref="Writing"/> string as the following:
        /// <code>
        /// DrawnString = Writing.Substring(MinimumDrawIndex, MaximumDrawLength);
        /// </code>
        /// </summary>
        string DrawnString 
        { 
            get 
            {
                if (DrawnStringDirty == true)
                    RetakeDrawnString();

                return _drawnString;
            }
            set { _drawnString = value; }
        }

        /// <summary>
        /// True if the <see cref="DrawnString"/> needs to be retaken, false if 
        /// otherwise.
        /// </summary>
        bool DrawnStringDirty
        {
            get { return _drawnStringDirty; }
            set { CollisionVolumeDirty = _drawnStringDirty = value; }
        }

        /// <summary>
        /// True if the <see cref="CollisionVolume"/> needs to be recalculated, 
        /// false if otherwise.
        /// </summary>
        bool CollisionVolumeDirty { get; set; }

        /// <summary>
        /// The backing field to <see cref="Color"/>.
        /// </summary>
        Microsoft.Xna.Framework.Graphics.Color _color;

        /// <summary>
        /// The backing field to <see cref="Writing"/>.
        /// </summary>
        string _writing;

        /// <summary>
        /// The backing field to <see cref="CollidableImplementer"/>.
        /// </summary>
        Rectangle _collidableImplementer;

        /// <summary>
        /// The backing field to <see cref="Font"/>.
        /// </summary>
        IFont _font;

        /// <summary>
        /// The backing field to <see cref="MinimumDrawIndex"/>.
        /// </summary>
        int _minimumDrawIndex;

        /// <summary>
        /// The backing field to <see cref="MaximumDrawLength"/>.
        /// </summary>
        int _maximumDrawLength;

        /// <summary>
        /// The backing field to <see cref="DrawnStringDirty"/>.
        /// </summary>
        bool _drawnStringDirty;

        /// <summary>
        /// The backing field to <see cref="DrawnString"/>.
        /// </summary>
        string _drawnString;

        /// <summary>
        /// The backing field to <see cref="DrawableImplementer"/>.
        /// </summary>
        IDrawable _drawableImplementer;

        /// <summary>
        /// The backing field to <see cref="DecoratedTransform"/>.
        /// </summary>
        ITransform _decoratedTransform;
    }
}