using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.SharedUI.Components;

public static class ISelectedObjectCollectionExt
{
    public static IList<SelectedObject> GetItems(this ISelectedObjectCollection source)
    {
        return source.Cast<SelectedObject>().ToList();
    }
}

namespace Tango.SharedUI.Components
{
    public interface ISelectedObjectCollection : IEnumerable, INotifyCollectionChanged
    {
        event EventHandler SelectionChanged;
        ObservableCollection<Object> Source { get; set; }
        ObservableCollection<Object> SynchedSource { get; set; }
    }

    public class SelectedObjectCollection<T> : ObservableCollection<SelectedObject<T>>, ISelectedObjectCollection
    {
        private Func<T, T, bool> _compareFunc;

        public event EventHandler SelectionChanged;
        public ObservableCollection<T> Source { get; set; }
        public ObservableCollection<T> SynchedSource { get; set; }

        ObservableCollection<object> ISelectedObjectCollection.Source { get; set; }
        ObservableCollection<object> ISelectedObjectCollection.SynchedSource { get; set; }

        public bool IsReadOnly { get; }

        public SelectedObjectCollection(ObservableCollection<T> source, ObservableCollection<T> synchedSource, Func<T, T, bool> compareFunc)
        {
            _compareFunc = compareFunc;

            SynchedSource = synchedSource;
            Source = source;

            foreach (var item in source)
            {
                var selectedItem = new SelectedObject<T>(item, _compareFunc == null ? synchedSource.Contains(item) : synchedSource.ToList().Exists(x => _compareFunc(x, item)));
                this.Add(selectedItem);
                selectedItem.IsSelectedChanged += SelectedItem_IsSelectedChanged;
            }
        }

        public SelectedObjectCollection(ObservableCollection<T> source, ObservableCollection<T> synchedSource) : this(source, synchedSource, null)
        {

        }

        private void SelectedItem_IsSelectedChanged(object sender, EventArgs e)
        {
            SelectedObject<T> item = sender as SelectedObject<T>;

            if (item.IsSelected)
            {
                if (_compareFunc == null)
                {
                    if (!SynchedSource.Contains(item.Data))
                    {
                        SynchedSource.Add(item.Data);
                    }
                }
                else
                {
                    if (!SynchedSource.ToList().Exists(x => _compareFunc(x, item.Data)))
                    {
                        SynchedSource.Add(item.Data);
                    }
                }
            }
            else
            {
                if (_compareFunc == null)
                {
                    SynchedSource.Remove(item.Data);
                }
                else
                {
                    foreach (var s in SynchedSource.ToList())
                    {
                        if (_compareFunc(s, item.Data))
                        {
                            SynchedSource.Remove(s);
                        }
                    }
                }
            }

            SelectionChanged?.Invoke(this, new EventArgs());
        }

        public void Add(SelectedObject item)
        {
            base.Add((SelectedObject<T>)item);
        }

        public bool Contains(SelectedObject item)
        {
            return base.Contains((SelectedObject<T>)item);
        }

        public void CopyTo(SelectedObject[] array, int arrayIndex)
        {
            base.CopyTo(array.Cast<SelectedObject<T>>().ToArray(), arrayIndex);
        }

        public bool Remove(SelectedObject item)
        {
            return base.Remove((SelectedObject<T>)item);
        }
    }
}