//---------------------------------------------------------------------------------------------------------------------------------------------------
// <copyright file="HeadsUpDisplay.cs" company="DarkWynter Studios">
//     Copyright (C)2007 DarkWynter Studios.  All rights reserved.
// </copyright>
//---------------------------------------------------------------------------------------------------------------------------------------------------
// {Contact : darkwynter.com for licensing information
//---------------------------------------------------------------------------------------------------------------------------------------------------

namespace DarkWynterEngine.UserInterface
{
    #region Using Statements
    using System;
    using System.Collections.Generic;
    using System.Collections;
    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Audio;
    using Microsoft.Xna.Framework.Content;
    using Microsoft.Xna.Framework.Graphics;
    using Microsoft.Xna.Framework.Input;
    using Microsoft.Xna.Framework.Storage;
    using Globals;
    #endregion

    /// <summary>
    ///  Creates, updates, and draws a heads up display on the user's viewport.
    /// </summary>
    public class HeadsUpDisplay
    {
        // Attributes:

        // Screen dead zone percentage
        private const float SIDES_DEAD_ZONE_PERCENT = 0.05f;
        private const float TOP_BOTTOM_DEAD_ZONE_PERCENT = 0.03f;
        private int playerIndex = 0;
        /// <summary>
        /// View-port on which our HUD will draw itself
        /// </summary>
        public Viewport parentViewport;

        // List of Text Displays
        private List<TextDisplay> textDisplays = new List<TextDisplay>();

        // List of Value Displays
        private List<ValueDisplay> valueDisplays = new List<ValueDisplay>();

        // List of Image Displays
        private List<ImageDisplay> imageDisplays = new List<ImageDisplay>();

        private List<ImageSpinner> imageSpinners = new List<ImageSpinner>();

        /// <summary>
        /// Indicates what type of Heads Up Display element this is.
        /// </summary>
        public enum DisplayType
        {
            /// <summary>
            /// A string of text.
            /// </summary>
            TEXT,
            /// <summary>
            /// A numerical value.
            /// </summary>
            VALUE,
            /// <summary>
            /// An image.
            /// </summary>
            IMAGE,
            /// <summary>
            /// Default.
            /// </summary>
            BASE
        };

        /// <summary>
        /// Base class for all types.
        /// </summary>
        public class HUDDisplay
        {
            /// <summary>
            /// Text string drawn to HUD.
            /// </summary>
            public string text;
            /// <summary>
            /// Position of HUD element.
            /// </summary>
            public Vector2 position = new Vector2();
            /// <summary>
            /// Width of HUD element.
            /// </summary>
            public int width;
            /// <summary>
            /// Height of HUD element.
            /// </summary>
            public int height;
            /// <summary>
            /// Color of text element.
            /// </summary>
            public Color color;
            /// <summary>
            /// Type of HUD element.
            /// </summary>
            public DisplayType type = DisplayType.BASE;
            /// <summary>
            /// Visibility of HUD element.
            /// </summary>
            public bool visible = true;
        };

        /// <summary>
        /// Used to display Text.
        /// </summary>
        private class TextDisplay : HUDDisplay
        {
            /// <summary>
            /// Text display constructor.
            /// </summary>
            public TextDisplay()
            {
                type = DisplayType.TEXT;
            }
        }

        /// <summary>
        /// Used to display Values.
        /// </summary>
        private class ValueDisplay : HUDDisplay
        {
            /// <summary>
            /// Numerical value drawn to HUD.
            /// </summary>
            public float value;
            /// <summary>
            /// Value display constructor.
            /// </summary>
            public ValueDisplay()
            {
                type = DisplayType.VALUE;
            }
        }

        /// <summary>
        /// Used to display Images.
        /// </summary>
        public class ImageDisplay : HUDDisplay
        {
            /// <summary>
            /// Image drawn to HUD.
            /// </summary>
            public Texture2D image;
            /// <summary>
            /// X scale of image.
            /// </summary>
            public float xScale;
            /// <summary>
            /// Y scale of image.
            /// </summary>
            public float yScale;
            /// <summary>
            /// Image display constructor.
            /// Scale defaults to 1.
            /// </summary>
            public ImageDisplay()
            {
                xScale = 1.0f;
                yScale = 1.0f;
                type = DisplayType.IMAGE;
            }
        }

        /// <summary>
        /// Used to display image sequences
        /// </summary>
        public class ImageSpinner : HUDDisplay
        {
            /// <summary>
            /// Array of images
            /// </summary>
            public ImageDisplay[] images;
            /// <summary>
            /// Index of active image
            /// </summary>
            public int activeIndex;
            
            /// <summary>
            /// Constructor
            /// </summary>
            /// <param name="size">Size of Image Display</param>
            public ImageSpinner(int size)
            {
             
                this.activeIndex = 0;
                this.images = new ImageDisplay[size];
            }

            /// <summary>
            /// Add an image to our array
            /// </summary>
            /// <param name="val">Image</param>
            /// <param name="slot">Location</param>
            public void addImage(ImageDisplay val, int slot)
            {
                images[slot] = val;
            }
            /// <summary>
            /// Iterate to next image
            /// </summary>
            public void next()
            {
                if (this.images.Length <= this.activeIndex + 1)
                {
                    this.activeIndex = 0;
                }
                else
                {
                    this.activeIndex++;
                }
            }
            /// <summary>
            /// Iterate to previous image
            /// </summary>
            public void prev()
            {
                if (this.activeIndex == 0)
                {
                    this.activeIndex = this.images.Length - 1;
                }
                else
                {
                    this.activeIndex--;
                }
            }
        }

        /// <summary>
        /// Heads Up Display constructor.
        /// </summary>
        public HeadsUpDisplay()
        {
            playerIndex = 0;
        }
        /// <summary>
        /// Heads Up Display constructor with player index and predefined viewport.
        /// </summary>
        /// <param name="index">Player this HUD belongs to.</param>
        /// <param name="viewport">Player's viewport.</param>
        public HeadsUpDisplay(int index, Viewport viewport)
        {
            playerIndex = index;
            parentViewport = viewport;
        }

        // Methods:
        //*******************************************************************************************
        // Still buggy.. I need to come back to it later
        // Check for edges of the screen if playing on Xbox360
        private void AdjustForDeadZone(HUDDisplay element)
        {
#if false//XBOX360
            float deadZoneX = Statics.GAME_WINDOW_WIDTH * SIDES_DEAD_ZONE_PERCENT;

            float deadZoneY = Statics.GAME_WINDOW_HEIGHT * TOP_BOTTOM_DEAD_ZONE_PERCENT;

            Vector2 absolutePosition = Vector2.Zero + element.position;
            // Player 1 always in absolute coordinates
            // Check Player 2:
            if (playerIndex == 1)
            {
                if (Statics.TOTAL_PLAYERS_PLAYING == 2)
                {
                    absolutePosition += new Vector2(0, parentViewport.Height);
                }
                else
                {
                    absolutePosition += new Vector2(parentViewport.Width, 0);
                }
            }
            else if (playerIndex == 2)
            {
                absolutePosition += new Vector2(0, parentViewport.Height);
            }
            else if (playerIndex == 3)
            {
                absolutePosition += new Vector2(parentViewport.Width, parentViewport.Height);
            }
            // First check for the left side dead zone
            // If its on the left side
            if (absolutePosition.X < Statics.GAME_WINDOW_WIDTH * 0.5f)
            {
                if (playerIndex == 0 || (playerIndex == 1 && Statics.TOTAL_PLAYERS_PLAYING == 2) ||
                   (playerIndex == 2 && Statics.TOTAL_PLAYERS_PLAYING > 2))
                {
                    element.position.X += deadZoneX;
                }
            }
            // else.. check for right side
            else if (absolutePosition.X > Statics.GAME_WINDOW_WIDTH * 0.5f)
            {
                if (playerIndex == 1 || (playerIndex == 0 && Statics.TOTAL_PLAYERS_PLAYING <= 2) ||
                    playerIndex == 3)
                {
                    element.position.X -= deadZoneX;
                }
                
            }
            // Then check upper side
            if (absolutePosition.Y < Statics.GAME_WINDOW_HEIGHT * 0.5f)
            {
                if (playerIndex == 0 || (playerIndex == 1 && Statics.TOTAL_PLAYERS_PLAYING > 2))
                {
                    element.position.Y += deadZoneY;
                }
                
            }
            else if (absolutePosition.Y > Statics.GAME_WINDOW_HEIGHT * 0.5f)
            {
                if (playerIndex == 2 || playerIndex == 3 || (playerIndex == 0 && Statics.TOTAL_PLAYERS_PLAYING == 1) ||
                    (playerIndex == 1 && Statics.TOTAL_PLAYERS_PLAYING == 2))
                {
                    element.position.Y -= deadZoneY;
                }
            }
#endif
        }

        /// <summary>
        /// Add a Text display to the TextDisplay list.
        /// </summary>
        /// <param name="text">Text to add.</param>
        /// <param name="position">Position to locate text.</param>
        /// <param name="color">Color to display text with.</param>
        /// <returns>Count of text displays</returns>
        public int AddTextDisplay(string text, Vector2 position, Color color)
        {
            TextDisplay temp = new TextDisplay();
            temp.text = text;
            Vector2 size = FontWriter.Arial.MeasureString(text);
            temp.width = (int)(size.X);
            temp.height = (int)(size.Y);
            temp.position = position;
            AdjustForDeadZone(temp);
            temp.color = color;
            textDisplays.Add(temp);
            return textDisplays.Count - 1;
        }

        /// <summary>
        /// Add a Value display to the ValueDisplay list.
        /// </summary>
        /// <param name="text">Text to display.</param>
        /// <param name="value">Value to display.</param>
        /// <param name="position">Position to display value.</param>
        /// <param name="width">Width of value display.</param>
        /// <param name="height">Height of value display.</param>
        /// <param name="color">Color of value and text.</param>
        /// <returns>Count of value displays</returns>
        public int AddValueDisplay(string text, float value, Vector2 position, int width, int height, Color color)
        {
            ValueDisplay temp = new ValueDisplay();
            temp.text = text;
            temp.value = value;
            temp.width = width;
            temp.height = height;
            temp.position = position;
            AdjustForDeadZone(temp);
            temp.color = color;
            valueDisplays.Add(temp);
            return valueDisplays.Count - 1;
        }

        /// <summary>
        /// Add an Image display to our ImageDisplay list.
        /// </summary>
        /// <param name="image">Image to display.</param>
        /// <param name="position">Position to display value.</param>
        /// <param name="width">Width of value display.</param>
        /// <param name="height">Height of value display.</param>
        /// <param name="color">Color of value and text.</param>
        /// <param name="draw">Toggle to turn drawing on/off.</param>
        /// <returns>Count of image displays</returns>
        public int AddImageDisplay(Texture2D image, Vector2 position, int width, int height, Color color, bool draw)
        {
            ImageDisplay temp = new ImageDisplay();
            temp.image = image;
            temp.width = width;
            temp.height = height;
            temp.position = position;
            AdjustForDeadZone(temp);
            temp.color = color;
            temp.visible = draw;
            imageDisplays.Add(temp);
            return imageDisplays.Count - 1;
        }
        /// <summary>
        /// Add an Image spinner to our ImageDisplay list
        /// </summary>
        /// <param name="val">Image spinner to add</param>
        /// <returns>Count of image spinners</returns>
        public int AddImageSpinner(ImageSpinner val)
        {
            this.imageSpinners.Add(val);
            return imageSpinners.Count - 1;
        }

        /// <summary>
        /// Set the image spinner at index location to the next in-line
        /// </summary>
        /// <param name="index">location</param>
        public void SpinnerNext(int index)
        {
            if (index < 0 || index >= this.imageSpinners.Count)
            {
                // Invalid index
                return;
            }
            else
            {
                ImageSpinner temp = this.imageSpinners[index];
                temp.next();
                this.imageSpinners[index] = temp;
            }
        }
        /// <summary>
        /// Set the image spinner at index location to the previous inline
        /// </summary>
        /// <param name="index">location</param>
        public void SpinnerBack(int index)
        {
            if (index < 0 || index >= this.imageSpinners.Count)
            {
                // Invalid index
                return;
            }
            else
            {
                ImageSpinner temp = this.imageSpinners[index];
                temp.prev();
                this.imageSpinners[index] = temp;
            }
        }

        /// <summary>
        /// Set the active index to val in our image spinner at index
        /// </summary>
        /// <param name="index">location</param>
        /// <param name="val">Active value</param>
        public void SpinnerSet(int index, int val)
        {
            if (index < 0 || index >= this.imageSpinners.Count)
            {
                // Invalid index
                return;
            }
            ImageSpinner temp = this.imageSpinners[index];
            if (val < 0 || temp.images.Length <= val)
            {
                return;
            }
            else
            {                
                temp.activeIndex = val;
                this.imageSpinners[index] = temp;
            }
        }

        /// <summary>
        /// Method which allows us to change the text in a TextDisplay
        /// </summary>
        /// <param name="index">location</param>
        /// <param name="newText">New text</param>
        public void UpdateText(int index, string newText)
        {
            if (index < 0 || index >= textDisplays.Count)
            {
                // Invalid index
                return;
            }
            else
            {
                // Change the text
                textDisplays[index].text = newText;
            }
        }
        /// <summary>
        /// Updates the visibility of a text display
        /// </summary>
        /// <param name="index">location</param>
        /// <param name="newText">New text</param>
        /// <param name="vis">Visibility</param>
        /// <param name="color">Display color</param>
        public void UpdateTextVis(int index, string newText, bool vis, Color color)
         {
            if (index < 0 || index >= textDisplays.Count)
            {
                // Invalid index
                return;
            }
            else
            {
                // Change the text
                textDisplays[index].color = color;
                textDisplays[index].text = newText;
                textDisplays[index].visible = vis;
             }
        }

        /// <summary>
        /// Method which allows us to change the Value in a ValueDisplay.
        /// </summary>
        /// <param name="index">Location of ValueDisplay in list.</param>
        /// <param name="newValue">New value of value display.</param>
        public void UpdateValue(int index, float newValue)
        {
            if (index < 0 || index >= valueDisplays.Count)
            {
                // Invalid index
                return;
            }
            else
            {
                // Change the value
                valueDisplays[index].value = newValue;
            }
        }
        /// <summary>
        /// Updates the x and y scale of an image display
        /// </summary>
        /// <param name="index">Location of ValueDisplay in list.</param>
        /// <param name="xScale">X-scale value.</param>
        /// <param name="yScale">Y-scale value.</param>
        public void UpdateImageScale(int index, float xScale, float yScale)
        {
            if (index < 0 || index >= this.imageDisplays.Count)
            {
                // Invalid index
                return;
            }
            else
            {
                this.imageDisplays[index].xScale = xScale;
                this.imageDisplays[index].yScale = yScale;
            }
        }
        /// <summary>
        /// Change height of an image.
        /// </summary>
        /// <param name="index">Location of ValueDisplay in list.</param>
        /// <param name="amount">New height of Image..</param>
        public void UpdateImageHeight(int index, int amount)
        {
            if (index < 0 || index >= this.imageDisplays.Count)
            {
                // Invalid index
                return;
            }
            else
            {
                this.imageDisplays[index].height = amount;
            }
        }
        /// <summary>
        /// Chage position of image.
        /// </summary>
        /// <param name="index">Location of ValueDisplay in list.</param>
        /// <param name="newPosition">New position of image.</param>
        public void UpdateImagePosition(int index, Vector2 newPosition)
        {
            if (index < 0 || index >= this.imageDisplays.Count)
            {
                // Invalid index
                return;
            }
            else
            {
                this.imageDisplays[index].position = newPosition;
            }
        }
        /// <summary>
        /// Change whether image is drawn of not.
        /// </summary>
        /// <param name="index">Location of ValueDisplay in list.</param>
        /// <param name="value">True to draw image, false to hide.</param>
        public void UpdateImageDraw(int index, bool value)
        {
            if (index < 0 || index >= this.imageDisplays.Count)
            {
                // Invalid index
                return;
            }
            else
            {
                this.imageDisplays[index].visible = value;
            }
        }

        /// <summary>
        /// Method that sets a text display as visible or invisible.
        /// </summary>
        /// <param name="index">Location of ValueDisplay in list.</param>
        /// <param name="visible">True to draw image, false to hide.</param>
        public void UpdateTextVisible(int index, bool visible)
        {
            if (index < 0 || index >= textDisplays.Count)
            {
                // Invalid index
                return;
            }
            else
            {
                // Change the value
                textDisplays[index].visible = visible;
            }
        }

        /// <summary>
        /// Method which allows us to change the color of a TextDisplay.
        /// </summary>
        /// <param name="index">Location of ValueDisplay in list.</param>
        /// <param name="color">New color of text.</param>
        public void UpdateTextColor(int index, Color color)
        {
            if (index < 0 || index >= textDisplays.Count)
            {
                // Invalid index
                return;
            }
            else
            {
                // Change the value
                textDisplays[index].color = color;
            }
        }

        /// <summary>
        /// Default Draw function.
        /// </summary>
        /// <param name="spriteBatch">SpriteBatch used to draw used to draw.</param>
        public void Draw(SpriteBatch spriteBatch)
        {
            Draw(spriteBatch, 0, 0);
        }

        /// <summary>
        /// Draw function for drawing our displays at a certain offset position.
        /// NOTE: SpriteBatch Begin and End are handled outside this scope.
        /// </summary>
        /// <param name="spriteBatch">SpriteBatch used to draw used to draw.</param>
        /// <param name="xoffset">X-Offset to draw location.</param>
        /// <param name="yoffset">Y-Offset to draw location.</param>
        public void Draw(SpriteBatch spriteBatch, int xoffset, int yoffset)
        {
            foreach (TextDisplay element in textDisplays)
            {
                if (element.visible)
                {
                    spriteBatch.DrawString(FontWriter.Arial, element.text, element.position, element.color);
                }
            }

            foreach (ImageDisplay element in imageDisplays)
            {
                if (element.visible == true)
                {
                    spriteBatch.Draw(element.image,
                                     new Rectangle((int)element.position.X + xoffset,
                                                   (int)element.position.Y + yoffset,
                                                   element.width,
                                                   element.height),
                                     new Rectangle(0, 0, (int)(element.image.Width * element.xScale), (int)(element.image.Height * element.yScale)),
                                     element.color);
                }
            }

            foreach (ImageSpinner elementBig in imageSpinners)
            {
                if (elementBig.visible == true)
                {
                    ImageDisplay element = elementBig.images[elementBig.activeIndex];
                    spriteBatch.Draw(element.image,
                                    new Rectangle((int)element.position.X + xoffset,
                                                  (int)element.position.Y + yoffset,
                                                  element.width,
                                                  element.height),
                                    new Rectangle(0, 0, (int)(element.image.Width * element.xScale), (int)(element.image.Height * element.yScale)),
                                    element.color);
                }
            }
        }
    }
}