using System;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Graphics.Writing;
using Chernobyl.Readiness;
using Microsoft.Xna.Framework.Graphics;

namespace Chernobyl.Graphics.Xna.Writing
{
    /// <summary>
    /// A IFont class that holds an instance to an XNA font known as a 
    /// SpriteFont.
    /// </summary>
    public class XnaFont : IFont
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The <see cref="IEventCollection{T}"/> instance that 
        /// takes and gives services.</param>
        /// <param name="xnaSpriteFont">The XNA SpriteFont instance that this 
        /// XnaFont should represent.</param>
        public XnaFont(IEventCollection<object> services, SpriteFont xnaSpriteFont)
        {
            XnaSpriteFont = xnaSpriteFont;

            // by default, if a key is not recognized, then use the question 
            // mark symbol. We'd prefer not to have exceptions thrown.
            XnaSpriteFont.DefaultCharacter = '?';
        }

        /// <summary>
        /// Measures the text passed in and returns its width and height in pixels.
        /// </summary>
        /// <param name="text">The text to measure.</param>
        /// <returns>The size of the string in pixels.</returns>
        public Mathematics.Vector2 MeasureString(string text)
        {
            Mathematics.Vector2 result;
            Microsoft.Xna.Framework.Vector2 size = XnaSpriteFont.MeasureString(text);
            Utility.ToChernobylVector(out result, ref size);
            return result;
        }

        /// <summary>
        /// True if this instance has been readied, false if otherwise.
        /// </summary>
        public bool IsReady
        {
            get { return _isReady; }
            private set
            {
                bool oldValue = _isReady;
                _isReady = value;
                if (oldValue == false && _isReady == true && _becameReady != null)
                    _becameReady(this, EventArgs.Empty);
            }
        }

        /// <summary>
        /// An event that is thrown right after this <see cref="IReadyable"/>
        /// has been readied. If an event handler is assigned to this event
        /// after it has become ready, then that event handler will be
        /// immediately invoked.
        /// </summary>
        public event EventHandler BecameReady
        {
            add
            {
                _becameReady += value;

                // if we are already ready, invoke the event
                if(IsReady == true)
                    value(this, EventArgs.Empty);
            }
            remove { _becameReady -= value; }
        }

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

        /// <summary>
        /// The XNA SpriteFont that is used to represent this font.
        /// </summary>
        public SpriteFont XnaSpriteFont
        {
            get { return _xnaSpriteFont; }
            private set
            {
                SpriteFont oldValue = value;
                _xnaSpriteFont = value;
                IsReady = (_xnaSpriteFont != null && oldValue == null);
            }
        }

        /// <summary>
        /// The backing field to <see cref="IsReady"/>.
        /// </summary>
        bool _isReady;

        /// <summary>
        /// The backing method to <see cref="BecameReady"/>.
        /// </summary>
        EventHandler _becameReady;

        /// <summary>
        /// The backing field to <see cref="XnaSpriteFont"/>.
        /// </summary>
        SpriteFont _xnaSpriteFont;
    }
}