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

namespace DarkWynter.Engine.Menus
{
    #region Using Statements
    using System;
    using System.Collections.Generic;
    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Graphics;
    using Microsoft.Xna.Framework.Content;
    using DarkWynter.Engine.Globals;
    using DarkWynter.Stream;
    #endregion



    /// <summary>
    /// Wrapper class for Game Menu Elements.
    /// </summary>
    public class GameMenuElement
    {
        /// <summary>
        /// Game menu title.
        /// </summary>
        protected string title = "Untitled";
        /// <summary>
        /// Element type from Enums_Engine.MenuElementType.
        /// </summary>
        protected Enums_Engine.MenuElementType type;
        /// <summary>
        /// Current visibility state of element.
        /// </summary>
        protected bool visible = true;
        /// <summary>
        /// Current x scale of element.
        /// </summary>
        protected float scaleX = 1.0f;
        /// <summary>
        /// Current y scale of element.
        /// </summary>
        protected float scaleY = 1.0f;
        /// <summary>
        /// Font used in this element.
        /// </summary>
        protected SpriteFont font = Statics_Stream.Fonts.ComicSans;
        /// <summary>
        /// Set to red by default, to provide easily noticable default color.
        /// </summary>
        protected Color color = Color.Red;

        /// <summary>
        /// Game Menu Element constructor.
        /// </summary>
        public GameMenuElement()
        {
            type = Enums_Engine.MenuElementType.NONE;
        }

        /// <summary>
        /// Accessor for element type.
        /// </summary>
        /// <returns>This element's type.</returns>
        public Enums_Engine.MenuElementType GetElementType()
        {
            return type;
        }

        /// <summary>
        /// Sets the element's scale.
        /// </summary>
        /// <param name="scaleX">X scale value</param>
        /// <param name="scaleY">Y scale value</param>
        public void SetScale(float scaleX, float scaleY)
        {
            this.scaleX = scaleX;
            this.scaleY = scaleY;
        }

        /// <summary>
        /// Gets the color of the SpriteFont
        /// </summary>
        /// <returns></returns>
        public Color GetColor()
        {
            return color;
        }

        public void SetColor(Color fontColor)
        {
            color = fontColor;
        }
        /// <summary>
        /// Gets the element's current font.
        /// </summary>
        /// <returns>Return's current spritefont</returns>
        public SpriteFont GetFont()
        {
            return font;
        }

        /// <summary>
        /// Sets the element's current font.
        /// </summary>
        /// <param name="font">SpriteFont to use.</param>
        public void SetFont(SpriteFont font)
        {
            this.font = font;
        }

        /// <summary>
        /// Gets the element's current x scale.
        /// </summary>
        /// <returns>Current X scale of element..</returns>
        public float GetScaleX()
        {
            return scaleX;
        }

        /// <summary>
        /// Gets the element's current y scale.
        /// </summary>
        /// <returns>Current Y scale of element.</returns>
        public float GetScaleY()
        {
            return scaleY;
        }

        /// <summary>
        /// Sets the element's title.
        /// </summary>
        /// <param name="title">Title of element.</param>
        public void SetTitle(string title)
        {
            this.title = title;
        }

        /// <summary>
        /// Gets the element's title.
        /// </summary>
        /// <returns>Title of element.</returns>
        public string GetTitle()
        {
            return title;
        }

        /// <summary>
        /// Hides this element from view.
        /// </summary>
        public void Hide()
        {
            visible = false;
        }

        /// <summary>
        /// Makes this element visible.
        /// </summary>
        public void Show()
        {
            visible = true;
        }

        /// <summary>
        /// Checks to see if element is currently visible.
        /// </summary>
        /// <returns>True if visible</returns>
        public bool isVisible()
        {
            return visible;
        }
    }
    
    /// <summary>
    /// 2D Label
    /// </summary>
    public class GameMenuLabel : GameMenuElement
    {
        /// <summary>
        /// Game Menu Lable constructor
        /// </summary>
        public GameMenuLabel()
        {
            type = Enums_Engine.MenuElementType.LABEL;
        }

        /// <summary>
        /// Game Menu Lable constructor with title.
        /// </summary>
        /// <param name="title">Title of the element.</param>
        public GameMenuLabel(string title)
        {
            type = Enums_Engine.MenuElementType.LABEL;
            this.title = title;
        }

        /// <summary>
        /// Game Menu Lable constructor with title.
        /// </summary>
        /// <param name="title">Title of the element.</param>
        public GameMenuLabel(string title, Color textColor)
        {
            type = Enums_Engine.MenuElementType.LABEL;
            this.color = textColor;
            this.title = title;
        }
    }

    /// <summary>
    /// 2D Image display
    /// </summary>
    public class GameMenuRandomImageDisplay : GameMenuElement
    {
        private List<Texture2D> images = new List<Texture2D>();
        private int selectedIndex = 0;
        private List<int> used = new List<int>();
        Random rand = new Random();

        /// <summary>
        /// Random Image Display constructor.
        /// </summary>
        public GameMenuRandomImageDisplay()
        {
            type = Enums_Engine.MenuElementType.IMAGE_DISPLAY;
        }

        /// <summary>
        /// Random Image Display constructor with title.
        /// </summary>
        /// <param name="title">Title of the Random Image Display.</param>
        public GameMenuRandomImageDisplay(string title)
        {
            type = Enums_Engine.MenuElementType.IMAGE_DISPLAY;
            this.title = title;
        }

        /// <summary>
        /// Add's an image to the Random Image Display.
        /// </summary>
        /// <param name="img">Image to add.</param>
        public void AddImage(Texture2D img)
        {
            images.Add(img);
        }

        /// <summary>
        /// Selects a random image to use.
        /// </summary>
        public void RandomIndex()
        {
            if (used.Count == images.Count)
            {
                used.Clear();
            }
            do
            {
                selectedIndex = rand.Next(images.Count);
            }
            while (used.Contains(selectedIndex));
            used.Add(selectedIndex);
        }

        /// <summary>
        /// Gets the current image being used.
        /// </summary>
        /// <returns>Image currently being used.</returns>
        public Texture2D GetCurrentTexture()
        {
            if (selectedIndex >= 0 && selectedIndex < images.Count)
            {
                return images[selectedIndex];
            }
            return null;
        }
    }

    /// <summary>
    /// 2D Button
    /// </summary>
    public class GameMenuButton : GameMenuElement
    {
        /// <summary>
        /// Game Menu Button constructor.
        /// </summary>
        public GameMenuButton()
        {
            type = Enums_Engine.MenuElementType.BUTTON;
        }

        /// <summary>
        /// Game Menu Button with title.
        /// </summary>
        /// <param name="title">Title of this Game Menu Button.</param>
        public GameMenuButton(string title)
        {
            this.title = title;
            type = Enums_Engine.MenuElementType.BUTTON;
        }
    }

    /// <summary>
    /// 2D Renderable 
    /// </summary>
    public class GameMenuValueInput : GameMenuElement
    {
        private int value = 0;
        private int maxValue = 0;
        private int minValue = 0;
        private int valueIncrement = 1;
        private float valueRatio = 0.0f;

        /// <summary>
        /// Constructor for Game Menu Value Input.
        /// </summary>
        public GameMenuValueInput()
        {
            type = Enums_Engine.MenuElementType.VALUE;
        }

        /// <summary>
        /// Constructor for Game Menu Value Input with predefined values.
        /// </summary>
        /// <param name="title">Title of this component.</param>
        /// <param name="minValue">Minimum value of this component.</param>
        /// <param name="maxValue">Maximum value of this component.</param>
        /// <param name="defaultValue">Initial/Default value of this component.</param>
        /// <param name="increment">Increment rate of this componenet.</param>
        public GameMenuValueInput(string title, int minValue, int maxValue, int defaultValue, int increment)
        {
            this.title = title;
            this.minValue = minValue;
            this.maxValue = maxValue;
            this.value = defaultValue;
            this.valueIncrement = increment;
            valueRatio = (float)this.value / (float)(this.maxValue - this.minValue);

            type = Enums_Engine.MenuElementType.VALUE;
        }

        /// <summary>
        /// Get current value of componenet.
        /// </summary>
        /// <returns>Current value.</returns>
        public int GetValue()
        {
            return value;
        }

        /// <summary>
        /// Set range of this componenet.
        /// </summary>
        /// <param name="min">Minimum allowed value.</param>
        /// <param name="max">Maximum allowed value.</param>
        public void SetRange(int min, int max)
        {
            maxValue = max;
            minValue = min;
            UpdateValueRatio();
        }

        /// <summary>
        /// Manually set the value of this component.
        /// </summary>
        /// <param name="val">Value to set this component to.</param>
        public void SetValue(int val)
        {
            if (val <= maxValue && val >= minValue)
            {
                value = val;
                UpdateValueRatio();
            }
        }

        private void UpdateValueRatio()
        {
            if (maxValue == minValue)
            {
                valueRatio = 1.0f;
            }
            else
            {
                valueRatio = ((float)this.value - this.minValue) / ((float)(this.maxValue - this.minValue));
            }
        }

        /// <summary>
        /// Ratio between minumum and maximum value of this component.
        /// </summary>
        /// <returns>Ratio of max and min values.</returns>
        public float GetValueRatio()
        {
            return valueRatio;
        }

        /// <summary>
        /// Increment value of component using predefined increment amount.
        /// </summary>
        public void Increment()
        {
            value += valueIncrement;
            if (value > maxValue)
            {
                value = maxValue;
            }
            UpdateValueRatio();
        }

        /// <summary>
        /// Decrement value of component using predefined increment amount.
        /// </summary>
        public void Decrement()
        {
            value -= valueIncrement;
            if (value < minValue)
            {
                value = minValue;
            }
            UpdateValueRatio();
        }
    }

    /// <summary>
    /// 2D Value Scroller
    /// </summary>
    public class GameMenuOption : GameMenuElement
    {
        private List<string> options = new List<string>();
        private int activeOptionIndex = 0;

        /// <summary>
        /// Constructor for Option selector.
        /// </summary>
        public GameMenuOption()
        {
            type = Enums_Engine.MenuElementType.OPTION;
        }

        /// <summary>
        /// Constructor for Option selector with title.
        /// </summary>
        /// <param name="title">Title of this component.</param>
        public GameMenuOption(string title)
        {
            this.title = title;
            type = Enums_Engine.MenuElementType.OPTION;
        }

        /// <summary>
        /// Add an option to this option selector.
        /// </summary>
        /// <param name="option">Displayed text.</param>
        public void AddOption(string option)
        {
            options.Add(option);
        }

        /// <summary>
        /// Add a list of options to this option selector.
        /// </summary>
        /// <param name="optionList">List of displayed text.</param>
        public void SetOption(List<string> optionList)
        {
            options = optionList;
        }

        /// <summary>
        /// Set currently displayed option text.
        /// </summary>
        /// <param name="index">Index of option to display.</param>
        public void SetCurrentIndex(int index)
        {
            activeOptionIndex = index;
        }

        /// <summary>
        /// Select the previous option in the list.
        /// </summary>
        public void PreviousOption()
        {
            activeOptionIndex--;
            if (activeOptionIndex < 0)
            {
                activeOptionIndex = 0;
            }
        }

        /// <summary>
        /// Select the next option in the list.
        /// </summary>
        public void NextOption()
        {
            activeOptionIndex++;
            if (activeOptionIndex >= options.Count)
            {
                activeOptionIndex = options.Count - 1;
            }
        }

        /// <summary>
        /// Get the current option's text.
        /// </summary>
        /// <returns>Current option's text.</returns>
        public string GetActiveOption()
        {
            return options[activeOptionIndex];
        }

        /// <summary>
        /// Get the current option's index.
        /// </summary>
        /// <returns>Current option's index.</returns>
        public int GetActiveIndex()
        {
            return activeOptionIndex;
        }
    }

    /// <summary>
    /// Image with multiple selectable components.
    /// </summary>
    public class GameMenuImageScroller : GameMenuElement
    {
        /// <summary>
        /// An image scrolling item
        /// </summary>
        public struct ImageScrollItem
        {
            /// <summary>
            /// Inactive image
            /// </summary>
            public Texture2D offImage;
            /// <summary>
            /// Active image
            /// </summary>
            public Texture2D onImage;
            /// <summary>
            /// Screen X position of image
            /// </summary>
            public int x;
            /// <summary>
            /// Screen Y position of image
            /// </summary>
            public int y;
            /// <summary>
            /// Name of the Item
            /// </summary>
            public string name;
        };

        private int maxVisibleAtATime = 0;
        List<ImageScrollItem> items = new List<ImageScrollItem>();
        private int activeItemIndex = 0;

        /// <summary>
        /// Default Constructor
        /// </summary>
        public GameMenuImageScroller()
        {
            type = Enums_Engine.MenuElementType.IMAGE_SCROLL;
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="title">The title of the Menu</param>
        /// <param name="numVisible">The number of visible lines?</param>
        public GameMenuImageScroller(string title, int numVisible)
        {
            maxVisibleAtATime = numVisible;
            this.title = title;
            type = Enums_Engine.MenuElementType.IMAGE_SCROLL;
        }

        private void AddNew(string name, Texture2D onImage, Texture2D offImage, int x, int y)
        {
            ImageScrollItem item = new ImageScrollItem();
            item.name = name;
            item.onImage = onImage;
            item.offImage = offImage;
            item.x = x;
            item.y = y;
            items.Add(item);
        }

        private void AddNew(string name, Texture2D onImage, Texture2D offImage)
        {
            ImageScrollItem item = new ImageScrollItem();
            item.name = name;
            item.onImage = onImage;
            item.offImage = offImage;
            item.x = -1;
            item.y = -1;
            items.Add(item);
        }

        /// <summary>
        /// Retrieve the Item at index location
        /// </summary>
        /// <param name="index">Location</param>
        /// <returns>ImageScrollItem</returns>
        public ImageScrollItem GetItemAt(int index)
        {
            if (index >= 0 && index < items.Count)
            {
                return items[index];
            }
            return new ImageScrollItem();
        }

        /// <summary>
        /// Returns the number of items in the Menu
        /// </summary>
        /// <returns>Number of items in the Menu</returns>
        public int GetNumItems()
        {
            return items.Count;
        }

        /// <summary>
        /// Returns the maximum number of visible items in a Menu
        /// </summary>
        /// <returns>Maximum number of visible items in a Menu</returns>
        public int GetMaxItemsVisible()
        {
            return maxVisibleAtATime;
        }

        private void Clear()
        {
            activeItemIndex = 0;
            items.Clear();
        }

        /// <summary>
        /// Sets the previous item as the current one
        /// </summary>
        public void PreviousItem()
        {
            activeItemIndex--;
            if (activeItemIndex < 0)
            {
                activeItemIndex = items.Count - 1;
            }
        }

        /// <summary>
        /// Sets the next item as the current one
        /// </summary>
        public void NextItem()
        {
            activeItemIndex++;
            if (activeItemIndex >= items.Count)
            {
                activeItemIndex = 0;
            }
        }

        private ImageScrollItem GetActiveItem()
        {
            return items[activeItemIndex];
        }

        /// <summary>
        /// Returns the index of the active item
        /// </summary>
        /// <returns>Index of active item</returns>
        public int GetActiveIndex()
        {
            return activeItemIndex;
        }

        /// <summary>
        /// Sets the item at index to the current one
        /// </summary>
        /// <param name="index">Location</param>
        public void SetCurrentIndex(int index)
        {
            if (index >= 0 || index < items.Count)
            {
                activeItemIndex = index;
            }
        }
    }

    /// <summary>
    /// GameMenu is used by a GameScreen.
    /// It contains a list of GameMenuElements such as Buttons, Options, and Scrollers 
    /// that are defined by classes that override GameScreen.
    /// </summary>
    public class GameMenu
    {
        private string title = "Untitled Menu";
        private List<GameMenuElement> menuElements = new List<GameMenuElement>();
        private int selectedElementIndex = 0;
        private Vector2 position = new Vector2();
        private const int SLIDER_WIDTH = 150;
        private const int SLIDER_HEIGHT = 30;
        private bool drawMenuTitle = true;
        private Texture2D sliderBackground;

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="title">Name of the Menu</param>
        /// <param name="x">Screen X position</param>
        /// <param name="y">Screen Y positiong</param>
        public GameMenu(string title, float positionX, float positionY)
        {
            this.title = title;
            position.X = positionX;
            position.Y = positionY;
            sliderBackground = Statics_Engine.SystemSettings.content.Load<Texture2D>("Content/_textures/SliderImproved");
        }

        /// <summary>
        /// Sets whether the menu is drawn or not
        /// </summary>
        /// <param name="draw">Yes or No</param>
        public void SetDrawMenuTitle(bool draw)
        {
            drawMenuTitle = draw;
        }
        
        /// <summary>
        /// Sets the menu title
        /// </summary>
        /// <param name="title">Name</param>
        public void SetTitle(string title)
        {
            this.title = title;
        }

        /// <summary>
        /// Sets the position where the menu will be drawn
        /// </summary>
        /// <param name="x">X</param>
        /// <param name="y">Y</param>
        public void SetPosition(float x, float y)
        {
            position.X = x;
            position.Y = y;
        }

        /// <summary>
        /// Adds a new menu Button
        /// </summary>
        /// <param name="visible">To draw or not to draw</param>
        /// <param name="title">Name</param>
        public void AddMenuButton(bool visible, string title)
        {
            AddMenuButton(title);
            if (!visible)
            {
                GetMenuElement(title).Hide();
            }
        }

        /// <summary>
        /// Adds a new menu Button
        /// </summary>
        /// <param name="title">Name</param>
        public void AddMenuButton(string title)
        {
            menuElements.Add(new GameMenuButton(title));
        }

        /// <summary>
        /// Adds a new Menu Option Item
        /// </summary>
        /// <param name="visible">To draw or not to draw</param>
        /// <param name="title">Name</param>
        /// <param name="options">String array of options</param>
        public void AddMenuOption(bool visible, string title, params string[] options)
        {
            AddMenuOption(title,options);
            if (!visible)
            {
                GetMenuElement(title).Hide();
            }
        }

        /// <summary>
        /// Adds a new Menu Option Item
        /// </summary>
        /// <param name="title">Name</param>
        /// <param name="options">String array of options</param>
        public void AddMenuOption(string title, params string[] options)
        {
            GameMenuOption element = new GameMenuOption(title);
            foreach (string s in options)
            {
                element.AddOption(s);
            }

            menuElements.Add(element);
        }

        /// <summary>
        /// Adds a new image display which randomly displays a different image
        /// </summary>
        /// <param name="title">Name</param>
        /// <param name="images">Array of images</param>
        public void AddRandomImageDisplay(string title, params Texture2D[] images)
        {
            GameMenuRandomImageDisplay element = new GameMenuRandomImageDisplay(title);
            foreach (Texture2D image in images)
            {
                element.AddImage(image);
            }

            menuElements.Add(element);
        }

        /// <summary>
        /// Sets the list of options for a particular Menu option item
        /// </summary>
        /// <param name="optionList">New list of options</param>
        /// <param name="optionNumber">Index of menu option item</param>
        public void SetMenuOption(List<string> optionList, int optionNumber)
        {
            GameMenuOption menuOptions = (GameMenuOption)menuElements[optionNumber];
            menuOptions.SetOption(optionList);
        }

        private void AddValueInput(bool visible, string title, int minValue, int maxValue, int defaultValue, int increment)
        {
            AddValueInput(title, minValue, maxValue, defaultValue, increment);
            if (!visible)
            {
                GetMenuElement(title).Hide();
            }
        }

        /// <summary>
        /// Adds a new Menu value-based item
        /// </summary>
        /// <param name="title">Name</param>
        /// <param name="minValue">Minimum Value</param>
        /// <param name="maxValue">Maximum Value</param>
        /// <param name="defaultValue">Default value</param>
        /// <param name="increment">Increments</param>
        public void AddValueInput(string title, int minValue, int maxValue, int defaultValue, int increment)
        {
            GameMenuValueInput valueInput = new GameMenuValueInput(title, minValue, maxValue, defaultValue, increment);
            menuElements.Add(valueInput);
        }

        /// <summary>
        /// Adds a new Menu image scroller item
        /// </summary>
        /// <param name="title">Name</param>
        /// <param name="numVisible">Number of visible lines?</param>
        public void AddImageScroller(string title, int numVisible)
        {
            GameMenuImageScroller element = new GameMenuImageScroller(title, numVisible);
            menuElements.Add(element);
        }

        /// <summary>
        /// Adds a new Menu Label item
        /// </summary>
        /// <param name="title">Name</param>
        public void AddLabel(string title, Color textColor)
        {
            GameMenuLabel label = new GameMenuLabel(title, textColor);
            menuElements.Add(label);
        }

        /// <summary>
        /// Adds a new Menu Label item
        /// </summary>
        /// <param name="title">Name</param>
        public void AddLabel(string title)
        {
            GameMenuLabel label = new GameMenuLabel(title);
            menuElements.Add(label);
        }

        /// <summary>
        /// Sets the current menu element to the previous menu element
        /// </summary>
        public void PreviousMenuElement()
        {
            selectedElementIndex--;
            if (selectedElementIndex < 0)
            {
                selectedElementIndex = 0;
            }

            if (GetActiveMenuElement().isVisible() == false)
            {
                    PreviousMenuElement();
            }

            if (GetActiveMenuElement().GetElementType() == Enums_Engine.MenuElementType.LABEL)
            {
                if (selectedElementIndex == 0)
                {
                    NextMenuElement();
                }
                else
                {
                    PreviousMenuElement();
                }
            }
        }

        /// <summary>
        /// Sets the current menu element to the next menu element
        /// </summary>
        public void NextMenuElement()
        {
            selectedElementIndex++;
            if (selectedElementIndex >= menuElements.Count)
            {
                selectedElementIndex = menuElements.Count - 1;
            }

            if (GetActiveMenuElement().isVisible() == false)
            {
                NextMenuElement();
            }

            if (GetActiveMenuElement().GetElementType() == Enums_Engine.MenuElementType.LABEL)
            {
                if (selectedElementIndex == menuElements.Count - 1)
                {
                    PreviousMenuElement();
                }
                else
                {
                    NextMenuElement();
                }
            }
        }

        /// <summary>
        /// Returns the Name of the current Game Menu
        /// </summary>
        /// <returns>String name of current Game Menu</returns>
        public string GetTitle()
        {
            return title;
        }

        /// <summary>
        /// Returns the current active menu element
        /// </summary>
        /// <returns>Menu Element</returns>
        public GameMenuElement GetActiveMenuElement()
        {
            return menuElements[selectedElementIndex];
        }

        /// <summary>
        /// Returns the index of the current active menu element
        /// </summary>
        /// <returns>Index of the current active menu element</returns>
        public int GetActiveIndex()
        {
            return selectedElementIndex;
        }

        /// <summary>
        /// Returns the Menu element at index
        /// </summary>
        /// <param name="index">Index of element to retrieve</param>
        /// <returns>Menu Element</returns>
        public GameMenuElement GetMenuElement(int index)
        {
            return menuElements[index];
        }

        /// <summary>
        /// Returns the first Menu element which has a matching title
        /// </summary>
        /// <param name="title">Search name</param>
        /// <returns>Menu Element</returns>
        public GameMenuElement GetMenuElement(string title)
        {
            foreach (GameMenuElement element in menuElements)
            {
                if (element.GetTitle() == title)
                {
                    return element;
                }
            }
            return new GameMenuElement();
        }

        /// <summary>
        /// Returns the first Menu element found with a matching title after the starting index
        /// </summary>
        /// <param name="title">Search name</param>
        /// <param name="fromIndex">Search index start</param>
        /// <returns>Menu Element</returns>
        public GameMenuElement GetMenuElement(string title, int fromIndex)
        {
            for (int i = fromIndex; i < menuElements.Count; i++)
            {
                if (menuElements[i].GetTitle() == title)
                {
                    return menuElements[i];
                }
            }
            return new GameMenuElement();
        }

        /// <summary>
        /// Sets the font for all menu items
        /// </summary>
        /// <param name="font">Font</param>
        public void SetFont(SpriteFont font)
        {
            for (int i = 0; i < menuElements.Count; i++)
            {
                menuElements[i].SetFont(font);
            }
        }

        /// <summary>
        /// Draw function
        /// </summary>
        /// <param name="spriteBatch">Spritebatch</param>
        public void Draw(SpriteBatch spriteBatch)
        {
            float yPosition = position.Y;
            int titleLength = 0;
            float scaleX = (Statics_Stream.RenderSettings.GAME_WINDOW_WIDTH / 1280.0f);
            float scaleY = (Statics_Stream.RenderSettings.GAME_WINDOW_HEIGHT / 1024.0f);

            // Draw Header
            if (drawMenuTitle)
            {
                spriteBatch.DrawString(Statics_Stream.Fonts.ComicSans, title, new Vector2(position.X, position.Y), Color.White);
                
                Vector2 size = Statics_Stream.Fonts.ComicSans.MeasureString(title);
                
                //Extra padding below the big font
                yPosition += size.Y;
            }

            // Draw menu elements
            for (int i = 0; i < menuElements.Count; i++)
            {
                if (menuElements[i].isVisible() == true)
                {
                     spriteBatch.DrawString(menuElements[i].GetFont(), menuElements[i].GetTitle(), new Vector2(position.X, yPosition), menuElements[i].GetColor());

                    Vector2 stringSize = menuElements[i].GetFont().MeasureString(menuElements[i].GetTitle());
                    titleLength = (int)(stringSize.X) + 10;

                    // Option Selectors
                    if (menuElements[i].GetElementType() == Enums_Engine.MenuElementType.OPTION)
                    {
                        GameMenuOption option = (GameMenuOption)menuElements[i];
                        spriteBatch.DrawString(menuElements[i].GetFont(), option.GetActiveOption(), new Vector2(position.X + titleLength, yPosition), Color.White);
                    }

                    // Value Selectors
                    if (menuElements[i].GetElementType() == Enums_Engine.MenuElementType.VALUE)
                    {
                        GameMenuValueInput valueSlider = (GameMenuValueInput)menuElements[i];
                        spriteBatch.Draw(sliderBackground, 
                                         new Rectangle((int)(position.X) + titleLength, (int)(yPosition), SLIDER_WIDTH, SLIDER_HEIGHT), 
                                         Color.Honeydew);

                        //Draw the actual slider value here
                        spriteBatch.Draw(sliderBackground, 
                                         new Rectangle((int)(position.X) + titleLength, 
                                                       (int)(yPosition), 
                                                       (int)(SLIDER_WIDTH * valueSlider.GetValueRatio()),
                                                       SLIDER_HEIGHT), 
                                         Color.DarkRed);

                        spriteBatch.DrawString(menuElements[i].GetFont(), "" + valueSlider.GetValue(), new Vector2(position.X + titleLength + (SLIDER_WIDTH / 2), yPosition - 3), Color.Black);

                    }

                    // Image Displays
                    if (menuElements[i].GetElementType() == Enums_Engine.MenuElementType.IMAGE_DISPLAY)
                    {
                        GameMenuRandomImageDisplay imageDisplay = (GameMenuRandomImageDisplay)menuElements[i];

                        Texture2D image = imageDisplay.GetCurrentTexture();
                        //yPosition += (160 * scaleY);
                        if (image != null)
                        {
                            spriteBatch.Draw(image, new Rectangle((int)(position.X),
                                                                  (int)(yPosition),
                                                                  (int)(image.Width * imageDisplay.GetScaleX() * scaleX),
                                                                  (int)(image.Height * imageDisplay.GetScaleY() * scaleY)), Color.White);
                            
                            yPosition += (image.Height + 50) * scaleY;
                        }
                    }

                    #region Image Scrollers
                    if (menuElements[i].GetElementType() == Enums_Engine.MenuElementType.IMAGE_SCROLL)
                    {
                        GameMenuImageScroller scroller = (GameMenuImageScroller)menuElements[i];
                        int numItems = scroller.GetNumItems();
                        int maxItems = scroller.GetMaxItemsVisible();
                        int activeIndex = scroller.GetActiveIndex();
                        yPosition += 8;

                        //if the window is smaller than the list.. start with the active one
                        for (int index = (maxItems < numItems) ? activeIndex : 0; 
                            index < ((maxItems < numItems)? activeIndex+maxItems : maxItems); index++)
                        {
                            if (index >= numItems)
                            {
                                break;
                            }
                            GameMenuImageScroller.ImageScrollItem item = scroller.GetItemAt(index);
                            float x, y;

                            if (item.x == -1){x = position.X;}
                            else{x = item.x;}

                            if (item.y == -1){y = yPosition;}
                            else{y = item.y;}

                            if (scroller.GetActiveIndex() == index)
                            {
                                if (item.onImage != null)
                                {
                                    // Draw Selected Button Image
                                    spriteBatch.Draw(item.onImage, new Rectangle((int)(x),
                                                                                 (int)(y),
                                                                                 (int)(item.onImage.Width * scroller.GetScaleX() * scaleX),
                                                                                 (int)(item.onImage.Height * scroller.GetScaleY() * scaleY)), Color.White);
                                }
                            }
                            else
                            {
                                if (item.offImage != null)
                                {
                                    // Draw Deselected Button Image
                                    spriteBatch.Draw(item.offImage, new Rectangle((int)(x),
                                                                                 (int)(y),
                                                                                 (int)(item.offImage.Width * scroller.GetScaleX() * scaleX),
                                                                                 (int)(item.offImage.Height * scroller.GetScaleY() * scaleY)), Color.White);
                                }
                            }
                            int heightOffset = 0;
                            if (item.offImage != null)
                            {
                                heightOffset = item.offImage.Height;
                            }
                            yPosition += (heightOffset + 50) * scaleY;
                        }
                    }
                    #endregion

                    yPosition += stringSize.Y + 20;
                }
            }
        }
    }
}