using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace Kreta.Framework.Collections.Generic
{
    /// <summary>
    /// Entitás lista felülete.
    /// </summary>
    public class EntityCollection<EntityType> : IEntityCollection<EntityType>, IEntityCollection, IList
        where EntityType : Kreta.Framework.Entities.Entity
    {
        protected List<EntityType> m_Entities = new List<EntityType>();

        public EntityCollection()
        {
        }

        /// <summary>
        /// Külön bejárat a DA számára
        /// </summary>
        /// <param name="entity">Entitás példány</param>
        protected internal void InternalAdd(EntityType entity)
        {
            m_Entities.Add(entity);
        }

        #region Internal operations
        protected virtual void DoRemove(EntityType entity)
        {
            if (entity.ID == -1)
            {
                m_Entities.Remove(entity);
            }
            else
            {
                m_Entities.RemoveAll(e => e.ID == entity.ID);
            }
        }

        protected virtual void DoAdd(EntityType entity)
        {
            if (!Contains(entity))
            {
                m_Entities.Add(entity);
            }
        }

        protected virtual void DoClear()
        {
            m_Entities.Clear();
        }
        #endregion

        #region IList<EntityType> Members

        int IList<EntityType>.IndexOf(EntityType item)
        {
            return IndexOf(item);
        }

        void IList<EntityType>.Insert(int index, EntityType item)
        {
            throw new NotSupportedException("IList<EntityType>.Insert");
        }

        void IList<EntityType>.RemoveAt(int index)
        {
            DoRemove(m_Entities[index]);
        }

        EntityType IList<EntityType>.this[int index]
        {
            get
            {
                return m_Entities[index];
            }
            set
            {
                throw new NotSupportedException("EntityType IList<EntityType>.this[int index] setter");
            }
        }

        #endregion

        #region ICollection<EntityType> Members

        void ICollection<EntityType>.Add(EntityType item)
        {
            DoAdd(item);
        }

        void ICollection<EntityType>.Clear()
        {
            DoClear();
        }

        bool ICollection<EntityType>.Contains(EntityType item)
        {
            return Contains(item);
        }

        void ICollection<EntityType>.CopyTo(EntityType[] array, int arrayIndex)
        {
            m_Entities.CopyTo(array, arrayIndex);
        }

        int ICollection<EntityType>.Count
        {
            get { return m_Entities.Count; }
        }

        bool ICollection<EntityType>.IsReadOnly
        {
            get { return false; }
        }

        bool ICollection<EntityType>.Remove(EntityType item)
        {
            if (Contains(item))
            {
                DoRemove(item);
                return true;
            }

            return false;
        }

        #endregion

        #region IEnumerable<EntityType> Members

        IEnumerator<EntityType> IEnumerable<EntityType>.GetEnumerator()
        {
            return m_Entities.GetEnumerator();
        }

        #endregion

        #region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator()
        {
            return m_Entities.GetEnumerator();
        }

        #endregion

        #region IList Members

        int IList.Add(object value)
        {
            DoAdd((EntityType)value);
            return IndexOf((EntityType)value);
        }

        void IList.Clear()
        {
            DoClear();
        }

        bool IList.Contains(object value)
        {
            return Contains((EntityType)value);
        }

        int IList.IndexOf(object value)
        {
            return IndexOf((EntityType)value);
        }

        void IList.Insert(int index, object value)
        {
            throw new NotSupportedException("void IList.Insert(int index, object value)");
        }

        bool IList.IsFixedSize
        {
            get { return false; }
        }

        bool IList.IsReadOnly
        {
            get { return false; }
        }

        void IList.Remove(object value)
        {
            DoRemove((EntityType)value);
        }

        void IList.RemoveAt(int index)
        {
            DoRemove(m_Entities[index]);
        }

        object IList.this[int index]
        {
            get
            {
                return m_Entities[index];
            }
            set
            {
                throw new NotSupportedException("object IList.this[int index] setter");
            }
        }

        #endregion

        #region ICollection Members

        void ICollection.CopyTo(Array array, int index)
        {
            ((ICollection)m_Entities).CopyTo(array, index);
        }

        int ICollection.Count
        {
            get { return m_Entities.Count; }
        }

        bool ICollection.IsSynchronized
        {
            get { return ((ICollection)m_Entities).IsSynchronized; }
        }

        object ICollection.SyncRoot
        {
            get { return ((ICollection)m_Entities).SyncRoot; }
        }

        #endregion

        #region IEntityCollection<EntityType> Members
        public int Count
        {
            get { return m_Entities.Count; }
        }

        public EntityType this[int index] => m_Entities[index];

        public int Add(EntityType entity)
        {
            DoAdd(entity);
            return IndexOf(entity);
        }

        public bool Contains(EntityType entity)
        {
            if (entity.ID == -1)
            {
                return m_Entities.Contains(entity);
            }

            return m_Entities.Any(e => e.ID == entity.ID);
        }

        public void DeleteAll(bool logikai = true)
        {
            foreach (EntityType entity in m_Entities)
            {
                entity.Delete(false, logikai);
            }

            m_Entities.Clear();
        }

        public void DeleteMany(IList<int> ids, bool logikai = true)
        {
            foreach (EntityType entity in m_Entities)
            {
                if (!ids.Contains(entity.ID))
                {
                    continue;
                }

                entity.Delete(false, logikai);
            }
            m_Entities.Clear();
        }

        public void DeleteAll(bool runHandler, bool logikai = true)
        {
            foreach (EntityType entity in m_Entities)
            {
                entity.Delete(runHandler, logikai);
            }

            m_Entities.Clear();
        }

        public void CascadeDeleteAll(bool logikai = true)
        {
            foreach (EntityType entity in m_Entities)
            {
                entity.CascadeDelete(logikai);
            }

            m_Entities.Clear();
        }

        public void CascadeDeleteAll(bool runHandler, bool logikai = true)
        {
            foreach (EntityType entity in m_Entities)
            {
                entity.CascadeDelete(runHandler, logikai);
            }

            m_Entities.Clear();
        }

        public EntityType FindEntityById(int entityId)
        {
            foreach (EntityType entity in m_Entities)
            {
                if (entity.ID == entityId)
                {
                    return entity;
                }
            }

            return null;
        }

        public void Clear()
        {
            DoClear();
        }

        public int IndexOf(EntityType entity)
        {
            if (entity.ID == -1)
            {
                return m_Entities.IndexOf(entity);
            }

            var found = m_Entities.Find(e => e.ID == entity.ID);
            return found == null ? -1 : m_Entities.IndexOf(found);
        }
        #endregion

        #region IEntityCollection Members

        int IEntityCollection.Count
        {
            get { return Count; }
        }

        Kreta.Framework.Entities.Entity IEntityCollection.this[int index]
        {
            get { return this[index]; }
        }

        int IEntityCollection.Add(Kreta.Framework.Entities.Entity entity) => Add((EntityType)entity);

        bool IEntityCollection.Contains(Kreta.Framework.Entities.Entity entity)
        {
            return Contains((EntityType)entity);
        }

        void IEntityCollection.DeleteAll()
        {
            DeleteAll();
        }

        void IEntityCollection.DeleteAll(bool runHandler)
        {
            DeleteAll(runHandler);
        }

        void IEntityCollection.CascadeDeleteAll()
        {
            CascadeDeleteAll();
        }

        void IEntityCollection.CascadeDeleteAll(bool runHandler)
        {
            CascadeDeleteAll(runHandler);
        }

        Kreta.Framework.Entities.Entity IEntityCollection.FindEntityById(int entityId)
        {
            return FindEntityById(entityId);
        }

        void IEntityCollection.Clear()
        {
            Clear();
        }

        int IEntityCollection.IndexOf(Kreta.Framework.Entities.Entity entity)
        {
            return IndexOf((EntityType)entity);
        }

        #endregion
    }
}