using System;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;

namespace UniversIS.Collections.ObjectModel
{
  // Обработать напильником. 
  // Ещё можно скопипастить аналогичный класс для наследника от KeyedCollectionBase<TKey, TItem>
  [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix",
    Justification = CodeAnalysisConstants.CA1710NamedToIllustrateUsage)]
  public abstract class OwnedCollectionBase<TOwner, TItem>: DisposableCollection<TItem>
    where TOwner: class
    where TItem: class
  {
    private static readonly string newItemHasOwnerMessage = CodeResources.MappedCollectionBase_NewItemHasOwner;

    private TOwner owner;

    protected OwnedCollectionBase(TOwner owner)
    {
      Code.NotNull(owner, "owner");
      this.owner = owner;
    }

    // TODO: common logic to helper???
    #region Core logic (same as KeyedOwnedCollectionBase)
    protected TOwner Owner
    {
      get
      {
        return owner;
      }
      set
      {
        Code.NotNull(value, "value");
        foreach (TItem item in this)
        {
          SetOwner(item, value);
        }
        owner = value;
      }
    }

    protected override void InsertItem(int index, TItem item)
    {
      ValidateNotDisposed();
      Code.NotNull(item, "item");
      SetOwnerOnNewItem(item);
      base.InsertItem(index, item);
    }

    protected override void SetItem(int index, TItem item)
    {
      ValidateNotDisposed();
      Code.NotNull(item, "item");
      SetOwnerOnNewItem(item);
      ClearOwner(this[index]);
      base.SetItem(index, item);
    }

    protected override void RemoveItem(int index)
    {
      ValidateNotDisposed();
      ClearOwner(this[index]);
      base.RemoveItem(index);
    }

    protected override void ClearItems()
    {
      foreach (TItem item in this)
      {
        ClearOwner(item);
      }
      base.ClearItems();
    }

    private void SetOwnerOnNewItem(TItem item)
    {
      Code.AssertState(!HasOwner(item), newItemHasOwnerMessage);
      SetOwner(item, owner);
    }

    protected abstract bool HasOwner(TItem item);
    protected abstract void ClearOwner(TItem item);
    protected abstract void SetOwner(TItem item, TOwner owner);
    #endregion

    [ContractArgumentValidator, DebuggerHidden]
    protected void ValidateNotDisposed()
    {
      Code.NotDisposed(owner != null, GetType().FullName);
    }

    protected override void Dispose(bool disposing)
    {
      base.Dispose(disposing);
      if (disposing)
      {
        owner = null;
      }
    }
  }

  public class DisposableCollection<T>: Collection<T>, IDisposable
  {
    #region IDisposable Members
    protected virtual void Dispose(bool disposing)
    {
      if (disposing)
      {
        foreach (var item in this.OfType<IDisposable>())
        {
          item.Dispose();
        }
        Clear();
      }
    }

    public void Dispose()
    {
      Dispose(true);
      GC.SuppressFinalize(this);
    }
    #endregion
  }
}

    public class OwnedCollection : Collection<TOwned>
    {
        public OwnedCollection (TOwner owner)
        {
            if (owner == null)
            {
                throw new ArgumentNullException("owner");
            }
                        
            Owner = owner;
        }

        public TOwner Owner { get; private set; }

        protected virtual void AttachItem(TOwned item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }
            else if(item.Owner != null)
            {
                throw new ArgumentException("item.Owner != null", "item");
            }

            item.Owner = this; // || item.Owner = Owner;
        }

        protected virtual void DetachItem(TOwned item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }

            item.Owner = null;
        }

        protected override void InsertItem(int index, T item)
        {
            AttachItem(item);
            base.InsertItem(index, item);
        }

        protected override void SetItem(int index, TOwned item)
        {
            AttachItem(item);
            DetachItem(this[index]);
            base.SetItem(index, item);
        }

        protected override void RemoveItem(int index)
        {
            DetachItem(this[index]);
            base.RemoveItem(index);
        }

        protected override void ClearItems()
        {
            foreach (var item in Items)
            {
                DetachItem(item);
            }

            base.ClearItems();
        }
    }