//----------------------------------------------
//            NGUI: Next-Gen UI kit
// Copyright © 2011-2015 Tasharen Entertainment
//----------------------------------------------

using UnityEngine;
using System.Collections.Generic;
using System.Diagnostics;

/// <summary>
/// This improved version of the System.Collections.Generic.List that doesn't release the buffer on Clear(),
/// resulting in better performance and less garbage collection.
/// PRO: BetterList performs faster than List when you Add and Remove items (although slower if you remove from the beginning).
/// CON: BetterList performs worse when sorting the list. If your operations involve sorting, use the standard List instead.
/// </summary>

public class ObjBetterList<T> where T : Object
{
    /// <summary>
    /// 索引改变回调函数
    /// </summary>
    private IndexChangeFunc _indexChangeFunc;

    /// <summary>
    /// Direct access to the buffer. Note that you should not use its 'Length' parameter, but instead use BetterList.size.
    /// </summary>

    private T[] _buffer;
    public T[] buffer
    {
        get
        {
            return _buffer;
        }
    }

    /// <summary>
    /// Direct access to the buffer's size. Note that it's only public for speed and efficiency. You shouldn't modify it.
    /// </summary>

    public int size = 0;

    public ObjBetterList()
    {

    }

    public ObjBetterList(int capacity)
    {
        _buffer = new T[capacity];
    }

    /// <summary>
    /// For 'foreach' functionality.
    /// </summary>
    /// 

    [DebuggerHidden]
	[DebuggerStepThrough]
	public IEnumerator<T> GetEnumerator ()
	{
		if (_buffer != null)
		{
			for (int i = 0; i < size; ++i)
			{
				yield return _buffer[i];
			}
		}
	}
	
	/// <summary>
	/// Convenience function. I recommend using .buffer instead.
	/// </summary>

	[DebuggerHidden]
	public T this[int i]
	{
		get
        {
            return _buffer[i];
        }
		set
        {
            var oldValue = _buffer[i];
            if(oldValue != value)
            {
                _buffer[i] = value;
                //移除老的
                DoIndexChanged(oldValue, -1);
                //添加新的
                DoIndexChanged(value, i);
            }
        }
	}

	/// <summary>
	/// Helper function that expands the size of the array, maintaining the content.
	/// </summary>

	void AllocateMore ()
	{
		T[] newList = (_buffer != null) ? new T[Mathf.Max(_buffer.Length << 1, 32)] : new T[32];
		if (_buffer != null && size > 0) _buffer.CopyTo(newList, 0);
        _buffer = newList;
	}

	/// <summary>
	/// Trim the unnecessary memory, resizing the buffer to be of 'Length' size.
	/// Call this function only if you are sure that the buffer won't need to resize anytime soon.
	/// </summary>

	void Trim ()
	{
		if (size > 0)
		{
			if (size < _buffer.Length)
			{
				T[] newList = new T[size];
				for (int i = 0; i < size; ++i) newList[i] = _buffer[i];
                _buffer = newList;
			}
		}
		else _buffer = null;
	}

	/// <summary>
	/// Clear the array by resetting its size to zero. Note that the memory is not actually released.
	/// </summary>

	public void Clear () { size = 0; }

	/// <summary>
	/// Clear the array and release the used memory.
	/// </summary>

	public void Release () { size = 0; _buffer = null; }

	/// <summary>
	/// Add the specified item to the end of the list.
	/// </summary>

	public void Add (T item)
	{
		if (_buffer == null || size == _buffer.Length) AllocateMore();
		_buffer[size] = item;
        //添加新的
        DoIndexChanged(item, size);
        ++size;
    }

	/// <summary>
	/// Insert an item at the specified index, pushing the entries back.
	/// </summary>

	public void Insert (int index, T item)
	{
		if (_buffer == null || size == _buffer.Length) AllocateMore();

		if (index > -1 && index < size)
		{
            for (int i = size; i > index; --i)
            {
                _buffer[i] = _buffer[i - 1];
                DoIndexChanged(_buffer[i], i);
            }

			_buffer[index] = item;
            DoIndexChanged(item, index);
            ++size;
		}
		else Add(item);
	}

	/// <summary>
	/// Returns 'true' if the specified item is within the list.
	/// </summary>

	public bool Contains (T item)
	{
		if (_buffer == null) return false;
        var hashCode = item.GetHashCode();
        for (int i = 0; i < size; ++i)
        {
            if (_buffer[i].GetHashCode() == hashCode)
            {
                return true;
            }
        }
		return false;
	}

	/// <summary>
	/// Return the index of the specified item.
	/// </summary>

	public int IndexOf (T item)
	{
		if (_buffer == null) return -1;
        var hashCode = item.GetHashCode();
        for (int i = 0; i < size; ++i)
        {
            if (_buffer[i].GetHashCode() == hashCode)
            {
                return i;
            }
        }
		return -1;
	}

	/// <summary>
	/// Remove the specified item from the list. Note that RemoveAt() is faster and is advisable if you already know the index.
	/// </summary>

	public bool Remove (T item)
	{
		if (_buffer != null && item != null)
		{
            var hashCode = item.GetHashCode();
            for (int i = 0; i < size; ++i)
			{
				if (_buffer[i].GetHashCode() == hashCode)
				{
					--size;
                    DoIndexChanged(_buffer[i], -1);
                    _buffer[i] = default(T);
                    for (int b = i; b < size; ++b)
                    {
                        _buffer[b] = _buffer[b + 1];
                        DoIndexChanged(_buffer[b], b);
                    }
					_buffer[size] = default(T);
					return true;
				}
			}
		}
		return false;
	}

	/// <summary>
	/// Remove an item at the specified index.
	/// </summary>

	public void RemoveAt (int index)
	{
		if (_buffer != null && index > -1 && index < size)
		{
			--size;
            DoIndexChanged(_buffer[index], -1);
            _buffer[index] = default(T);
            for (int b = index; b < size; ++b)
            {
                _buffer[b] = _buffer[b + 1];
                DoIndexChanged(_buffer[b], b);
            }
			_buffer[size] = default(T);
		}
	}


	/// <summary>
	/// Mimic List's ToArray() functionality, except that in this case the list is resized to match the current size.
	/// </summary>

	public T[] ToArray () { Trim(); return _buffer; }

	/// <summary>
	/// List.Sort equivalent. Manual sorting causes no GC allocations.
	/// </summary>

	[DebuggerHidden]
	[DebuggerStepThrough]
	public void Sort (CompareFunc comparer)
	{
		int start = 0;
		int max = size - 1;
		bool changed = true;

		while (changed)
		{
			changed = false;

			for (int i = start; i < max; ++i)
			{
				// Compare the two values
				if (comparer(_buffer[i], _buffer[i + 1]) > 0)
				{
					// Swap the values
					T temp = _buffer[i];
					_buffer[i] = _buffer[i + 1];
					_buffer[i + 1] = temp;
                    DoIndexChanged(_buffer[i], i);
                    DoIndexChanged(_buffer[i + 1], i + 1);
                    changed = true;
				}
				else if (!changed)
				{
					// Nothing has changed -- we can start here next time
					start = (i == 0) ? 0 : i - 1;
				}
			}
		}
	}

    /// <summary>
    /// 索引改变回调函数
    /// </summary>
    public void SetIndexChangeFunc(IndexChangeFunc func)
    {
        _indexChangeFunc = func;
    }

    private void DoIndexChanged(T item, int index)
    {
        if(_indexChangeFunc != null)
        {
            _indexChangeFunc(item, index);
        }
    }

    /// <summary>
    /// Comparison function should return -1 if left is less than right, 1 if left is greater than right, and 0 if they match.
    /// </summary>

    public delegate int CompareFunc (T left, T right);

    /// <summary>
    /// 索引改变回调
    /// </summary>
    /// <param name="item"></param>
    /// <param name="index"></param>
	public delegate void IndexChangeFunc (T item, int index);
}