/// <summary>
 /// Låter andra klasser lyssna på förändringar i repositoryt så att de kan uppdateras.
 /// </summary>
 /// <param name="handler"></param>
 /// <returns>Referns till en instans av FDRFeedRepository med eventhanterare</returns>
 public static IRepository<Feed> getFeeds(NotifyCollectionChangedEventHandler handler)
 {
     if (feeds == null)
         feeds = new FDRFeedRepository();
     feeds.CollectionChanged += handler;
     return feeds;
 }

    public GeneratorNodeFactory( NotifyCollectionChangedEventHandler itemsChangedHandler,
                                 NotifyCollectionChangedEventHandler groupsChangedHandler,
                                 EventHandler<ExpansionStateChangedEventArgs> expansionStateChangedHandler,
                                 EventHandler isExpandedChangingHandler,
                                 EventHandler isExpandedChangedHandler,
                                 DataGridControl dataGridControl )
    {
      if( itemsChangedHandler == null )
        throw new ArgumentNullException( "itemsChangedHandler" );

      if( groupsChangedHandler == null )
        throw new ArgumentNullException( "groupsChangedHandler" );

      if( expansionStateChangedHandler == null )
        throw new ArgumentNullException( "expansionStateChangedHandler" );

      if( isExpandedChangingHandler == null )
        throw new ArgumentNullException( "isExpandedChangingHandler" );

      if( isExpandedChangedHandler == null )
        throw new ArgumentNullException( "isExpandedChangedHandler" );

      m_itemsChangedHandler = itemsChangedHandler;
      m_groupsChangedHandler = groupsChangedHandler;
      m_expansionStateChangedHandler = expansionStateChangedHandler;
      m_isExpandedChangingHandler = isExpandedChangingHandler;
      m_isExpandedChangedHandler = isExpandedChangedHandler;

      if( dataGridControl != null )
      {
        m_dataGridControl = new WeakReference( dataGridControl );
      }
    }

 public void AddHandler(NotifyCollectionChangedEventHandler handler)
 {
     if(handler != null)
     {
         _books.CollectionChanged += handler;
     }
 }

 public CollectionChangedEventListener(INotifyCollectionChanged source, NotifyCollectionChangedEventHandler handler)
 {
     if (source == null) { throw new ArgumentNullException("source"); }
     if (handler == null) { throw new ArgumentNullException("handler"); }
     this.source = source;
     this.handler = handler;
 }

        public static void OnAutoScrollToEndChanged(DependencyObject s, DependencyPropertyChangedEventArgs e)
        {
            var ctrl = s as ItemsControl;
            if (ctrl == null)
                throw new InvalidOperationException("This attached property only supports ItemsControl or derived types.");

            var data = ctrl.Items as INotifyCollectionChanged;
            if (data == null)
                throw new InvalidOperationException("Collection does not support change notifications.");

            Control parentCtrl = ctrl;
            while (parentCtrl != null && parentCtrl.GetType() != typeof(ScrollViewer))
                parentCtrl = parentCtrl.Parent as Control;
            ScrollViewer sv = parentCtrl as ScrollViewer;

            var scrollToEndHandler = new NotifyCollectionChangedEventHandler(
                (s1, e1) =>
                {
                    if (e1.Action == NotifyCollectionChangedAction.Add && sv != null)
                        sv.ScrollToBottom();
                });

            if ((bool)e.NewValue)
                data.CollectionChanged += scrollToEndHandler;
            else
                data.CollectionChanged -= scrollToEndHandler;
        }

        public static void OnAutoScrollChanged(DependencyObject s, DependencyPropertyChangedEventArgs e)
        {
            var val = (bool)e.NewValue;
            var lb = s as ListView;
            if (lb == null)
                throw new InvalidOperationException("This behavior can only be attached to a ListView.");

            var ic = lb.Items;
            var data = ic.SourceCollection as INotifyCollectionChanged;
            if (data == null) return;

            var autoscroller = new NotifyCollectionChangedEventHandler(
                (s1, e1) =>
                {
                    var selectedItem = default(object);
                    switch (e1.Action)
                    {
                        case NotifyCollectionChangedAction.Add:
                        case NotifyCollectionChangedAction.Move: selectedItem = e1.NewItems[e1.NewItems.Count - 1]; break;
                        case NotifyCollectionChangedAction.Remove: if (ic.Count < e1.OldStartingIndex) { selectedItem = ic[e1.OldStartingIndex - 1]; } else if (ic.Count > 0) selectedItem = ic[0]; break;
                        case NotifyCollectionChangedAction.Reset: if (ic.Count > 0) selectedItem = ic[0]; break;
                    }

                    if (selectedItem == default(object)) return;
                    ic.MoveCurrentTo(selectedItem);
                    lb.ScrollIntoView(selectedItem);
                });

            if (val) data.CollectionChanged += autoscroller;
            else data.CollectionChanged -= autoscroller;
        }

        public static void OnAutoScrollToEndChanged(DependencyObject s, DependencyPropertyChangedEventArgs e)
        {
            var listBox = s as ListBox;
            if(listBox==null)
                return;
            var listBoxItems = listBox.Items;
            var data = listBoxItems.SourceCollection as INotifyCollectionChanged;
            if (data == null)
                return;

            var scrollToEndHandler = new NotifyCollectionChangedEventHandler(
                (s1, e1) =>
                {
                    if (listBox.Items.Count <= 0) 
                        return;
                    var lastItem = listBox.Items[listBox.Items.Count - 1];
                    listBoxItems.MoveCurrentTo(lastItem);
                    listBox.ScrollIntoView(lastItem);
                });

            if ((bool)e.NewValue)
                data.CollectionChanged += scrollToEndHandler;
            else
                data.CollectionChanged -= scrollToEndHandler;
        }

 /// <summary>
 /// Låter andra klasser lyssna på förändringar i repositoryt så att de kan uppdateras.
 /// </summary>
 /// <param name="handler"></param>
 /// <returns>Referns till en instans av FDRCategoryRepository med eventhanterare</returns>
 public static IRepository<Category> getCategories(NotifyCollectionChangedEventHandler handler)
 {
     if (categories == null)
         categories = new FDRCategoryRepository();
     categories.CollectionChanged += handler;
     return categories;
 }

        /// <summary>
        /// Hookups the handler to the collection changed event. When the value changes it removes the handler.
        /// </summary>
        /// <param name="oldValue">The old collection.</param>
        /// <param name="newValue">The new collection.</param>
        /// <param name="handler">The handler to hookup.</param>
        public static void HookupToCollectionChanged(INotifyCollectionChanged oldValue, INotifyCollectionChanged newValue,
            NotifyCollectionChangedEventHandler handler)
        {
            if (oldValue != null)
                oldValue.CollectionChanged -= handler;

            if (newValue != null)
                newValue.CollectionChanged += handler;
        }

        /// <summary>
        /// Adds a weak event listener for a CollectionChanged event.
        /// </summary>
        /// <param name="source">The source of the event.</param>
        /// <param name="handler">The event handler.</param>
        /// <exception cref="ArgumentNullException">source must not be <c>null</c>.</exception>
        /// <exception cref="ArgumentNullException">handler must not be <c>null</c>.</exception>
        protected void AddWeakEventListener(INotifyCollectionChanged source, NotifyCollectionChangedEventHandler handler)
        {
            if (source == null) { throw new ArgumentNullException("source"); }
            if (handler == null) { throw new ArgumentNullException("handler"); }

            CollectionChangedEventListener listener = new CollectionChangedEventListener(source, handler);

            collectionChangedListeners.Add(listener);

            CollectionChangedEventManager.AddListener(source, listener);
        }

		private static void Subscribe(DataGrid dataGrid)
		{
			var handler = new NotifyCollectionChangedEventHandler((sender, eventArgs) => ScrollToEnd(dataGrid));
			if (handlersDict.ContainsKey(dataGrid))
			{
				return;
			}
            handlersDict.Add(dataGrid, handler);
			((INotifyCollectionChanged)dataGrid.Items).CollectionChanged += handler;
			ScrollToEnd(dataGrid);
		}

 private static void SetupOnUnloadedHandler(DependencyObject dependencyObject, INotifyCollectionChanged observableCollection,
                                            NotifyCollectionChangedEventHandler sourceChangedHandler)
 {
     RoutedEventHandler unloadedEventHandler = null;
     unloadedEventHandler = (sender, args) =>
                                {
                                    observableCollection.CollectionChanged -= sourceChangedHandler;
                                    ((ListViewBase)sender).SelectionChanged -= OnGridSelectionChanged;
                                    ((ListViewBase)sender).Unloaded -= unloadedEventHandler;
                                };
     ((ListViewBase)dependencyObject).Unloaded += unloadedEventHandler;
 }

        protected void RemoveEventListener(INotifyCollectionChanged source, NotifyCollectionChangedEventHandler handler)
        {
            if (source == null) { throw new ArgumentException("source"); }
            if (handler == null) { throw new ArgumentException("handler"); }

            CollectionChangedEventListener listener = collectionEventListeners.LastOrDefault(c => c.Source == source && c.Handler == handler);

            if (listener != null)
            {
                collectionEventListeners.Remove(listener);
                CollectionChangedEventManager.RemoveListener(source, listener);
            }
        }

        public DataMappingViewModel(IWebActivity activity, NotifyCollectionChangedEventHandler mappingCollectionChangedEventHandler = null)
        {
            _activity = activity;
            _actionManager = new ActionManager();
            Inputs = new ObservableCollection<IInputOutputViewModel>();
            Outputs = new ObservableCollection<IInputOutputViewModel>();

            if(mappingCollectionChangedEventHandler != null)
            {
                Inputs.CollectionChanged += mappingCollectionChangedEventHandler;
                Outputs.CollectionChanged += mappingCollectionChangedEventHandler;
            }
            Initialize(_activity);
        }

        private static void Subscribe(DataGrid dataGrid)
        {
            if (infoDict.ContainsKey(dataGrid))
                return;

            var timer = new DispatcherTimer(DispatcherPriority.Background);
            var handler = new NotifyCollectionChangedEventHandler((sender, eventArgs) => timer.Start());

            infoDict.Add(dataGrid, new DataGridInfo(handler, timer));

            timer.Tick += (sender, args) => ScrollToEnd(dataGrid);
            ((INotifyCollectionChanged)dataGrid.Items).CollectionChanged += handler;
            
            timer.Start();
        }

 internal void HandleToolCollectionNotification(NotifyCollectionChangedEventHandler listener, bool register)
 {
     if (null == listener)
     {
         throw FxTrace.Exception.ArgumentNull("listener");
     }
     if (register)
     {
         this.tools.CollectionChanged += listener;
     }
     else
     {
         this.tools.CollectionChanged -= listener;
     }
 }

        /// <summary>
        /// This method will be called when the AutoScrollToEnd
        /// property was changed
        /// </summary>
        /// <param name="s">The sender (the ListBox)</param>
        /// <param name="e">Some additional information</param>
        public static void OnAutoScrollToEndChanged(DependencyObject s, DependencyPropertyChangedEventArgs e)
        {
            var listView = s as ListView;
            if (listView != null)
            {
                var listViewItems = listView.Items;
                var data = listViewItems.SourceCollection as INotifyCollectionChanged;

                var scrollToEndHandler = new NotifyCollectionChangedEventHandler(
                    (s1, e1) =>
                        {
                            if (listView.Items.Count > 0 && e1 != null && e1.NewItems != null) // fix for error in certain conditions
                            {
                                //object lastItem = listView.Items[listView.Items.Count - 1];
                                var lastItem = e1.NewItems[0];
                                listView.Items.MoveCurrentTo(lastItem);
                                listView.ScrollIntoView(lastItem);
                                listView.SelectedItem = lastItem;
                            }
                        });

                var gotFocusHandler = new RoutedEventHandler (
                    (s2, e2) =>
                    {
                        if (listView.Items.Count > 0)
                        {
                            //object lastItem = listView.Items[listView.Items.Count - 1];
                            listView.ScrollIntoView(listView.SelectedItem);
                        }
                    });

                if ((bool)e.NewValue)
                {
                    if (data != null)
                    {
                        data.CollectionChanged += scrollToEndHandler;
                        listView.GotFocus += gotFocusHandler;
                    }
                }
                else if (data != null)
                {
                    data.CollectionChanged -= scrollToEndHandler;
                    listView.GotFocus -= gotFocusHandler;
                }
            }
        }

        public void Advertisements_WhenNewItemAdded_CallsCollectionChangedEvent()
        {
            //	Arrange
            var paperVm = GetValidNewspaperItemViewModel();
            var adVm = GetValidAdvertisementItemViewModel();
            IList addedItems = new ArrayList();

            var collectionChangedEvent = new NotifyCollectionChangedEventHandler((sender, arg) => { addedItems = arg.NewItems; });
            paperVm.Advertisements.CollectionChanged += collectionChangedEvent;

            //	Act
            paperVm.Advertisements.Add(adVm);

            //	Assert
            addedItems.Count.Should().Be(1, "One item was added");
            adVm.Should().Be(addedItems[0]);
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        private static void AssertChange(
            ObservableCollection<int> original,
            Action<ObservableCollection<int>> change,
            ICollection copy,
            NotifyCollectionChangedEventHandler handler)
        {
            try
            {
                change(original);
                CollectionAssert.AreEqual(original, copy);
            }
            finally
            {
                original.CollectionChanged -= handler;
            }

            original.Add(42);
            CollectionAssert.AreNotEqual(original, copy);
        }

        public static void OnIsAutoScrollChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
        {
            var value = (bool)e.NewValue;
            var listView = obj as ListView;
            var itemCollection = listView.Items;
            var data = (INotifyCollectionChanged)itemCollection;

            var autoscroller = new NotifyCollectionChangedEventHandler(
                (o, arg) =>
                {
                    var selectedItem = default(object);
                    switch (arg.Action)
                    {
                        case NotifyCollectionChangedAction.Add:
                        case NotifyCollectionChangedAction.Move:
                            {
                                selectedItem = arg.NewItems[arg.NewItems.Count - 1];
                                break;
                            }
                        case NotifyCollectionChangedAction.Remove:
                            {
                                if (itemCollection.Count < arg.OldStartingIndex)
                                {
                                    selectedItem = itemCollection[arg.OldStartingIndex - 1];
                                }
                                else if (itemCollection.Count > 0) selectedItem = itemCollection[0];
                                break;
                            }
                        case NotifyCollectionChangedAction.Reset:
                            {
                                if (itemCollection.Count > 0) selectedItem = itemCollection[0];
                                break;
                            }
                    }
                    if (selectedItem != default(object))
                    {
                        itemCollection.MoveCurrentTo(selectedItem);
                        listView.ScrollIntoView(selectedItem);
                    }
                });
            if (value) data.CollectionChanged += autoscroller;
            else data.CollectionChanged -= autoscroller;
        }