// Copyright (C) Stichting Deltares 2017. All rights reserved.
//
// This file is part of the Dam Engine.
//
// The Dam Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

namespace Deltares.DamEngine.Data.Standard
{

    /// <summary>
    /// Delegate void SingleArgumentDelegate
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="argument">The argument.</param>
    public delegate void SingleArgumentDelegate<T>(T argument) where T : class;

    /// <summary>
    /// Extends the standard List&lt;T&gt; class with delegates which are called on adding or removing items
    /// </summary>
    /// <typeparam name="T">The generic type to create the list for</typeparam>
    public class DelegatedList<T> : VirtualList<T> where T : class
    {
        private SingleArgumentDelegate<T> addMethod;

        /// <summary>
        /// Initializes a new instance of the <see cref="DelegatedList{T}"/> class.
        /// </summary>
        public DelegatedList() {}

        /// <summary>
        /// Initializes a new instance of the <see cref="DelegatedList{T}"/> class.
        /// </summary>
        /// <param name="addMethod">The add method.</param>
        public DelegatedList(SingleArgumentDelegate<T> addMethod)
        {
            AddMethod = addMethod;
        }

        /// <summary>
        /// Sets the add method.
        /// </summary>
        /// <value>
        /// The add method.
        /// </value>
        public SingleArgumentDelegate<T> AddMethod
        {
            set
            {
                addMethod = value;
            }
        }

        private void InvokeAddMethod(T newItem)
        {
            if (addMethod != null)
            {
                addMethod(newItem);
            }
        }

        #region List<T> Overrides

        /// <summary>
        /// Gets or sets the element at the specified index.
        /// </summary>
        /// <param name="index">The index.</param>
        /// <returns></returns>
        public override T this[int index]
        {
            get
            {
                return base[index];
            }
            set
            {
                T newItem = value;
                base[index] = newItem;
                InvokeAddMethod(newItem);
            }
        }

        /// <summary>
        /// Adds the specified item.
        /// </summary>
        /// <param name="item">The item.</param>
        public override void Add(T item)
        {
            base.Add(item);
            InvokeAddMethod(item);
        }

        /// <summary>
        /// Clears this instance.
        /// </summary>
        public override void Clear()
        {
            foreach (var itemToRemove in ToArray())
            {
                Remove(itemToRemove);
            }
        }

        /// <summary>
        /// Removes the specified item.
        /// </summary>
        /// <param name="item">The item.</param>
        /// <returns></returns>
        public override bool Remove(T item)
        {
            bool removed = base.Remove(item);
            return removed;            
        }

        /// <summary>
        /// Inserts the specified index.
        /// </summary>
        /// <param name="index">The index.</param>
        /// <param name="item">The item.</param>
        public override void Insert(int index, T item)
        {
            base.Insert(index, item);
            InvokeAddMethod(item);
        }

        #endregion
    }
}