using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using RecrownedAthenaeum.SpecialTypes;
using RecrownedAthenaeum.UI.SkinSystem.Definitions;
using System;
using System.Collections.Generic;

namespace RecrownedAthenaeum.UI.SkinSystem
{
    /// <summary>
    /// A skin is used to group a theme which can then be applied to the UI via the use of modules.
    /// </summary>
    public class Skin : IDisposable, ISkin
    {
        /// <summary>
        /// Whether or not this skin is completed being built and thus ready to use.
        /// </summary>
        public bool Laminated { get; private set; }
        private bool disposed;

        private TextureAtlas textureAtlas;

        Dictionary<string, Color> colors;
        readonly Dictionary<string, Type> moduleTypeOfDefinition;
        readonly Dictionary<Type, Dictionary<string, ISkinDefinitionData>> definitions;

        /// <summary>
        /// The texture for the cursor.
        /// </summary>
        public virtual Texture2D CursorTexture { get; private set; }

        /// <summary>
        /// Creates a basic unfilled skin.
        /// </summary>
        /// <param name="textureAtlas">The texture atlas to use for this skin.</param>
        /// <param name="cursorTexture">The texture the cursor will be.</param>
        public Skin(TextureAtlas textureAtlas, Texture2D cursorTexture)
        {
            this.textureAtlas = textureAtlas;
            this.CursorTexture = cursorTexture;
            colors = new Dictionary<string, Color>();
            moduleTypeOfDefinition = new Dictionary<string, Type>();
            definitions = new Dictionary<Type, Dictionary<string, ISkinDefinitionData>>();
        }

        /// <summary>
        /// Returns a <see cref="TextureAtlas.Region"/> with given name of region.
        /// </summary>
        /// <param name="name">Name of region.</param>
        /// <returns>The region corresponding to the name.</returns>
        public virtual TextureAtlas.Region GetTextureAtlasRegion(string name)
        {
            return textureAtlas[name];
        }

        /// <summary>
        /// Returns a <see cref="Color"/> with given name of defined color;
        /// </summary>
        /// <param name="name">Name of defined color.</param>
        /// <returns>The defined color based on the name given.</returns>
        public virtual Color GetColor(string name)
        {
            return colors[name];
        }

        /// <summary>
        /// Draws a region from the texture atlas.
        /// </summary>
        /// <param name="regionName">Region to draw.</param>
        /// <param name="color">The color to tint the region.</param>
        /// <param name="batch">The batch to use.</param>
        /// <param name="destination">The destination to draw to.</param>
        /// <param name="rotation">The rotation to use in radians.</param>
        /// <param name="origin">The origin for the rotation.</param>
        public virtual void Draw(string regionName, string color, SpriteBatch batch, Rectangle destination, float rotation = 0, Vector2 origin = default(Vector2))
        {
            if (disposed) throw new ObjectDisposedException(GetType().Name);
            textureAtlas.Draw(regionName, batch, destination, colors[color], rotation, origin);
        }

        private ISkinDefinitionData ObtainDefinition(Type type, string definitionName)
        {
            if (disposed) throw new ObjectDisposedException(GetType().Name);
            if (!Laminated) throw new InvalidOperationException("Skin has yet to be laminated yet.");
            if (definitionName == null) definitionName = "default";
            if (!definitions.ContainsKey(type)) throw new KeyNotFoundException("Could not find any skin definition defining type \"" + type.FullName + "\"");
            if (!definitions[type].ContainsKey(definitionName)) throw new KeyNotFoundException("Could not find skin definition defining type  \"" + type.Name + "\" with name \"" + definitionName + "\"");
            return definitions[type][definitionName];
        }

        /// <summary>
        /// Returns the proper definition for the given parameters or throws exception in the case the requested definition does not exist.
        /// </summary>
        /// <typeparam name="T">Convenience to cast to the needed definition type.</typeparam>
        /// <param name="definitionName">The name of the definition.</param>
        /// <returns>The definition cast to T.</returns>
        public virtual T ObtainDefinition<T>(string definitionName = null) where T : ISkinDefinitionData
        {
            return (T)ObtainDefinition(moduleTypeOfDefinition[typeof(T).FullName], definitionName);
        }

        /// <summary>
        /// Adds the definition.
        /// </summary>
        /// <param name="definitionName">The name of the definition. Default (if left blank) name is "default".</param>
        /// <param name="skinDefinition">The definition itself.</param>
        public virtual void AddDefinition(ISkinDefinitionData skinDefinition, string definitionName = null)
        {
            if (disposed) throw new ObjectDisposedException(GetType().Name);
            if (Laminated) throw new InvalidOperationException("This skin has been laminated and cannot be edited.");
            if (definitionName == null) definitionName = "default";
            if (!definitions.ContainsKey(moduleTypeOfDefinition[skinDefinition.GetType().FullName]))
            {
                moduleTypeOfDefinition.Add(skinDefinition.GetType().FullName, skinDefinition.UIModuleType);
                definitions.Add(skinDefinition.UIModuleType, new Dictionary<string, ISkinDefinitionData>());
            } else if (definitions[moduleTypeOfDefinition[skinDefinition.GetType().FullName]].ContainsKey(definitionName)) throw new ArgumentException("Type of definition with that name already exists!");

            definitions[moduleTypeOfDefinition[skinDefinition.GetType().FullName]].Add(definitionName, skinDefinition);
        }

        /// <summary>
        /// Adds color to skin.
        /// </summary>
        /// <param name="name"></param>
        /// <param name="color"></param>
        public virtual void AddColor(string name, Color color)
        {
            if (Laminated) throw new InvalidOperationException("This skin has been laminated and cannot be edited.");
            colors.Add(name, color);
        }

        /// <summary>
        /// Laminates the skin. Making sure no more additions are done and sets the skin to be ready for use.
        /// Needs to be called before any use of skin. Building skin needs to be done before lamination.
        /// </summary>
        public void Laminate()
        {
            Laminated = true;
        }

        /// <summary>
        /// Disposes <see cref="textureAtlas"/> and the <see cref="Texture2D"/> holding the cursor texture.
        /// </summary>
        public void Dispose()
        {
            if (disposed) throw new ObjectDisposedException(GetType().Name);
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Overridable dispose function.
        /// </summary>
        /// <param name="disposing">true when it's a user call to dispose.</param>
        public virtual void Dispose(bool disposing)
        {
            disposed = true;
            if (disposing && !disposed)
            {
                textureAtlas.Dispose();
                CursorTexture.Dispose();
            }
        }

        /// <summary>
        /// Destructor. Calls the dispose with false.
        /// </summary>
        ~Skin()
        {
            Dispose(false);
        }
    }
}