using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Dependency;
using Chernobyl.Event;
using Chernobyl.Graphics;
using Chernobyl.Graphics.Drawing;
using Chernobyl.Graphics.Texture;
using Chernobyl.Interface.Input;
using Chernobyl.Interface.Tool;
using Chernobyl.Interface.Utility;
using Chernobyl.Mathematics.Collision;
using Chernobyl.Mathematics.Geometry;
using Chernobyl.Mathematics.Mechanics;
using Chernobyl.Mathematics.Movement;

namespace Chernobyl.Interface.Collections
{
    /// <summary>
    /// An interface that implements and renders <see cref="IEnumerable{T}"/>s.
    /// 
    /// Note that the <see cref="EnumerableListView{T}"/> doesn't store information 
    /// about indices as it cannot guarantee that the items stored within the 
    /// <see cref="IEnumerable{T}"/> are indexed or are ordered to being with. 
    /// You can do this yourself using the methods available to the 
    /// <see cref="IEnumerable{T}"/> and <see cref="IEnumerator{T}"/> but you 
    /// should be certain that the <see cref="IEnumerable{T}"/> contained within 
    /// this <see cref="EnumerableListView{T}"/> at least has an order that can 
    /// be indexed.
    /// 
    /// Performance Tip: If you do not require items in the list to be selected 
    /// then you can improve performance by turning off selection of items within 
    /// the list using a <see cref="SelectionMode"/> of 
    /// <see cref="Collections.SelectionMode{T}.None(T, EnumerableListView{T})"/>. 
    /// Doing this will stop the list from setting up the infrastructure necessary 
    /// to allow objects to be selected.
    /// </summary>
    /// <typeparam name="T">The type that is to be held in the list.</typeparam>
    public class EnumerableListView<T> : MatrixTransform, IEnumerable<T>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="EnumerableListView{T}"/> 
        /// class.
        /// </summary>
        /// <param name="services">The instance that gives out services for use 
        /// by this type and takes services from this type for use by other systems.</param>
        /// <param name="enumerable">The enumerable that should be viewable in
        /// the interface list</param>
        public EnumerableListView(IEventCollection<object> services, IEnumerable<T> enumerable)
            : this(services, enumerable, null)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="EnumerableListView{T}"/> 
        /// class.
        /// </summary>
        /// <param name="services">The instance that gives out services for use 
        /// by this type and takes services from this type for use by other systems.</param>
        /// <param name="enumerable">The enumerable that should be viewable in
        /// the interface list</param>
        /// <param name="selectionMode">The method that determines when items in
        /// the list can be selected or null if the default 
        /// <see cref="SelectionModeFunc"/> should be used (The default value is
        /// given by the field <see cref="SelectionModeDefault"/>). Several
        /// methods are available in the
        /// <see cref="Chernobyl.Interface.Collections.SelectionMode{T}"/> struct 
        /// or you can use your own. For performance reasons, if you don't need
        /// an item to be selected, you should use
        /// <see cref="Chernobyl.Interface.Collections.SelectionMode{T}.None"/>.</param>
        public EnumerableListView(IEventCollection<object> services, IEnumerable<T> enumerable, SelectionModeFunc selectionMode)
            : this(services, enumerable, selectionMode, null)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="EnumerableListView{T}"/> 
        /// class.
        /// </summary>
        /// <param name="services">The instance that gives out services for use 
        /// by this type and takes services from this type for use by other systems.</param>
        /// <param name="enumerable">The enumerable that should be viewable in
        /// the interface list</param>
        /// <param name="button">The <see cref="IButton"/> that will be used to 
        /// interact with the list or null if <see cref="ICursor.FirstButton"/> 
        /// should be used.</param>
        /// <param name="selectionMode">The method that determines when items in
        /// the list can be selected or null if the default 
        /// <see cref="SelectionModeFunc"/> should be used (The default value is
        /// given by the field <see cref="SelectionModeDefault"/>). Several
        /// methods are available in the
        /// <see cref="Chernobyl.Interface.Collections.SelectionMode{T}"/> struct 
        /// or you can use your own. For performance reasons, if you don't need
        /// an item to be selected, you should use
        /// <see cref="Chernobyl.Interface.Collections.SelectionMode{T}.None"/>.</param>
        public EnumerableListView(IEventCollection<object> services, IEnumerable<T> enumerable, SelectionModeFunc selectionMode, IButton button)
        {
            Services = services;
            SelectionMode = selectionMode ?? SelectionModeDefault;
            SelectionItems = new List<ItemSelectionContainer>();
            _selectedItems = Enumerable.Empty<T>();
            TheEnumerable = enumerable;
            Layout = new Layout(Axis.Y);
            Button = button;
            MakeParentChild(this, Layout);
            services.Inject<EnumerableListView<T>>(this);
        }

        /// <summary>
        /// The method that determines when an item in the list can be selected. 
        /// </summary>
        /// <param name="item">The item that whose as selected or not selected is 
        /// to be determined by the method.</param>
        /// <param name="listView">The <see cref="EnumerableListView{T}"/> in which 
        /// <paramref name="item"/> is to be selected.</param>
        /// <returns>True if the item can be selected, false if otherwise.</returns>
        public delegate bool SelectionModeFunc(T item, EnumerableListView<T> listView);

        /// <summary>
        /// The method that determines when items in the list can be selected. 
        /// Several default methods are available in the 
        /// <see cref="Chernobyl.Interface.Collections.SelectionMode{T}"/> struct 
        /// or you can use your own. The default value of this property is given 
        /// by the field <see cref="SelectionModeDefault"/>.
        /// </summary>
        public SelectionModeFunc SelectionMode
        {
            get { return _selectionMode;  }
            set
            {
                _selectionMode = value;
                Refresh();
            }
        }

        /// <summary>
        /// The default value of the property <see cref="SelectionMode"/>. The 
        /// value of this field is <see cref="Collections.SelectionMode{T}.Single"/>.
        /// </summary>
        public static readonly SelectionModeFunc SelectionModeDefault = SelectionMode<T>.Single;

        /// <summary>
        /// The items that have been selected in the list or an empty 
        /// <see cref="IEnumerable{T}"/> if nothing is selected.
        /// </summary>
        /// <exception cref="ArgumentException">Thrown if the 
        /// <see cref="IEnumerable{T}"/> value set on this property contains items 
        /// that are not contained within this IEnumerable{T}.</exception>
        public IEnumerable<T> SelectedItems
        {
            get
            {
                return _selectedItems;
            }
            set
            {
                if (value.All(item => TheEnumerable.Contains(item)) == false)
                    throw new ArgumentException("One or more of the items in the " +
                        "IEnumerable<T> set on this property are not contained " + 
                        "within this IEnumerable<T>. Please ensure the items you've " + 
                        "set to be selected are actually contained with this list.", "value");

                if (SelectedItemsChanged != null)
                {
                    IEnumerable<T> oldItems = _selectedItems;

                    _selectedItems = value;

                    SelectedItemsChanged(this, new ValueChangedEventArgs<IEnumerable<T>>(oldItems, SelectedItems));
                }
                else
                    _selectedItems = value;

                // go through all of the selection items and inform them that they 
                // are selected. Grab the number of items selected while we are 
                // at it
                int count = 0;
                foreach (ItemSelectionContainer itemSelectionContainer in SelectionItems.Where(item => _selectedItems.Contains(item.Item)))
                {
                    ++count;
                    itemSelectionContainer.IsSelected = true;
                }
                
                // if no items are selected than we need to inform all selection
                // items that they are no longer selected
                if(count == 0)
                {
                    foreach (ItemSelectionContainer itemSelectionContainer in SelectionItems.Where(item => item.IsSelected))
                        itemSelectionContainer.IsSelected = false;
                }

            }
        }

        /// <summary>
        /// An event that is raised right after a new item or items have been 
        /// selected.
        /// </summary>
        public event EventHandler<ValueChangedEventArgs<IEnumerable<T>>> SelectedItemsChanged;

        /// <summary>
        /// Updates the view so that the items viewed in the list correlate to 
        /// the items in the <see cref="IEnumerable{T}"/> at this moment.
        /// </summary>
        public void Refresh()
        {
            if (_standardInterfaceFactory != null)
            {
                Layout.Clear();
                SelectionItems.Clear();

                if (TheEnumerable.Any() == true)
                {
                    if(_parentDrawableForItemViews != null)
                    {
                        _parentDrawableForItemViews.DrawableChildren.Clear();
                        foreach (T item in TheEnumerable)
                        {
                            IDrawableTransformCollidable2D view = _standardInterfaceFactory(item);
                            Layout.Add(view);
                            view.DrawableParent = _parentDrawableForItemViews;

                            // don't need to do any setup of selection properties if nothing 
                            // can be selected in the first place
                            if (SelectionMode != SelectionMode<T>.None)
                            {
                                if (_parentDrawableForSelectionBackground != null && _cursor != null)
                                {
                                    ItemSelectionContainer itemContainer = new ItemSelectionContainer(Services, this, item, _cursor, Button, view, _parentDrawableForSelectionBackground);
                                    SelectionItems.Add(itemContainer);
                                }
                                else
                                {
                                    Interface.Trace.TraceEvent(TraceEventType.Warning, 0, "Unable to refresh " +
                                    "the selected items of the EnumerableListView<T> \"" + Name + "\" because the \"" +
                                    typeof(Scene).FullName + "\" and \"" + typeof(ICursor).FullName + "\" services have not been set on this instance " +
                                    "or the \"" + typeof(Scene).FullName + "\" has been set on this instance but it did not contain a valid IDrawable " + 
                                    "for drawing 2D (see the Scene.Draw2D property).");
                                }
                            }
                        }
                    }
                    else
                    {
                        Interface.Trace.TraceEvent(TraceEventType.Warning, 0, "Unable to refresh " +
                        "the EnumerableListView<T> \"" + Name + "\" because the \"" + typeof(Scene).FullName +
                        "\" service has not been set on this instance or it has and it did not " +
                        "contain a valid IDrawable for drawing 3D (see Scene.Draw3D property).");
                    }
                }
            }
            else
            {
                Interface.Trace.TraceEvent(TraceEventType.Warning, 0, "Unable to refresh " +
                "the EnumerableListView<T> \"" + Name + "\" because the \"" +
                typeof(IStandardInterfaceFactoryCollection).FullName + "\" service has not " +
                "been set on this instance.");
            }
        }

        /// <summary>
        /// An event handler that can be assigned to an event. This method performs 
        /// the same task as <see cref="Refresh()"/> (i.e. updates the view so 
        /// that the items viewed in the list correlate to the items in the 
        /// <see cref="IEnumerable{T}"/> at this moment).
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        public void Refresh(object sender, EventArgs e)
        {
            Refresh();
        }

        /// <summary>
        /// Returns an enumerator that iterates through the collection.
        /// </summary>
        /// <returns>
        /// A <see cref="IEnumerator{T}"/> that can be used to iterate through 
        /// the collection.
        /// </returns>
        public IEnumerator<T> GetEnumerator()
        {
            return TheEnumerable.GetEnumerator();
        }

        /// <summary>
        /// Returns an enumerator that iterates through a collection.
        /// </summary>
        /// <returns>
        /// An <see cref="IEnumerator"/> object that can be used to iterate 
        /// through the collection.
        /// </returns>
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        /// <summary>
        /// The <see cref="Scene"/> that the text should be rendered in.
        /// </summary>
        [Inject]
        public Scene Scene
        {
            set
            {
                if (_parentDrawableForSelectionBackground == null)
                    _parentDrawableForSelectionBackground = new Drawable();

                if (_parentDrawableForItemViews == null)
                    _parentDrawableForItemViews = new Drawable();

                Refresh();
            }
        }

        /// <summary>
        /// The <see cref="IEventCollection{T}"/> class that holds interface 
        /// factory collections.
        /// </summary>
        [Inject]
        public IInterfaceFactoryCollectionServices FactoryCollectionServices
        {
            set
            {
                StandardInterfaceFactoryCollection = value.OfType<IStandardInterfaceFactoryCollection>().First();
            }
        }

        /// <summary>
        /// The cursor to use when selecting items in the list.
        /// </summary>
        [Inject]
        public ICursor Cursor
        {
            set
            {
                _cursor = value;

                if (Button == null)
                    Button = _cursor.FirstButton;

                Refresh();
            }
        }

        /// <summary>
        /// The collection that holds the standard interface factorys. The 
        /// appropriate interface factory (based on the type held by this list 
        /// view) will be used to create the item views for each of the items in 
        /// the list.
        /// </summary>
        IStandardInterfaceFactoryCollection StandardInterfaceFactoryCollection
        {
            set
            {
                value.TryGetValue(typeof(T), out _standardInterfaceFactory);
                if (_standardInterfaceFactory == null)
                {
                    IEnumerator<Type> baseTypesEnumerator = Chernobyl.Reflection.Utility.GetBaseTypes<T>().GetEnumerator();
                    while (_standardInterfaceFactory == null && baseTypesEnumerator.MoveNext() == true)
                        value.TryGetValue(baseTypesEnumerator.Current, out _standardInterfaceFactory);

                    baseTypesEnumerator.Dispose();
                }

                if (_standardInterfaceFactory == null)
                    throw new Exception("Unable to create the list view. Failed " +
                    "to retrieve an interface factory for the type \"" +
                    typeof(T).FullName + "\". Please ensure the proper \"" +
                    typeof(IStandardInterfaceFactoryCollection).FullName +
                    "\" was passed as a service to this EnumerableListView<T> " +
                    "and that it contains a proper interface factory for the type " +
                    "contained within the list.");

                Refresh();
            }
        }

        /// <summary>
        /// The list of items that can be selected in the list.
        /// </summary>
        List<ItemSelectionContainer> SelectionItems { get; set; }

        /// <summary>
        /// The button to use for selecting items in the list.
        /// </summary>
        IButton Button { get; set; }

        /// <summary>
        /// "lays out" the items in the list (provides the ordering and separation 
        /// of items in the list).
        /// </summary>
        Layout Layout { get; set; }

        /// <summary>
        /// The enumerable that should be viewable in the interface list.
        /// </summary>
        IEnumerable<T> TheEnumerable { get; set; }

        /// <summary>
        /// The instance that gives out services for use by this type and takes 
        /// services from this type for use by other systems.
        /// </summary>
        IEventCollection<object> Services { get; set; }

        /// <summary>
        /// The factory that creates standard interface views.
        /// </summary>
        InterfaceFactory _standardInterfaceFactory;

        /// <summary>
        /// The <see cref="IDrawable"/> that is to become the parent of the 
        /// <see cref="IDrawable"/> item views in the list.
        /// </summary>
        IDrawable _parentDrawableForItemViews;

        /// <summary>
        /// The <see cref="IDrawable"/> that is to become the parent of the 
        /// <see cref="Background"/> instance that will be the items "selection 
        /// background".
        /// </summary>
        IDrawable _parentDrawableForSelectionBackground;

        /// <summary>
        /// The backing field to <see cref="SelectionMode"/>.
        /// </summary>
        SelectionModeFunc _selectionMode;

        /// <summary>
        /// The backing field to <see cref="SelectedItems"/>.
        /// </summary>
        IEnumerable<T> _selectedItems;

        /// <summary>
        /// The backing field to <see cref="Cursor"/>.
        /// </summary>
        ICursor _cursor;

        /// <summary>
        /// Holds the data necessary to perform selection on items within the list. 
        /// This class also sets up and performs the selection on the items.
        /// </summary>
        class ItemSelectionContainer
        {
            /// <summary>
            /// Initializes a new instance of the <see cref="EnumerableListView{T}.ItemSelectionContainer"/> class.
            /// </summary>
            /// <param name="services">The instance that gives out services for 
            /// use by this type and takes services from this type for use by 
            /// other systems.</param>
            /// <param name="listView">The list view that contains the item in 
            /// question.</param>
            /// <param name="item">The item that can be selected in the 
            /// <paramref name="listView"/></param>
            /// <param name="cursor">The cursor that is used to select the item.</param>
            /// <param name="button">The button that is used to select the item.</param>
            /// <param name="view">The view that is drawn on screen to represent 
            /// the <paramref name="item"/>.</param>
            /// <param name="parentDrawableForSelectionBackground">The 
            /// <see cref="IDrawable"/> that is to become the parent of the 
            /// <see cref="Background"/> instance that will be the items "selection 
            /// background".</param>
            public ItemSelectionContainer(IEventCollection<object> services, EnumerableListView<T> listView, T item, ICursor cursor, IButton button, ICollidable2D view,
                                          IDrawable parentDrawableForSelectionBackground)
            {
                IsSelected = false;
                Services = services;
                ListView = listView;
                Item = item;
                ParentDrawableForSelectionBackground = parentDrawableForSelectionBackground;

                // create the background to make the item look like it is selected
                ShapeCollection viewCollection = new ShapeCollection(new IShape[] {view});
                SelectionBackground = new Background(Services, new Texture2D(Services, ColorRgba.Blue), viewCollection);

                // Allow the item to be clicked using the ClickableRegion extension.
                // We use a WeakEventHandler to allow this ItemSelectionContainer
                // to be garbage collected. We pass in a null unregister method
                // to WeakEventHandler because a lambda to unregister the WeakEventHandler 
                // would create a strong reference to ClickableRegion and prevent it
                // from getting garbage collected.
                ClickableRegion = new ClickableRegion(services, null, view);
                ClickableRegion.PressedDown += new WeakEventHandler<ItemSelectionContainer, PointerEventArgs>(CursorPressedDown, null);
            }

            /// <summary>
            /// True if the object is selected, false if otherwise.
            /// </summary>
            public bool IsSelected
            {
                get { return _isSelected; }
                set
                {
                    if(value != _isSelected)
                    {
                        if(value == true && ListView.SelectionMode(Item, ListView) == true)
                        {
                            _isSelected = true;
                        }
                        else
                        {
                            _isSelected = false;

                            ParentDrawableForSelectionBackground.DrawableChildren.Remove(SelectionBackground);
                        }
                    }
                }
            }

            /// <summary>
            /// The item that can be selected in the <see cref="ListView"/>.
            /// </summary>
            public T Item { get; private set; }

            /// <summary>
            /// An event handler that is invoked when the cursor clicks on an 
            /// item within the list.
            /// </summary>
            /// <param name="sender">The sender of the event.</param>
            /// <param name="e">The <see cref="ClickEventArgs"/> instance 
            /// containing the event data.</param>
            void CursorPressedDown(object sender, PointerEventArgs e)
            {
                IsSelected = !IsSelected;

                if (IsSelected == true)
                {
                    // add the item to the selected items in the list view 
                    ListView.SelectedItems = ListView.SelectedItems.Concat(Item.ToEnumerable());
                }
                else
                {
                    // remove the item from the selected items in the list view 
                    ListView.SelectedItems = ListView.SelectedItems.Except(Item.ToEnumerable());
                }
            }

            /// <summary>
            /// The list view that contains the item in question.
            /// </summary>
            EnumerableListView<T> ListView { get; set; }

            /// <summary>
            /// The <see cref="IDrawable"/> that is to become the parent of the 
            /// <see cref="Background"/> instance that will be the items "selection 
            /// background".
            /// </summary>
            IDrawable ParentDrawableForSelectionBackground { get; set; }

            /// <summary>
            /// The instance that gives out services for use by this type and 
            /// takes services from this type for use by other systems.
            /// </summary>
            IEventCollection<object> Services { get; set; }

            /// <summary>
            /// The background that is applied to the item to show that it is 
            /// selected.
            /// </summary>
            Background SelectionBackground { get; set; }

            /// <summary>
            /// Used to allow an item in the list to be clicked on.
            /// </summary>
            ClickableRegion ClickableRegion { get; set; }

            /// <summary>
            /// The backing field to <see cref="IsSelected"/>.
            /// </summary>
            bool _isSelected;
        };
    }

    /// <summary>
    /// A holder class for several predefined methods for selecting an item from  
    /// an <see cref="EnumerableListView{T}"/>
    /// </summary>
    /// <typeparam name="T">The type of the items contained within the list.</typeparam>
    public static class SelectionMode<T>
    {
        /// <summary>
        /// A method to use when you don't want items to be selected.
        /// </summary>
        /// <param name="item">The item that whose as selected or not selected is 
        /// to be determined by the method.</param>
        /// <param name="listView">The <see cref="EnumerableListView{T}"/> in which 
        /// <paramref name="item"/> is to be selected.</param>
        /// <returns>Always returns false.</returns>
        public static bool None(T item, EnumerableListView<T> listView)
        {
            return false;
        }

        /// <summary>
        /// A method to use when you only want a single item at a time to be 
        /// selected. 
        /// </summary>
        /// <param name="item">The item that whose as selected or not selected is 
        /// to be determined by the method.</param>
        /// <param name="listView">The <see cref="EnumerableListView{T}"/> in which 
        /// <paramref name="item"/> is to be selected.</param>
        /// <returns>Returns true if no item has been selected, false if otherwise.</returns>
        public static bool Single(T item, EnumerableListView<T> listView)
        {
            if (listView.SelectedItems.Count() != 0)
                listView.SelectedItems = Enumerable.Empty<T>();

            return true;
        }

        /// <summary>
        /// A method to use if you want to allow multiple items to be selected.
        /// </summary>
        /// <param name="item">The item that whose as selected or not selected is 
        /// to be determined by the method.</param>
        /// <param name="listView">The <see cref="EnumerableListView{T}"/> in which 
        /// <paramref name="item"/> is to be selected.</param>
        /// <returns>True if the item can be selected, false if otherwise.</returns>
        public static bool Multiple(T item, EnumerableListView<T> listView)
        {
            return true;
        }
    }
}