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

namespace GraphSharp
{
	internal class GraphHideHelper<TVertex, TEdge> : ISoftMutableGraph<TVertex, TEdge>
		where TEdge : IEdge<TVertex>
	{
		private readonly IMutableBidirectionalGraph<TVertex, TEdge> graph;

		#region Helper Types
		protected class HiddenCollection
		{
			public List<TVertex> hiddenVertices = new List<TVertex>();
			public List<TEdge> hiddenEdges = new List<TEdge>();
		}
		#endregion

		#region Properties, fields, events
		private readonly List<TVertex> hiddenVertices = new List<TVertex>();
		private readonly List<TEdge> hiddenEdges = new List<TEdge>();
		private readonly IDictionary<string, HiddenCollection> hiddenCollections = new Dictionary<string, HiddenCollection>();
		private readonly IDictionary<TVertex, List<TEdge>> hiddenEdgesOf = new Dictionary<TVertex, List<TEdge>>();

		public event EdgeAction<TVertex, TEdge> EdgeHidden;
		public event EdgeAction<TVertex, TEdge> EdgeUnhidden;

		public event VertexAction<TVertex> VertexHidden;
		public event VertexAction<TVertex> VertexUnhidden;
		#endregion

		public GraphHideHelper( IMutableBidirectionalGraph<TVertex, TEdge> managedGraph )
		{
			graph = managedGraph;
		}

		#region Event handlers, helper methods

		/// <summary>
		/// Returns every edge connected with the vertex <code>v</code>.
		/// </summary>
		/// <param name="v">The vertex.</param>
		/// <returns>Edges, adjacent to the vertex <code>v</code>.</returns>
		protected IEnumerable<TEdge> EdgesFor( TVertex v )
		{
			return graph.InEdges( v ).Concat( graph.OutEdges( v ) );
		}

		protected HiddenCollection GetHiddenCollection( string tag )
		{
			HiddenCollection h;
			if ( !hiddenCollections.TryGetValue( tag, out h ) )
			{
				h = new HiddenCollection();
				hiddenCollections[tag] = h;
			}
			return h;
		}

		protected void OnEdgeHidden( TEdge e )
		{
			if ( EdgeHidden != null )
				EdgeHidden( e );
		}

		protected void OnEdgeUnhidden( TEdge e )
		{
			if ( EdgeUnhidden != null )
				EdgeUnhidden( e );
		}

		protected void OnVertexHidden( TVertex v )
		{
			if ( VertexHidden != null )
				VertexHidden( v );
		}

		protected void OnVertexUnhidden( TVertex v )
		{
			if ( VertexUnhidden != null )
				VertexUnhidden( v );
		}
		#endregion

		#region ISoftMutableGraph<TVertex,TEdge> Members

		public IEnumerable<TVertex> HiddenVertices
		{
			get { return hiddenVertices; }
		}

		public IEnumerable<TEdge> HiddenEdges
		{
			get { return hiddenEdges; }
		}

		/// <summary>
		/// Hides the vertex <code>v</code>.
		/// </summary>
		/// <param name="v">The vertex to hide.</param>
		public bool HideVertex( TVertex v )
		{
			if ( graph.ContainsVertex( v ) && !hiddenVertices.Contains( v ) )
			{
				HideEdges( EdgesFor( v ) );

				//hide the vertex
				graph.RemoveVertex( v );
				hiddenVertices.Add( v );
				OnVertexHidden( v );
				return true;
			}

			return false;
		}

		/// <summary>
		/// Hides a lot of vertices.
		/// </summary>
		/// <param name="vertices">The vertices to hide.</param>
		public void HideVertices( IEnumerable<TVertex> vertices )
		{
			var verticesToHide = new List<TVertex>( vertices );
			foreach ( TVertex v in verticesToHide )
			{
				HideVertex( v );
			}
		}

		public bool HideVertex( TVertex v, string tag )
		{
			HiddenCollection h = GetHiddenCollection( tag );
			var eeh = new EdgeAction<TVertex, TEdge>( e => h.hiddenEdges.Add( e ) );
			var veh = new VertexAction<TVertex>( vertex => h.hiddenVertices.Add( vertex ) );
			EdgeHidden += eeh;
			VertexHidden += veh;
			bool ret = HideVertex( v );
			EdgeHidden -= eeh;
			VertexHidden -= veh;
			return ret;
		}

		public void HideVertices( IEnumerable<TVertex> vertices, string tag )
		{
			foreach ( TVertex v in vertices )
			{
				HideVertex( v, tag );
			}
		}

		public void HideVerticesIf( Func<TVertex, bool> predicate, string tag )
		{
			var verticesToHide = new List<TVertex>();
			foreach ( var v in graph.Vertices )
			{
				if ( predicate( v ) )
					verticesToHide.Add( v );
			}
			HideVertices( verticesToHide, tag );
		}

		public bool IsHiddenVertex( TVertex v )
		{
			return ( !graph.ContainsVertex( v ) && hiddenVertices.Contains( v ) );
		}

		public bool UnhideVertex( TVertex v )
		{
			//if v not hidden, it's an error
			if ( !IsHiddenVertex( v ) )
				return false;

			//unhide the vertex
			graph.AddVertex( v );
			hiddenVertices.Remove( v );
			OnVertexUnhidden( v );
			return true;
		}

		public void UnhideVertexAndEdges( TVertex v )
		{
			UnhideVertex( v );
			List<TEdge> hiddenEdgesList;
			hiddenEdgesOf.TryGetValue( v, out hiddenEdgesList );
			if ( hiddenEdgesList != null )
				UnhideEdges( hiddenEdgesList );
		}

		public bool HideEdge( TEdge e )
		{
			if ( graph.ContainsEdge( e ) && !hiddenEdges.Contains( e ) )
			{
				graph.RemoveEdge( e );
				hiddenEdges.Add( e );

				GetHiddenEdgeListOf( e.Source ).Add( e );
				GetHiddenEdgeListOf( e.Target ).Add( e );

				OnEdgeHidden( e );
				return true;
			}

			return false;
		}

		private List<TEdge> GetHiddenEdgeListOf( TVertex v )
		{
			List<TEdge> hiddenEdgeList;
			hiddenEdgesOf.TryGetValue( v, out hiddenEdgeList );
			if ( hiddenEdgeList == null )
			{
				hiddenEdgeList = new List<TEdge>();
				hiddenEdgesOf[v] = hiddenEdgeList;
			}
			return hiddenEdgeList;
		}

		public IEnumerable<TEdge> HiddenEdgesOf( TVertex v )
		{
			return GetHiddenEdgeListOf( v );
		}

		public int HiddenEdgeCountOf( TVertex v )
		{
			return GetHiddenEdgeListOf( v ).Count;
		}

		public bool HideEdge( TEdge e, string tag )
		{
			var h = GetHiddenCollection( tag );
			var eeh = new EdgeAction<TVertex, TEdge>( edge => h.hiddenEdges.Add( edge ) );
			EdgeHidden += eeh;
			bool ret = HideEdge( e );
			EdgeHidden -= eeh;
			return ret;
		}

		public void HideEdges( IEnumerable<TEdge> edges )
		{
			var edgesToHide = new List<TEdge>( edges );
			foreach ( var e in edgesToHide )
			{
				HideEdge( e );
			}
		}

		public void HideEdges( IEnumerable<TEdge> edges, string tag )
		{
			var edgesToHide = new List<TEdge>( edges );
			foreach ( var e in edgesToHide )
			{
				HideEdge( e, tag );
			}
		}

		public void HideEdgesIf( Func<TEdge, bool> predicate, string tag )
		{
			var edgesToHide = new List<TEdge>();
			foreach ( var e in graph.Edges )
			{
				if ( predicate( e ) )
					edgesToHide.Add( e );
			}
			HideEdges( edgesToHide, tag );
		}

		public bool IsHiddenEdge( TEdge e )
		{
			return ( !graph.ContainsEdge( e ) && hiddenEdges.Contains( e ) );
		}

		public bool UnhideEdge( TEdge e )
		{
			if ( IsHiddenVertex( e.Source ) || IsHiddenVertex( e.Target ) || !IsHiddenEdge( e ) )
				return false;

			//unhide the edge
			graph.AddEdge( e );
			hiddenEdges.Remove( e );

			GetHiddenEdgeListOf( e.Source ).Remove( e );
			GetHiddenEdgeListOf( e.Target ).Remove( e );

			OnEdgeUnhidden( e );
			return true;
		}

		public void UnhideEdgesIf( Func<TEdge, bool> predicate )
		{
			var edgesToUnhide = new List<TEdge>();
			foreach ( var e in hiddenEdges )
			{
				if ( predicate( e ) )
					edgesToUnhide.Add( e );
			}
			UnhideEdges( edgesToUnhide );
		}

		public void UnhideEdges( IEnumerable<TEdge> edges )
		{
			var edgesToUnhide = new List<TEdge>( edges );
			foreach ( var e in edgesToUnhide )
			{
				UnhideEdge( e );
			}
		}

		public bool Unhide( string tag )
		{
			HiddenCollection h = GetHiddenCollection( tag );
			foreach ( TVertex v in h.hiddenVertices )
			{
				UnhideVertex( v );
			}
			foreach ( TEdge e in h.hiddenEdges )
			{
				UnhideEdge( e );
			}
			return hiddenCollections.Remove( tag );
		}

		public bool UnhideAll()
		{
			while ( hiddenVertices.Count > 0 )
			{
				UnhideVertex( hiddenVertices[0] );
			}
			while ( hiddenEdges.Count > 0 )
			{
				UnhideEdge( hiddenEdges[0] );
			}
			return true;
		}

		public int HiddenVertexCount
		{
			get { return hiddenVertices.Count; }
		}

		public int HiddenEdgeCount
		{
			get { return hiddenEdges.Count; }
		}
		#endregion

		#region IBidirectionalGraph<TVertex,TEdge> Members

		public int Degree( TVertex v )
		{
			throw new NotImplementedException();
		}

		public int InDegree( TVertex v )
		{
			throw new NotImplementedException();
		}

		public TEdge InEdge( TVertex v, int index )
		{
			throw new NotImplementedException();
		}

		public IEnumerable<TEdge> InEdges( TVertex v )
		{
			throw new NotImplementedException();
		}

		public bool IsInEdgesEmpty( TVertex v )
		{
			throw new NotImplementedException();
		}

		#endregion

		#region IIncidenceGraph<TVertex,TEdge> Members

		public bool ContainsEdge( TVertex source, TVertex target )
		{
			throw new NotImplementedException();
		}

		public bool TryGetEdge( TVertex source, TVertex target, out TEdge edge )
		{
			throw new NotImplementedException();
		}

		public bool TryGetEdges( TVertex source, TVertex target, out IEnumerable<TEdge> edges )
		{
			throw new NotImplementedException();
		}

		#endregion

		#region IImplicitGraph<TVertex,TEdge> Members

		public bool IsOutEdgesEmpty( TVertex v )
		{
			throw new NotImplementedException();
		}

		public int OutDegree( TVertex v )
		{
			throw new NotImplementedException();
		}

		public TEdge OutEdge( TVertex v, int index )
		{
			throw new NotImplementedException();
		}

		public IEnumerable<TEdge> OutEdges( TVertex v )
		{
			throw new NotImplementedException();
		}

		#endregion

		#region IGraph<TVertex,TEdge> Members

		public bool AllowParallelEdges
		{
			get { throw new NotImplementedException(); }
		}

		public bool IsDirected
		{
			get { throw new NotImplementedException(); }
		}

		#endregion

		#region IVertexSet<TVertex,TEdge> Members

		public bool ContainsVertex( TVertex vertex )
		{
			throw new NotImplementedException();
		}

		public bool IsVerticesEmpty
		{
			get { throw new NotImplementedException(); }
		}

		public int VertexCount
		{
			get { throw new NotImplementedException(); }
		}

		public IEnumerable<TVertex> Vertices
		{
			get { throw new NotImplementedException(); }
		}

		#endregion

		#region IEdgeListGraph<TVertex,TEdge> Members

		public bool ContainsEdge( TEdge edge )
		{
			throw new NotImplementedException();
		}

		public int EdgeCount
		{
			get { throw new NotImplementedException(); }
		}

		public IEnumerable<TEdge> Edges
		{
			get { throw new NotImplementedException(); }
		}

		public bool IsEdgesEmpty
		{
			get { throw new NotImplementedException(); }
		}

		#endregion

		public bool TryGetInEdges( TVertex v, out IEnumerable<TEdge> edges )
		{
			throw new NotImplementedException();
		}
		
		public bool TryGetOutEdges( TVertex v, out IEnumerable<TEdge> edges )
		{
			throw new NotImplementedException();
		}
	}
}