#region ================== Copyright (c) 2007 Pascal vd Heiden

/*
 * Copyright (c) 2007 Pascal vd Heiden, www.codeimp.com
 * 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;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Reflection;
using CodeImp.DoomBuilder.Interface;
using CodeImp.DoomBuilder.IO;
using CodeImp.DoomBuilder.Map;
using CodeImp.DoomBuilder.Rendering;
using CodeImp.DoomBuilder.Geometry;
using CodeImp.DoomBuilder.Editing;
using System.Threading;
using System.Drawing;

#endregion

namespace CodeImp.DoomBuilder.BuilderModes.Editing
{
	#if DEBUG
	
	[EditMode(SwitchAction = "triangulatormode",		// Action name used to switch to this mode
			  ButtonDesc = "Triangulator Mode",			// Description on the button in toolbar/menu
			  ButtonImage = "TriangulatorMode.png",		// Image resource name for the button
			  ButtonOrder = int.MaxValue)]				// Position of the button (lower is more to the left)

	public class TriangulatorMode : ClassicMode
	{
		#region ================== Constants

		#endregion

		#region ================== Variables

		// Highlighted item
		private Sector highlighted;

		#endregion

		#region ================== Properties

		#endregion

		#region ================== Constructor / Disposer

		// Constructor
		public TriangulatorMode()
		{
		}

		// Disposer
		public override void Dispose()
		{
			// Not already disposed?
			if(!isdisposed)
			{
				// Clean up

				// Dispose base
				base.Dispose();
			}
		}

		#endregion

		#region ================== Methods

		// Cancel mode
		public override void Cancel()
		{
			base.Cancel();

			// Return to this mode
			General.Map.ChangeMode(new SectorsMode());
		}

		// Mode engages
		public override void Engage()
		{
			base.Engage();
		}

		// Mode disengages
		public override void Disengage()
		{
			base.Disengage();

			// Check which mode we are switching to
			if(General.Map.NewMode is VerticesMode)
			{
				// Convert selection to vertices

				// Clear selected sectors
				General.Map.Map.ClearSelectedSectors();
			}
			else if(General.Map.NewMode is LinedefsMode)
			{
				// Convert selection to linedefs

				// Clear selected sectors
				General.Map.Map.ClearSelectedSectors();
			}

			// Hide highlight info
			General.Interface.HideInfo();
		}

		// This redraws the display
		public unsafe override void RedrawDisplay()
		{
			// Render lines and vertices
			if(renderer.StartPlotter(true))
			{
				renderer.PlotLinedefSet(General.Map.Map.Linedefs);
				renderer.PlotVerticesSet(General.Map.Map.Vertices);
				if((highlighted != null) && !highlighted.IsDisposed)
					renderer.PlotSector(highlighted, General.Colors.Highlight);
				renderer.Finish();
			}

			// Do not show things
			if(renderer.StartThings(true))
			{
				renderer.SetThingsRenderOrder(false);
				renderer.Finish();
			}

			renderer.Present();
		}

		// This highlights a new item
		protected void Highlight(Sector s)
		{
			// Redraw lines
			if(renderer.StartPlotter(false))
			{
				// Undraw previous highlight
				if((highlighted != null) && !highlighted.IsDisposed)
					renderer.PlotSector(highlighted);

				// Set new highlight
				highlighted = s;

				// Render highlighted item
				if((highlighted != null) && !highlighted.IsDisposed)
					renderer.PlotSector(highlighted, General.Colors.Highlight);

				// Done
				renderer.Finish();
				renderer.Present();
			}

			// Show highlight info
			if((highlighted != null) && !highlighted.IsDisposed)
				General.Interface.ShowSectorInfo(highlighted);
			else
				General.Interface.HideInfo();
		}

		// Mouse moves
		public override void MouseMove(MouseEventArgs e)
		{
			base.MouseMove(e);

			// Find the nearest linedef within highlight range
			Linedef l = General.Map.Map.NearestLinedef(mousemappos);

			// Check on which side of the linedef the mouse is
			float side = l.SideOfLine(mousemappos);
			if(side > 0)
			{
				// Is there a sidedef here?
				if(l.Back != null)
				{
					// Highlight if not the same
					if(l.Back.Sector != highlighted) Highlight(l.Back.Sector);
				}
				else
				{
					// Highlight nothing
					if(highlighted != null) Highlight(null);
				}
			}
			else
			{
				// Is there a sidedef here?
				if(l.Front != null)
				{
					// Highlight if not the same
					if(l.Front.Sector != highlighted) Highlight(l.Front.Sector);
				}
				else
				{
					// Highlight nothing
					if(highlighted != null) Highlight(null);
				}
			}
		}

		// Mouse leaves
		public override void MouseLeave(EventArgs e)
		{
			base.MouseLeave(e);

			// Highlight nothing
			Highlight(null);
		}

		// Mouse button pressed
		public override void MouseDown(MouseEventArgs e)
		{
			base.MouseDown(e);
			bool front, back;

			// Edit button is used?
			if(General.Interface.CheckActionActive(null, "classicedit"))
			{
				// Item highlighted?
				if((highlighted != null) && !highlighted.IsDisposed)
				{
					// Flip selection
					highlighted.Selected = !highlighted.Selected;

					// Make update lines selection
					foreach(Sidedef sd in highlighted.Sidedefs)
					{
						if(sd.Line.Front != null) front = sd.Line.Front.Sector.Selected; else front = false;
						if(sd.Line.Back != null) back = sd.Line.Back.Sector.Selected; else back = false;
						sd.Line.Selected = front | back;
					}

					// Update display
					if(renderer.StartPlotter(false))
					{
						// Redraw highlight to show selection
						renderer.PlotSector(highlighted);
						renderer.Finish();
						renderer.Present();
					}
				}
			}
		}

		// Mouse released
		public override void MouseUp(MouseEventArgs e)
		{
			ICollection<Sector> selected;
			TriangleList triangles;
			
			base.MouseUp(e);
			
			// Item highlighted?
			if((highlighted != null) && !highlighted.IsDisposed)
			{
				// Edit button is used?
				if(General.Interface.CheckActionActive(null, "classicedit"))
				{
					// Anything selected?
					selected = General.Map.Map.GetSectorsSelection(true);
					if(selected.Count > 0)
					{
						// Remove highlight
						Highlight(null);

						// Clear selection
						General.Map.Map.ClearSelectedSectors();
						General.Map.Map.ClearSelectedLinedefs();
						General.Interface.RedrawDisplay();

						// Get a triangulator and bind events
						Triangulator t = new Triangulator();
						t.OnShowLine = new Triangulator.ShowLine(ShowLine);
						t.OnShowPolygon = new Triangulator.ShowPolygon(ShowPolygon);
						t.OnShowPoint = new Triangulator.ShowPoint(ShowPoint);
						t.OnShowEarClip = new Triangulator.ShowEarClip(ShowEarClip);

						// Triangulate this now!
						triangles = t.PerformTriangulation(General.GetByIndex<Sector>(selected, 0));

						// Start with a clear display
						if(renderer.StartPlotter(true))
						{
							// Render lines and vertices
							renderer.PlotLinedefSet(General.Map.Map.Linedefs);
							renderer.PlotVerticesSet(General.Map.Map.Vertices);

							// Go for all triangle vertices
							for(int i = 0; i < triangles.Count; i += 3)
							{
								renderer.PlotLine(triangles[i + 0], triangles[i + 1], General.Colors.Selection);
								renderer.PlotLine(triangles[i + 1], triangles[i + 2], General.Colors.Selection);
								renderer.PlotLine(triangles[i + 2], triangles[i + 0], General.Colors.Selection);
							}

							// Done
							renderer.Finish();
							renderer.Present();
							Thread.Sleep(200);
						}
					}
				}
				else
				{
					// Get a triangulator and bind events
					Triangulator t = new Triangulator();

					// Triangulate the whole map!
					triangles = new TriangleList();
					foreach(Sector s in General.Map.Map.Sectors)
						triangles.AddRange(t.PerformTriangulation(s));

					// Start with a clear display
					if(renderer.StartPlotter(true))
					{
						// Render lines and vertices
						renderer.PlotLinedefSet(General.Map.Map.Linedefs);
						renderer.PlotVerticesSet(General.Map.Map.Vertices);

						// Go for all triangle vertices
						for(int i = 0; i < triangles.Count; i += 3)
						{
							renderer.PlotLine(triangles[i + 0], triangles[i + 1], General.Colors.Selection);
							renderer.PlotLine(triangles[i + 1], triangles[i + 2], General.Colors.Selection);
							renderer.PlotLine(triangles[i + 2], triangles[i + 0], General.Colors.Selection);
						}

						// Done
						renderer.Finish();
						renderer.Present();
						Thread.Sleep(200);
					}
				}
			}
		}

		// This shows a point
		private void ShowPoint(Vector2D v, int c)
		{
			for(int a = 0; a < 6; a++)
			{
				RedrawDisplay();
				Thread.Sleep(20);

				// Start with a clear display
				if(renderer.StartPlotter(true))
				{
					// Render lines and vertices
					renderer.PlotLinedefSet(General.Map.Map.Linedefs);
					renderer.PlotVerticesSet(General.Map.Map.Vertices);

					// Show the point
					renderer.PlotVertexAt(v, c);

					// Done
					renderer.Finish();
					renderer.Present();
				}

				// Wait a bit
				Thread.Sleep(60);
			}
		}

		// This shows a line
		private void ShowLine(Vector2D v1, Vector2D v2, PixelColor c)
		{
			for(int a = 0; a < 6; a++)
			{
				RedrawDisplay();
				Thread.Sleep(20);
				Application.DoEvents();
				
				// Start with a clear display
				if(renderer.StartPlotter(true))
				{
					// Render lines and vertices
					renderer.PlotLinedefSet(General.Map.Map.Linedefs);
					renderer.PlotVerticesSet(General.Map.Map.Vertices);

					// Show the line
					renderer.PlotLine(v1, v2, c);

					// Done
					renderer.Finish();
					renderer.Present();
				}

				// Wait a bit
				Thread.Sleep(60);
				Application.DoEvents();
			}
		}

		// This shows a polygon
		private void ShowPolygon(Polygon p, PixelColor c)
		{
			LinkedListNode<EarClipVertex> v;
			
			for(int a = 0; a < 5; a++)
			{
				RedrawDisplay();
				Thread.Sleep(10);
				
				// Start with a clear display
				if(renderer.StartPlotter(true))
				{
					// Render lines and vertices
					renderer.PlotLinedefSet(General.Map.Map.Linedefs);
					renderer.PlotVerticesSet(General.Map.Map.Vertices);

					// Go for all vertices in the polygon
					v = p.First;
					while(v != null)
					{
						// Show the line
						if(v.Next != null) renderer.PlotLine(v.Value.Position, v.Next.Value.Position, c);
						v = v.Next;
					}
					
					// Show last line as well
					renderer.PlotLine(p.Last.Value.Position, p.First.Value.Position, c);
					
					// Done
					renderer.Finish();
					renderer.Present();
				}

				// Wait a bit
				Thread.Sleep(50);
			}
		}

		// This shows a polygon
		private void ShowEarClip(EarClipVertex[] found, LinkedList<EarClipVertex> remains)
		{
			EarClipVertex prev, first;
			
			for(int a = 0; a < 5; a++)
			{
				// Start with a clear display
				if(renderer.StartPlotter(true))
				{
					// Render lines and vertices
					renderer.PlotLinedefSet(General.Map.Map.Linedefs);
					renderer.PlotVerticesSet(General.Map.Map.Vertices);

					// Go for all remaining vertices
					prev = null; first = null;
					foreach(EarClipVertex v in remains)
					{
						// Show the line
						if(prev != null) renderer.PlotLine(v.Position, prev.Position, PixelColor.FromColor(Color.OrangeRed));
						if(prev == null) first = v;
						prev = v;
						
						if(v.IsReflex)
							renderer.PlotVertexAt(v.Position, ColorCollection.SELECTION);
						else
							renderer.PlotVertexAt(v.Position, ColorCollection.VERTICES);
					}
					if(first != null) renderer.PlotLine(first.Position, prev.Position, PixelColor.FromColor(Color.OrangeRed));

					if(found != null)
					{
						renderer.PlotLine(found[0].Position, found[1].Position, PixelColor.FromColor(Color.SkyBlue));
						renderer.PlotLine(found[1].Position, found[2].Position, PixelColor.FromColor(Color.SkyBlue));
						renderer.PlotLine(found[2].Position, found[0].Position, PixelColor.FromColor(Color.SkyBlue));
						renderer.PlotVertexAt(found[1].Position, ColorCollection.INDICATION);
					}
					
					// Done
					renderer.Finish();
					renderer.Present();
				}
				Thread.Sleep(10);

				// Start with a clear display
				if(renderer.StartPlotter(true))
				{
					// Render lines and vertices
					renderer.PlotLinedefSet(General.Map.Map.Linedefs);
					renderer.PlotVerticesSet(General.Map.Map.Vertices);

					// Go for all remaining vertices
					prev = null; first = null;
					foreach(EarClipVertex v in remains)
					{
						// Show the line
						if(prev != null) renderer.PlotLine(v.Position, prev.Position, PixelColor.FromColor(Color.OrangeRed));
						if(prev == null) first = v;
						prev = v;

						if(v.IsReflex)
							renderer.PlotVertexAt(v.Position, ColorCollection.SELECTION);
						else
							renderer.PlotVertexAt(v.Position, ColorCollection.VERTICES);
					}
					if(first != null) renderer.PlotLine(first.Position, prev.Position, PixelColor.FromColor(Color.OrangeRed));

					// Done
					renderer.Finish();
					renderer.Present();
				}
				Thread.Sleep(20);
			}
		}
		
		#endregion
	}

	#endif
}