using Microsoft.Xna.Framework.Input;
using RecrownedAthenaeum.SpecialTypes;
using RecrownedAthenaeum.Input;
using RecrownedAthenaeum.UI.SkinSystem.Definitions;
using RecrownedAthenaeum.UI.SkinSystem;
using RecrownedAthenaeum.Render;

namespace RecrownedAthenaeum.UI.Modular.Modules.Interactive
{
    /// <summary>
    /// Function to be called when button is clicked.
    /// </summary>
    /// <param name="button">The button that was clicked.</param>
    public delegate void Clicked(Button button);

    /// <summary>
    /// A very primitive button containing all the basic functions.
    /// </summary>
    public class Button : UIModule
    {
        private ButtonSkinDefinition skinDefinition;
        private ISpecialDrawable downTexture, upTexture, highlightedTexture, disabledTexture;
        /// <summary>
        /// Click event listeners.
        /// </summary>
        public event Clicked Listeners;
        private bool pressed;
        /// <summary>
        /// Whether or not this button should be currently disabled.
        /// </summary>
        public bool disabled = false;

        /// <summary>
        /// Whether or not this button is currently being hovered on.
        /// </summary>
        public bool Highlighted { get; private set; }

        /// <summary>
        /// Constructs this button using <see cref="ISpecialDrawable"/>s for the different states it could be in.
        /// </summary>
        /// <param name="down">Button being pressed.</param>
        /// <param name="up">Button not being pressed.</param>
        /// <param name="disabled">Disabled button.</param>
        /// <param name="selected">Button being highlighted.</param>
        public Button(ISpecialDrawable down, ISpecialDrawable up, ISpecialDrawable disabled = null, ISpecialDrawable selected = null)
        {
            this.downTexture = down;
            this.upTexture = up;
            this.disabledTexture = disabled;
            this.highlightedTexture = selected;
        }

        /// <summary>
        /// Constructs this button using the skin system.
        /// </summary>
        /// <param name="skin">The skin containing the information of the textures and design to follow.</param>
        /// <param name="definitionName">The name of the definition in the skin. Can be null to select the default.</param>
        public Button(ISkin skin, string definitionName = null)
        {
            skinDefinition = skin.ObtainDefinition<ButtonSkinDefinition>(definitionName);
            downTexture = skin.GetTextureAtlasRegion(skinDefinition.downRegion, true);
            upTexture = skin.GetTextureAtlasRegion(skinDefinition.upRegion, true);
            disabledTexture = skin.GetTextureAtlasRegion(skinDefinition.disabledRegion);
            highlightedTexture = skin.GetTextureAtlasRegion(skinDefinition.selectedRegion);
        }

        /// <summary>
        /// Instantiates a button using a definition.
        /// </summary>
        /// <param name="skin">The skin the definition is defined in.</param>
        /// <param name="skinDefinition">The definition itself.</param>
        public Button(ISkin skin, ButtonSkinDefinition skinDefinition) :
            this(skin.GetTextureAtlasRegion(skinDefinition.downRegion, true),
                skin.GetTextureAtlasRegion(skinDefinition.upRegion, true),
                skin.GetTextureAtlasRegion(skinDefinition.disabledRegion),
                skin.GetTextureAtlasRegion(skinDefinition.selectedRegion))
        { }

        /// <summary>
        /// Draws the button.
        /// </summary>
        /// <param name="batch">Batch used to draw the button.</param>
        public override void Draw(ConsistentSpriteBatch batch)
        {
            if (disabled)
            {
                disabledTexture?.Draw(batch, Boundaries, color);
            }
            else
            {
                if (pressed)
                {
                    downTexture.Draw(batch, Boundaries, color);
                }
                else if (Highlighted)
                {
                    highlightedTexture?.Draw(batch, Boundaries, color);
                }
                else
                {
                    upTexture.Draw(batch, Boundaries, color);
                }
            }

            base.Draw(batch);
        }

        /// <summary>
        /// Called when the mouse changes state.
        /// </summary>
        /// <param name="state">The new state.</param>
        /// <returns>Whether or not to continue calling the next mouse change listener.</returns>
        public sealed override bool MouseStateChanged(MouseState state)
        {
            if (InputUtilities.MouseWithinBoundries(Boundaries))
            {
                if (state.LeftButton == ButtonState.Pressed)
                {
                    pressed = true;
                }
                else
                {
                    pressed = false;
                }
                if (InputUtilities.MouseClicked())
                {
                    OnClick();
                }
                Highlighted = true;
            }
            else
            {
                Highlighted = false;
                pressed = false;
            }

            return base.MouseStateChanged(state);
        }

        /// <summary>
        /// Called when the state of the keyboard changes.
        /// </summary>
        /// <param name="state">The new state.</param>
        /// <returns>Whether or not the next keyboard change listener should be called.</returns>
        public sealed override bool KeyboardStateChanged(KeyboardState state)
        {
            return base.KeyboardStateChanged(state);
        }

        internal void OnClick()
        {
            Listeners?.Invoke(this);
        }

    }
}
