//---------------------------------------------------------------------------------------------------------------------------------------------------
// <copyright file="ScreenObject.cs" company="DarkWynter Studios">
//     Copyright (C)2007 DarkWynter Studios.  All rights reserved.
// </copyright>
//---------------------------------------------------------------------------------------------------------------------------------------------------
// {License Information: Creative Commons}
//---------------------------------------------------------------------------------------------------------------------------------------------------


using System;
using System.Collections.Generic;
using System.Text;
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 System.ComponentModel;
using System.Xml;
using DWGame.Globals;
using DW.Stream;


namespace DW.UserInterface_2D
{
    /// <summary>
    /// Base class for all types.
    /// </summary>
    public class ScreenObject
    {

        /// <summary>
        /// Text string drawn to HUD.
        /// </summary>
        public string text = "";
        public string _text { get { return text; } set { text = value; } }

        /// <summary>
        /// Position of HUD element.
        /// </summary>
        public Vector2 position = new Vector2();
        public Vector2 _position { get { return position; } set { position = value; } }

        /// <summary>
        /// Width of HUD element.
        /// </summary>
        public int width;
        public int _width { get { return width; } set { width = value; } }

        /// <summary>
        /// Height of HUD element.
        /// </summary>
        public int height;
        public int _height { get { return height; } set { height = value; } }

        /// <summary>
        /// Color of text element.
        /// </summary>
        public Color color;
        public Color _color { get { return color; } set { color = value; } }

        /// <summary>
        /// Type of HUD element.
        /// </summary>
        public DisplayType type = DisplayType.BASE;
        public DisplayType _type { get { return type; } set { type = value; } }

        /// <summary>
        /// Visibility of HUD element.
        /// </summary>
        public bool visible = true;
        public bool _visible { get { return visible; } set { visible = value; } }

        /// <summary>
        /// Time limit for the text display
        /// </summary>
        public float timeLimit;
        public float _timeLimit { get { return timeLimit; } set { timeLimit = value; } }

        /// <summary>
        /// Stopwatch to regulate time limit
        /// </summary>
        public Stopwatch stopWatch = new Stopwatch();
        public Stopwatch _stopWatch { get { return stopWatch; } set { stopWatch = value; } }


        /// <summary>
        /// Rotation of HUD element.
        /// </summary>
        public float rotation;
        public float _rotation { get { return rotation; } set { rotation = value; } }

        public static Color GetColor(XmlNode node)
        {
            return new Color(
                byte.Parse(node.Attributes["colorR"].Value), byte.Parse(node.Attributes["colorG"].Value),
                byte.Parse(node.Attributes["colorB"].Value), byte.Parse(node.Attributes["colorA"].Value)
                );
        }

    };


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

    /// <summary>
    /// Used to display Text.
    /// </summary>
    public class TextDisplay : ScreenObject
    {
        string mName;
        /// <summary>
        /// Sets the image and defaults the source to the entire image
        /// </summary>
        public string name
        {
            get { return mName; }
            set
            {
                mName = value;
            }
        }

        /// <summary>
        /// Text display constructor.
        /// </summary>
        public TextDisplay()
        {
            type = DisplayType.TEXT;
        }

        /// <summary>
        /// Text display constructor.
        /// </summary>
        public TextDisplay(XmlNode node)
        {
            type = DisplayType.TEXT;

            name = node.Attributes["nameID"].Value;
            position = new Vector2(int.Parse(node.Attributes["posX"].Value), int.Parse(node.Attributes["posY"].Value));
            visible = bool.Parse(node.Attributes["toDraw"].Value);
            color = GetColor(node);

            text = node.Attributes["text"].Value;
        }
    }



    /// <summary>
    /// Used to display Images.
    /// </summary>
    public class ImageDisplay : ScreenObject
    {
        /// <summary>
        /// Image drawn to HUD.
        /// Edit by Drew: I changed this so that there is a "Source" property in the image... 
        /// this is used for my health bar. Getters and setters change eachother appropriately.
        /// References that use Width*Scale in existing code will just be left alone.
        /// </summary>


        string mName;
        /// <summary>
        /// Sets the image and defaults the source to the entire image
        /// </summary>
        public string name
        {
            get { return mName; }
            set
            {
                mName = value;

            }
        }

        Texture2D mImage;
        /// <summary>
        /// Sets the image and defaults the source to the entire image
        /// </summary>
        public Texture2D image
        {
            get { return mImage; }
            set
            {
                mImage = value;
                Source = new Rectangle(0, 0, image.Width, image.Height);
            }
        }
        /// <summary>
        /// X scale of image.
        /// </summary>
        public float xScale;
        /// <summary>
        /// Y scale of image.
        /// </summary>
        public float yScale;

        /// <summary>
        /// Contains the size of the image (source/scale)
        /// This is only different from Texture Dimension * scale when 
        /// the source is changed... i.e. only on my health bars
        /// </summary>
        public Rectangle Size;

        Rectangle mSource;
        /// <summary>
        /// Changes the Source Rectangle
        /// </summary>
        public Rectangle Source
        {
            get { return mSource; }
            set
            {
                mSource = value;
                Size = new Rectangle(0, 0, (int)(mSource.Width * xScale), (int)(mSource.Height * yScale));
            }
        }
        /// <summary>
        /// Image display constructor.
        /// Scale defaults to 1.
        /// </summary>
        public ImageDisplay()
        {
            xScale = 1.0f;
            yScale = 1.0f;
            type = DisplayType.IMAGE;
        }

        /// <summary>
        /// Image display constructor.
        /// Scale defaults to 1.
        /// </summary>
        public ImageDisplay(XmlNode node)
        {
            xScale = 1.0f;
            yScale = 1.0f;
            type = DisplayType.IMAGE;

            name = node.Attributes["nameID"].Value;
            position = new Vector2(int.Parse(node.Attributes["posX"].Value), int.Parse(node.Attributes["posY"].Value));
            visible = bool.Parse(node.Attributes["toDraw"].Value);
            color = GetColor(node);

            image = Renderer.content.Load<Texture2D>(node.Attributes["texturePath"].Value);
        }
    }

    /// <summary>
    /// Used to display image sequences
    /// </summary>
    public class ImageSpinner_old : ScreenObject
    {
        /// <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_old(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--;
            }
        }
    }
    #endregion
}