//---------------------------------------------------------------------------------------------------------------------------------------------------
// <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 System.Diagnostics;
        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;
        using DarkWynter.Engine.Globals;
        using System.ComponentModel;
        using DarkWynter.Stream.UIInterfacing;

        #endregion

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


        // Screen dead zone percenta    ge
        private const float SIDES_DEAD_ZONE_PERCENT = 0.05f;
        private const float TOP_BOTTOM_DEAD_ZONE_PERCENT = 0.03f;

        private Vector2 DIALOGUE_LOCATION = new Vector2(20, 500);
        private Vector2 SPEAKER_OFFSET = new Vector2(25, 10);
        private Vector2 TEXT_OFFSET = new Vector2(20, 50);

        private int playerIndex = 0;
        private int dialogueBoxIndex;
        private int speakerTextIndex;
        private int dialogueTextIndex;
        private int displayLength = 0;

        private Texture2D dialogueBoxTexture;
        private Texture2D successTexture;

        private Stopwatch ReadTimer = new Stopwatch();
        private  Stopwatch ImageTimer = new Stopwatch();


            public List<TextDisplay_old> textDisplays { get { return _textDisplays; } set { _textDisplays = value; } }
            private List<TextDisplay_old> _textDisplays = new List<TextDisplay_old>();

            public List<ImageDisplay_old> imageDisplays { get { return _imageDisplays; } set { _imageDisplays = value; } }
            public List<ImageDisplay_old> _imageDisplays = new List<ImageDisplay_old>();

            public List<ValueDisplay_old> valueDisplays { get { return _valueDisplays; } set { _valueDisplays = value; } }
            private List<ValueDisplay_old> _valueDisplays = new List<ValueDisplay_old>();

            public List<ImageSpinner_old> imageSpinners { get { return _imageSpinners; } set { _imageSpinners = value; } }
            private List<ImageSpinner_old> _imageSpinners = new List<ImageSpinner_old>();



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

            InitializeDialogControl();
        }
        /// <summary>
        /// Inits the dialogue control system
        /// </summary>
        public void InitializeDialogControl()
        {

            ReadTimer.Reset();
            
            dialogueBoxTexture = Statics_Engine.SystemSettings.content.Load<Texture2D>("Content/_textures/dialogueBox");

            DIALOGUE_LOCATION.X = 20;
            DIALOGUE_LOCATION.Y = Statics_Stream.RenderSettings.cameraList[0].viewport.Height - (dialogueBoxTexture.Height + 10);

            dialogueBoxIndex = AddImageDisplay(dialogueBoxTexture, DIALOGUE_LOCATION, dialogueBoxTexture.Width,
                dialogueBoxTexture.Height, Color.White, false);

            speakerTextIndex = AddTextDisplay("", DIALOGUE_LOCATION + SPEAKER_OFFSET, Color.White);

            UpdateTextVisible(speakerTextIndex, false);

            dialogueTextIndex = AddTextDisplay("", DIALOGUE_LOCATION + TEXT_OFFSET, Color.White);

            UpdateTextVisible(dialogueTextIndex, false);

        }
        /// <summary>
        /// Shows the dialogue
        /// </summary>
        /// <param name="backgroundImage">Which image to post in the background</param>
        /// <param name="speaker">Who is talking</param>
        /// <param name="message">What the message is</param>
        /// <param name="color">Color of the text</param>
        public void ShowDialog(Texture2D backgroundImage, string speaker, string message, Color color)
        {
            UpdateImageDisplay(dialogueBoxIndex, backgroundImage, DIALOGUE_LOCATION, backgroundImage.Width, backgroundImage.Height, Color.White, true);
            UpdateImageVis(dialogueBoxIndex, true, color);
            UpdateTextVis(speakerTextIndex, speaker, true, Color.White);
            UpdateTextVis(dialogueTextIndex, message, true, Color.White);
        }
        /// <summary>
        /// Removes the dialogue from the HUD
        /// </summary>
        public void RemoveDialog()
        {
            UpdateImageVis(dialogueBoxIndex, false, Color.White);
            UpdateTextVis(speakerTextIndex, "ERROR", false, Color.White);
            UpdateTextVis(dialogueTextIndex, "YOU SHOULDN'T EVER SEE THIS", false, Color.White);
        }
        /// <summary>
        /// Displays the dialogue on the HUD
        /// </summary>
        /// <param name="backgroundImage">Which image to post in the background</param>
        /// <param name="speaker">Who is talking</param>
        /// <param name="message">What the message is</param>
        /// <param name="color">Color</param>
        /// <param name="limitMilli">Time limit to display message</param>
        public void DisplayDialog(Texture2D backgroundImage, string speaker, string message, Color color, int limitMilli)
        {
            displayLength = limitMilli;

            if (!ReadTimer.IsRunning)
            {
                displayLength = limitMilli;
                ReadTimer.Start();
            }
            else
            {
                displayLength = limitMilli;
                ReadTimer.Reset();
            }

            ShowDialog(backgroundImage, speaker, message, color);

        }
        /// <summary>
        /// Removes dialogue once time limit expires
        /// </summary>
        public void UpdateDialogue()
        {
            //Remove dialogue once the limit has passed
            if (ReadTimer.ElapsedMilliseconds >= displayLength)
            {
                RemoveDialog();
                ReadTimer.Reset();
                displayLength = 0;
            }
        }
        /// <summary>
        /// Resizes the HUD based on viewport change
        /// </summary>
        /// <param name="HudScaleMultiplier">The ratio between old viewport and resized viewport</param>
        public void Resize(Vector2 HudScaleMultiplier)
        {
            // Handle the dialogue stuff first...have to handle seperatly so HACK...
            DIALOGUE_LOCATION.X = DIALOGUE_LOCATION.X * HudScaleMultiplier.X;
            DIALOGUE_LOCATION.Y = DIALOGUE_LOCATION.Y * HudScaleMultiplier.Y;
       
            SPEAKER_OFFSET.X = DIALOGUE_LOCATION.X * HudScaleMultiplier.X;
            SPEAKER_OFFSET.Y = DIALOGUE_LOCATION.Y * HudScaleMultiplier.Y;

            TEXT_OFFSET.X = TEXT_OFFSET.X * HudScaleMultiplier.X;
            TEXT_OFFSET.Y = TEXT_OFFSET.Y  *HudScaleMultiplier.Y;

            for (int i = 0; i < textDisplays.Count; i++)
            {
                textDisplays[i].position.X = textDisplays[i].position.X * HudScaleMultiplier.X;
                textDisplays[i].position.Y = textDisplays[i].position.Y * HudScaleMultiplier.Y;
            }
            for (int i = 0; i < _valueDisplays.Count; i++)
            {
                _valueDisplays[i].position.X = _valueDisplays[i].position.X * HudScaleMultiplier.X;
                _valueDisplays[i].position.Y = _valueDisplays[i].position.Y * HudScaleMultiplier.Y;
            }
            for (int i = 0; i < _imageDisplays.Count; i++)
            {
                _imageDisplays[i].position.X = _imageDisplays[i].position.X * HudScaleMultiplier.X;
                _imageDisplays[i].position.Y = _imageDisplays[i].position.Y * HudScaleMultiplier.Y;
            }
            for (int i = 0; i < imageSpinners.Count; i++)
            {
                imageSpinners[i].position.X = imageSpinners[i].position.X * HudScaleMultiplier.X;
                imageSpinners[i].position.Y = imageSpinners[i].position.Y * HudScaleMultiplier.Y;
            }


        }

        public void TimedMessage(string text, Vector2 position, Color color, float timeLimit)
        {
            int sharkIndex = DarkWynterEngine._HUD.AddTextDisplay(text, position, color);
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            
            
        }
        
        /// <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_old temp = new TextDisplay_old();
            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_old temp = new ValueDisplay_old();
            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_old temp = new ImageDisplay_old();
            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;
        }
        # region Spinner
        /// <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_old 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_old 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_old 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_old temp = this.imageSpinners[index];
            if (val < 0 || temp.images.Length <= val)
            {
                return;
            }
            else
            {
                temp.activeIndex = val;
                this.imageSpinners[index] = temp;
            }
        }

        #endregion

        /// <summary>
        /// Update Hud events.
        /// </summary>
        public void Update()
        {
            UpdateDialogue();
        }
        /// <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] = new ImageDisplay_old();
            _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_old 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_old 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_old element in textDisplays)
            {
                if (element.visible)
                {
                    spriteBatch.DrawString(Statics_Stream.Fonts.Arial, element.text, element.position, element.color);
                }
            }

        }
    }
}