/*
 * GUIList.cs
 * Authors: Mike DeMauro, Bradley Blankenship
 * Copyright (c) 2007-2008 Cornell University

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Util;

namespace tAC_Engine.GUI
{
    /// <summary>
    /// Displays a list of strings using GUILabels
    /// TODO: add support for objects
    /// </summary>
    public class GUIList : GUIContainer
    {
        #region Fields

		/// <summary>
		/// Pixel texture used for list GUI
		/// </summary>
        protected Texture2D mPixel;

        /// <summary>
		/// The sprite font
        /// </summary>
        protected SpriteFont mFont;

        /// <summary>
        /// The color for the text
        /// </summary>
        protected Color mTextColor = Color.Black;

        /// <summary>
        /// The color for the background
        /// </summary>
        protected Color mBackgroundColor = Color.White;

        /// <summary>
        /// The color to use when a label is selected
        /// </summary>
        protected Color mSelectedColor = Color.Yellow;

        /// <summary>
        /// Draw a border around the list
        /// </summary>
        protected bool mIsBorderVisible = true;

        /// <summary>
        /// Uses a scroll bar
        /// </summary>
        protected bool mIsScrollBarEnabled = true;

        /// <summary>
        /// The color for the border
        /// </summary>
        protected Color mBorderColor = Color.Black;

        /// <summary>
        /// The labels used to display the list
        /// </summary>
        protected List<GUILabel> mLabels = new List<GUILabel>();

        /// <summary>
        /// The index of the selected label in the list, -1 if no label is selected
        /// </summary>
        protected int mSelectedIndex = -1;

        /// <summary>
        /// The selected label in the list, null if no label is selected
        /// </summary>
        protected GUILabel mSelectedLabel;

        /// <summary>
        /// Height of each row
		/// TODO: make variable
        /// </summary>
        protected const int mRowHeight = 24;

		/// <summary>
		/// GUI scroll bar component
		/// </summary>
        protected GUIScrollBar mScrollBar;

		/// <summary>
		/// The current viewport to draw to
		/// </summary>
        protected Viewport mViewport;

		/// <summary>
		/// Reference to the game's viewport
		/// </summary>
        protected Viewport mGameViewport;

        #endregion

        #region Properties

        /// <summary>
        /// Allows access to the basic font values.
        /// </summary>
        public SpriteFont Font
        {
            get { return mFont; }
            set 
            { 
                mFont = value;
                foreach (GUILabel label in mLabels)
                {
                    label.Font = value;
                }
            }
        }

        /// <summary>
        /// The color of the background.
        /// </summary>
        public Color BackgroundColor
        {
            get { return mBackgroundColor; }
            set 
            { 
                mBackgroundColor = value;
                foreach (GUILabel l in mLabels) l.BackgroundColor = value;
            }
        }

        /// <summary>
        /// Allows access to the color of the text.
        /// </summary>
        public Color TextColor
        {
            get { return mTextColor; }
            set
            {
                mTextColor = value;
                foreach (GUILabel l in mLabels) l.TextColor = value;
            }
        }

        /// <summary>
        /// Allows access to the selection color.
        /// </summary>
        public Color SelectedColor
        {
            get { return mSelectedColor; }
            set
            {
                mSelectedColor = value;
                if (mSelectedLabel != null) mSelectedLabel.SelectedColor = value;
            }
        }

        /// <summary>
        /// The index of the selected label in the list, -1 if no label is selected
        /// </summary>
        public int SelectedIndex
        {
            get { return mSelectedIndex; }
            set
            {
                if (value >= 0 && value < mLabels.Count)
                {
                    if (mSelectedLabel != null)
                        mSelectedLabel.Selected = false;
                    mSelectedIndex = value;
                    mSelectedLabel = mLabels[mSelectedIndex];
                    mSelectedLabel.Selected = true;
                    if (SelectionChanged != null) 
                        SelectionChanged(this, EventArgs.Empty);
                }
                else
                {
                    if (mSelectedLabel != null)
                        mSelectedLabel.Selected = false;
                    mSelectedIndex = -1;
                    mSelectedLabel = null;
                    if (SelectionChanged != null)
                        SelectionChanged(this, EventArgs.Empty);
                }
            }
        }

        /// <summary>
        /// The selected label in the list, null if no label is selected
        /// </summary>
        public GUILabel SelectedLabel
        {
            get { return mSelectedLabel; }
        }

        /// <summary>
        /// The items in the list
        /// </summary>
        public IEnumerable<string> Items
        {
            get
            {
                foreach (GUILabel l in mLabels) yield return l.Text;
            }
        }


        /// <summary>
        /// Sets/Gets the visibility of this control (scrollbar visibility is preserved)
        /// </summary>
        public override bool Visible
        {
            get { return base.Visible; }
            set
            {
                base.Visible = value;
                mScrollBar.Visible = mIsScrollBarEnabled;
            }
        }


        /// <summary>
        /// Use a scrollbar
        /// </summary>
        public bool IsScrollbarEnabled
        {
            get { return mIsScrollBarEnabled; }
            set 
            { 
                mIsScrollBarEnabled = value;
                mScrollBar.Visible = value;
                updateScrollBar();
            }
        }

        public override Vector2 Position
        {
            get
            {
                return base.Position;
            }
            set
            {
                base.Position = value;

                SetScrollBarPosition();
                updateLabels();
            }
        }

        public override Vector2 ScreenOffset
        {
            get { return base.ScreenOffset; }
            set
            {
                base.ScreenOffset = value;

                SetScrollBarPosition();
                updateLabels();
            }
        }

        #endregion

		#region Creation

		/// <summary>
		/// Constructor
		/// </summary>
        public GUIList()
        {
            mScrollBar = new GUIScrollBar();
            //mScrollBar.LayerDepth = this.LayerDepth + 0.001f;
            Add(mScrollBar);
		}

		#endregion

		#region Initialization

		/// <summary>
        /// Initializes the component. Override this method to load any non-graphics
        /// resources and query for any required services.
        /// </summary>
        public override void Initialize()
        {
            SetScrollBarPosition();
            
            mScrollBar.ScrollChanged += mScrollBar_ScrollChanged;

            base.Initialize();
		}

        /// <summary>
        /// Set the position of the scrollbar
        /// </summary>
        protected virtual void SetScrollBarPosition()
        {
            if (mScrollBar != null)
            {
                //NOTE: hardcoded width
                mScrollBar.Size = new Vector2(24, mSize.Y);
                mScrollBar.Position = new Vector2(mPosition.X + mSize.X - 24, mPosition.Y);
                mScrollBar.ScreenOffset = mScreenOffset;
                //mScrollBar.LayerDepth = this.LayerDepth + 0.001f;
            }
        }

		#endregion

		#region Management

		/// <summary>
		/// Loads the necessary information for all content dependent objects
		/// </summary>
        public override void LoadContent()
        {
            // If we have a parent container
            if (mParentScreen != null)
            {
                // Get the basic font if we do not have one
                if (Font == null)
                {
                    // Load the standard font
                    mFont = mParentScreen.Content.Load<SpriteFont>(@"Fonts\Courier New");
                }

                // create pixel
                mPixel = new Texture2D(mParentScreen.GraphicsDevice, 1, 1, 1, TextureUsage.None, SurfaceFormat.Color);
                Color[] pixels = new Color[1];
                pixels[0] = Color.White;
                mPixel.SetData(pixels);

                mGameViewport = mParentScreen.GraphicsDevice.Viewport;
                mViewport = new Viewport();
                mViewport.Width = mBounds.Width;
                mViewport.Height = mBounds.Height;
                mViewport.X = mBounds.X;
                mViewport.Y = mBounds.Y;
                mViewport.MaxDepth = mGameViewport.MaxDepth;
                mViewport.MinDepth = mGameViewport.MinDepth;
            }
            base.LoadContent();
        }

        #endregion

        #region Event Handling

		/// <summary>
		/// The event that is thrown when an item in the list is selected.
		/// </summary>
		public event EventHandler SelectionChanged;

		/// <summary>
		/// Processes when the scroll bar has changed
		/// </summary>
		/// <param name="sender">The sender of the event</param>
		/// <param name="e">The associated event arguments with the event</param>
		public void mScrollBar_ScrollChanged(object sender, EventArgs e)
		{
			updateLabels();
		}

		/// <summary>
		/// Handles mouse events
		/// </summary>
		/// <param name="e">The key event that has just been received</param>
		/// <returns>Whether or not the event had to be processed</returns>
        public override bool HandleMouseEvent(MouseInputEvent e)
        {
            if(mScrollBar.HandleMouseEvent(e))
                return true;

            bool retVal = base.HandleMouseEvent(e);

			// If we're visible
			if (retVal && Enabled)
			{
				if (e.EventCode == (int)GUIEventCodes.LEFT_MOUSE_RELEASED)
				{
					mSelectedIndex = -1;
					mSelectedLabel = null;
					for (int i = 0; i < mLabels.Count; i++)
					{
						if (mLabels[i].Bounds.Contains(e.X, e.Y))
						{
							mSelectedIndex = i;
							mSelectedLabel = mLabels[i];
							mSelectedLabel.Selected = true;
                            mSelectedLabel.SelectedColor = mSelectedColor;
							if (SelectionChanged != null) SelectionChanged(this, EventArgs.Empty);
						}
						else
						{
							mLabels[i].Selected = false;
						}
					}
				}
			}
            return retVal;
        }

		/// <summary>
		/// Handles key events
		/// </summary>
		/// <param name="e">The key event that has just been received</param>
		/// <returns>Whether or not the event had to be processed</returns>
        public override bool HandleKeyEvent(KeyInputEvent e)
        {
            if (mSelectedIndex != -1)
            {
                if (e.Trigger == Trigger.Activated)
                {
                    // Move selection up or down if necessary
                    if (e.Key == Keys.Up && mSelectedIndex > 0)
                    {
                        mSelectedLabel.Selected = false;

                        --mSelectedIndex;
                        mSelectedLabel = mLabels[mSelectedIndex];
                        mSelectedLabel.Selected = true;
                        if (SelectionChanged != null) SelectionChanged(this, EventArgs.Empty);
                    }
                    else if (e.Key == Keys.Down && mSelectedIndex < mLabels.Count - 1)
                    {
                        mSelectedLabel.Selected = false;

                        ++mSelectedIndex;
                        mSelectedLabel = mLabels[mSelectedIndex];
                        mSelectedLabel.Selected = true;
                        if (SelectionChanged != null) SelectionChanged(this, EventArgs.Empty);
                    }

                    // Move viewable rows if necessary
                    int numVisibleRows = (int)Size.Y / mRowHeight;

                    if ((mSelectedIndex - mScrollBar.ScrollPosition) < 0) 
                    {
                        --mScrollBar.ScrollPosition;
                        updateLabels();
                    }
                    else if ((mSelectedIndex - mScrollBar.ScrollPosition) >= numVisibleRows)
                    {
                        ++mScrollBar.ScrollPosition;
                        updateLabels();
                    }
                }
            }
            return base.HandleKeyEvent(e);
        }

        #endregion

        #region Mutators

    	/// <summary>
        /// Updates visibility and positions of labels
        /// </summary>
        protected void updateLabels()
        {
            int numVisibleRows = (int)Size.Y / mRowHeight;
            if ((int)Size.Y % mRowHeight > 0)
            {
                ++numVisibleRows;
            }

            for (int i = 0; i < mLabels.Count; i++)
            {
                if ((i - mScrollBar.ScrollPosition) < 0 || (i - mScrollBar.ScrollPosition) >= numVisibleRows)
                {
                    mLabels[i].Visible = false;
                }
                else
                {
                    mLabels[i].Visible = true;
                }
				mLabels[i].Position = new Vector2(Position.X + 1, Position.Y + (i - mScrollBar.ScrollPosition) * mRowHeight);
                mLabels[i].ScreenOffset = mScreenOffset;
                //mLabels[i].LayerDepth = mLayerDepth + 0.001f;
            }
        }

        /// <summary>
        /// Updates visibility and scroll positions of the scroll bar
        /// </summary>
        protected void updateScrollBar()
        {
            if (!mIsScrollBarEnabled)
            {
                mScrollBar.Visible = false;
                mScrollBar.ScrollPosition = 0;
            }
            else
            {
                int numVisibleRows = (int)Size.Y / mRowHeight;
                if (mLabels.Count > numVisibleRows)
                {
                    mScrollBar.Visible = true;
                }

                if (mLabels.Count > numVisibleRows)
                {
                    mScrollBar.MaxScrollPosition = mLabels.Count - numVisibleRows;
                }
                else
                {
                    mScrollBar.MaxScrollPosition = 0;
                }

                //mScrollBar.LayerDepth = mLayerDepth + 0.001f;
            }    
        }
        
        /// <summary>
        /// Adds a label to the list
        /// </summary>
        /// <param name="s">The string to add</param>
        public new void Add(GUILabel label)
        {
            mLabels.Add(label);
            label.Position = new Vector2(1, mLabels.Count * mRowHeight);
            label.Size = new Vector2(Size.X - 2, mRowHeight);
            
            base.Add(label);
            updateLabels();
            updateScrollBar();
        }
        
        /// <summary>
        /// Adds a string to the list
        /// </summary>
        /// <param name="s">The string to add</param>
        public void Add(string s)
        {
            GUILabel label = new GUILabel();
            label.Text = s;
            label.Font = mFont;
            label.Position = new Vector2(1, mLabels.Count * mRowHeight);
            label.Size = new Vector2(Size.X - 2, mRowHeight);
            label.BackgroundColor = mBackgroundColor;
            label.TextColor = mTextColor;
            
            Add(label);
        }

        /// <summary>
        /// Adds a list of strings to the list
        /// </summary>
        /// <param name="strings">The list of strings to add</param>
        public void Add(IEnumerable<string> strings)
        {
            foreach (string s in strings) 
            {
                Add(s);
            }
        }

		/// <summary>
		/// Override to remove the game components.
		/// </summary>
		/// <param name="component">Remove the given game component.</param>
		/// <returns>Whether the component was successfully removed or not.</returns>
		public override bool Remove(GUIComponent component)
		{
			// The return value
			bool retVal = base.Remove(component);

			// If it's a label
			if (component is GUILabel)
			{
				// Remove from our label list
				mLabels.Remove(component as GUILabel);

                // Unselected the label if it's the one
                if (mSelectedLabel == component)
                    mSelectedLabel = null;

				// Now redo the layout
				updateLabels();
			}

			// Return
			return retVal;
		}

        /// <summary>
        /// Remove the game component corresponding the given string
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool Remove(string value)
        {
            GUILabel labelToRemove = null;
            foreach(GUILabel label in mLabels)
            {
                if (label.Text == value)
                    labelToRemove = label;
            }

            if (labelToRemove != null)
                return Remove(labelToRemove);

            return false;
        }

        #endregion

        #region Draw

		/// <summary>
		/// Renders the GUI list
		/// </summary>
		/// <param name="gameTime">Time that has passed in game</param>
        public override void Draw(GameTime gameTime)
        {
			// If we're visible
			if (Visible)
			{
				// Draw Background
				Batch.Draw(mPixel, Bounds, null, mBackgroundColor, 0f, Vector2.Zero, SpriteEffects.None, 0f);

				// Draw Labels
				// NOTE: this is not ideal
				//Batch.End();
				//ParentScreen.GraphicsDevice.Viewport = mViewport;
				//Batch.Begin();
				//foreach (GUILabel label in mLabels)
				//{
				//    label.Draw(gameTime);
				//}
				////Batch.End();
				////ParentScreen.GraphicsDevice.Viewport = mGameViewport;
				////Batch.Begin();

				//// Draw scrollbar
				//mScrollBar.Draw(gameTime);
				base.Draw(gameTime);

                if (mIsBorderVisible)
                {
                    // Draw (inset) borders
                    // -top
                    Batch.Draw(mPixel, Position, null, mBorderColor, 0f, Vector2.Zero, new Vector2(Size.X, 1f), SpriteEffects.None, 0f);
                    // -right
                    Batch.Draw(mPixel, new Vector2(Position.X + Size.X - 1, Position.Y), null, mBorderColor, 0f, Vector2.Zero, new Vector2(1f, Size.Y), SpriteEffects.None, 0f);
                    // -bottom
                    Batch.Draw(mPixel, new Vector2(Position.X, Position.Y + Size.Y - 1), null, mBorderColor, 0f, Vector2.Zero, new Vector2(Size.X, 1f), SpriteEffects.None, 0f);
                    // -left
                    Batch.Draw(mPixel, Position, null, mBorderColor, 0f, Vector2.Zero, new Vector2(1f, Size.Y), SpriteEffects.None, 0f);
                }

				//NOTE: don't call base.Draw() since this method draws each component from mComponents
			}
        }

        #endregion
    }
}