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

namespace DarkWynter.Engine.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 DarkWynter.Stream;

    #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>
        /// 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;
        }

        /// <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 = Statics_Stream.Fonts.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>
        /// Update/Replace an ImageDisplay
        /// </summary>
        /// <param name="index">Index of the image display</param>
        /// <param name="image">New image to use</param>
        /// <param name="position">New position</param>
        /// <param name="width">New width</param>
        /// <param name="height">New height</param>
        /// <param name="color">New Color</param>
        /// <param name="draw">To draw or not to draw</param>
        public void UpdateImageDisplay(int index, Texture2D image, Vector2 position, int width, int height, Color color, bool draw)
        {
            imageDisplays[index].image = image;
            imageDisplays[index].width = width;
            imageDisplays[index].height = height;
            imageDisplays[index].position = position;
            imageDisplays[index].color = color;
            imageDisplays[index].visible = draw;
        }

        /// <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>
        /// Update the Image's Source
        /// </summary>
        /// <param name="index">Location of ImageDisplay in list.</param>
        /// <param name="source">New Source on the Image File</param>
        public void UpdateImageSource(int index, Rectangle source)
        {
            if (index < 0 || index >= this.imageDisplays.Count)
            {
                // Invalid index
                return;
            }
            else
            {
                this.imageDisplays[index].Source = source;
            }
        }
        /// <summary>
        /// Get the Image's Position
        /// </summary>
        /// <param name="index">Location of ImageDisplay in list.</param>
        /// <returns>The Image at that index's position</returns>
        public Vector2 GetImagePosition(int index)
        {
            return this.imageDisplays[index].position;
        }
        /// <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>
        /// Change the image's visibility and color
        /// </summary>
        /// <param name="index">Index of the image in the HUD</param>
        /// <param name="visible">Boolean representing whether the image is drawn or not</param>
        /// <param name="color">The color to color the image</param>
        public void UpdateImageVis(int index, bool visible, Color color)
        {
            if (index < 0 || index >= this.imageDisplays.Count)
            {
                // Invalid index
                return;
            }
            else
            {
                this.imageDisplays[index].visible = visible;
                this.imageDisplays[index].color = color;
            }

        }


        /// <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 (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.Size.Width,
                                                   element.Size.Height),
                                     element.Source,
                                     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);
                }
            }

            foreach (TextDisplay element in textDisplays)
            {
                if (element.visible)
                {
                    spriteBatch.DrawString(Statics_Stream.Fonts.Arial, element.text, element.position, element.color);
                }
            }

        }
    }
}