#region ================== Copyright (c) 2009 Boris Iwanski

/*
 * Copyright (c) 2009 Boris Iwanski
 * This program is released under GNU General Public License
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 */

#endregion

#region ================== Namespaces

using System.Collections.Generic;
using CodeImp.DoomBuilder.Map;
using System.Threading;

#endregion

namespace CodeImp.DoomBuilder.BuilderModes
{
	[ErrorChecker("Check closed sectors", true, 300)]
	public class CheckClosedSectors : ErrorChecker
	{
		#region ================== Constants

		private const int PROGRESS_STEP = 40;

		#endregion

		#region ================== Constructor / Destructor

		// Constructor
		public CheckClosedSectors()
		{
			// Total progress is done when all sectors are checked
			SetTotalProgress(General.Map.Map.Sectors.Count / PROGRESS_STEP);
		}
		
		#endregion
		
		#region ================== Methods
		
		// This runs the check
		public override void Run()
		{
			int progress = 0;
			int stepprogress = 0;
			
            // This is a simple yet effective way to check if a sector is closed.
            // Each sidedef that belongs to a sector is checked out. The lines vertices
            // are used as the key in a Dictionary. While going through all the
            // sidedefs the values associated to the keys are set with a bitwise OR.
            //
            // The idea for this method was taken from the way DEU checks for closed
            // sectors
            //
            // The starting vertex of the side gets its 1 bit set, the ending  vertex
            // of the side gets its 2 bit set.
            // The resulting dictionary will have 1, 2 or 3 as values (unlike the DEU
            // version 0 will not appear here, since we only look at sides that belong
            // to the current sector).
            // Values 1 and 2 mean that a line they belong to has no side belonging to
            // the current sector, thereby making the sector unclosed.
            // A value of 3 usually means all lines belonging to that vertex have at least
            // one side referencing the current sector. There are (rare) cases where this
            // is not true, so a second check is done for all "opposite" vertices of the
            // vertices with values 1 and 2: if the opposite vertex has a value of 3, but
            // the line between the two vertices has no side referencing the current sector,
            // then this falsely good vertex is added to the holes, too

			// Go for all the sectors
			foreach(Sector s in General.Map.Map.Sectors)
			{
                List<Vertex> foundholes = new List<Vertex>();
                Dictionary<Vertex, int> vertices = new Dictionary<Vertex, int>();

                // look at each side that belongs to the current sector
                foreach (Sidedef sd in s.Sidedefs)
                {
                    // Add the lines starting vertex to the Dictionary if it's not yet present
                    if (!vertices.ContainsKey(sd.Line.Start))
                    {
                        vertices.Add(sd.Line.Start, 0);
                    }

                    // Add the lines ending vertex to the Dictionary if it's not yet present
                    if (!vertices.ContainsKey(sd.Line.End))
                    {
                        vertices.Add(sd.Line.End, 0);
                    }

                    // enable the 1 bit of the start vertex and the 2 bit of the end vertex of the side
                    // This is from the sides point of view, where the side is always the "right" of line,
                    // so start and end are flipped depending if the current side is the front of the
                    // line or not
                    if(sd.IsFront == true) {
                        vertices[sd.Line.Start] |= 1;
                        vertices[sd.Line.End] |= 2;
                    }
                    else
                    {
                        vertices[sd.Line.End] |= 1;
                        vertices[sd.Line.Start] |= 2;
                    }
                }

                // look at all the vertices
                foreach (KeyValuePair<Vertex, int> kvp in vertices)
                {
                    // only look at bad vertices
                    if (kvp.Value != 3)
                    {
                        // add the current vertex to the holes list
                        if (!foundholes.Contains(kvp.Key))
                        {
                            foundholes.Add(kvp.Key);
                        }

                        // this checks if any vertices slipped past the first test
                        // look at all lines that share the current vertex
                        foreach (Linedef cl in kvp.Key.Linedefs)
                        {
                            // the line does not has its front or back side referencing the current sector
                            if (!((cl.Front != null && cl.Front.Sector == s) || (cl.Back != null && cl.Back.Sector == s)))
                            {
                                // if the opposite vertex of our current vertex is marked good something must be wrong,
                                // since the above check tells us that the line bewtween the vertices has no side referencing
                                // the current sector. So add the falsely marked vertex to the holes list
                                if (vertices.ContainsKey(cl.Start) && vertices[cl.Start] == 3 && !foundholes.Contains(cl.Start))
                                {
                                    foundholes.Add(cl.Start);
                                }

                                if (vertices.ContainsKey(cl.End) && vertices[cl.End] == 3 && !foundholes.Contains(cl.End))
                                {
                                    foundholes.Add(cl.End);
                                }
                            }
                        }
                    }
                }

				// Add report when holes have been found
				if(foundholes.Count > 0)
					SubmitResult(new ResultSectorUnclosed(s, foundholes));

				// Handle thread interruption
				try { Thread.Sleep(0); }
				catch(ThreadInterruptedException) { return; }

				// We are making progress!
				if((++progress / PROGRESS_STEP) > stepprogress)
				{
					stepprogress = (progress / PROGRESS_STEP);
					AddProgress(1);
				}
			}
		}
		
		#endregion
	}
}