using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using Common.Logging;
using GeoAPI.Geometries;
using SharpMap;
using SharpMap.Data;
using SharpMap.Forms;
using SharpMap.Forms.Tools;
using SharpMap.Layers;

namespace WinFormSamples
{
 public class SampleTool : MapTool, IDisposable
 {
 private ILog Logger = LogManager.GetLogger(typeof(SampleTool));

 public SampleTool() : base("Sample", "A sample tool that does nothing really useful")
 {
 Logger.Debug(fmh => fmh("Created \"{0}\"-Tool, {1}", Name,Description));
 Enabled = true;
 }

 void IDisposable.Dispose()
 {
 HandleCancel();
 }

 private ToolTip _toolTip;

 public SampleTool(MapBox mapBox1) : this()
 {
 MapControl = mapBox1;
 MapControl.MapChanged += (sender, args) => { HandleCancel(); };
 _cts.Token.Register(HandleCancel);
 }

 public override bool DoKeyDown(Coordinate mapPosition, KeyEventArgs keyEventArgs)
 {
 Logger.Debug(fmh => fmh("KeyDown {1} at {0}", mapPosition, keyEventArgs.KeyCode));
 return base.DoKeyDown(mapPosition, keyEventArgs);
 }

 public override bool DoKeyUp(Coordinate mapPosition, KeyEventArgs keyEventArgs)
 {
 Logger.Debug(fmh => fmh("KeyUp {1} at {0}", mapPosition, keyEventArgs.KeyCode));
 return base.DoKeyUp(mapPosition, keyEventArgs);
 }

 public override bool DoMouseDoubleClick(Coordinate mapPosition, MouseEventArgs mouseEventArgs)
 {
 Logger.Debug(fmh => fmh("MouseDoubleClick {1} at {0}", mapPosition, mouseEventArgs.Button));
 return base.DoMouseDoubleClick(mapPosition, mouseEventArgs);
 }

 public override bool DoMouseDown(Coordinate mapPosition, MouseEventArgs mouseEventArgs)
 {
 Logger.Debug(fmh => fmh("MouseDown {1} at {0}", mapPosition, mouseEventArgs.Button));
 return base.DoMouseDown(mapPosition, mouseEventArgs);
 }

 public override bool DoMouseEnter()
 {
 Logger.Debug(fmh => fmh("MouseEnter"));
 return base.DoMouseEnter();
 }

 protected override void OnEnabledChanged(EventArgs e)
 {
 base.OnEnabledChanged(e);
 if (!Enabled)
 {
 if (_toolTip != null) _toolTip.RemoveAll();
 }
 }

 private CancellationTokenSource _cts = new CancellationTokenSource();

 public override bool DoMouseHover(Coordinate mapPosition)
 {
 Logger.Debug(fmh => fmh("MouseHover at {0}", mapPosition));

 _cts.Cancel();
 _cts.Token.WaitHandle.WaitOne();
 _cts.Dispose();

 _cts = new CancellationTokenSource();
 _cts.Token.Register(HandleCancel);
 
 var t = new Task<FeatureDataRow>(FindGeoNearPoint, mapPosition, _cts.Token);
 t.Start();
 t.ContinueWith(res => ShowToolTip(res.Result));

 return base.DoMouseHover(mapPosition);
 }

 BackgroundWorker _bw = new BackgroundWorker();

 void HandleCancel()
 {
 if (_toolTip != null)
 {
 MapControl.Invoke(new MethodInvoker(() =>
 {
 _toolTip.Hide(MapControl);
 _toolTip.Dispose();
 }));
 _toolTip = null;
 }
 }

 private void ShowToolTip(FeatureDataRow fdr)
 {
 if (fdr != null)
 {
 
 MapControl.BeginInvoke(new Action(() =>
 {
 var _t = new ToolTip();
 _toolTip = _t;
 _t/*oolTip*/.ToolTipTitle = fdr.Table.TableName;
 
 _t/*oolTip*/.Show(ToText(fdr), MapControl);
 }));
 }
 else
 {
 //MapControl.BeginInvoke(new MethodInvoker( () => _toolTip.Hide(MapControl)));
 }
 }

 private string ToText(FeatureDataRow fdr)
 {
 var sb = new StringBuilder();
 if (fdr.Geometry != null)
 {
 sb.AppendFormat("Geometry:\n Type: {0}\n SRID: {1}\n", 
 fdr.Geometry.GeometryType, fdr.Geometry.SRID);
 switch (fdr.Geometry.Dimension)
 {
 case Dimension.Surface:
 sb.AppendFormat(" Area: {0}\n", fdr.Geometry.Area);
 break;
 case Dimension.Curve:
 sb.AppendFormat(" Length: {0}\n", fdr.Geometry.Length);
 break;
 case Dimension.Point:
 sb.AppendFormat(" Position: {0}\n", fdr.Geometry.AsText());
 break;
 }
 }

 sb.Append("Data:\n");
 foreach (DataColumn col in fdr.Table.Columns)
 sb.AppendFormat(" {0}: {1}\n", col.Caption, fdr[col] == DBNull.Value ? "NULL" : fdr[col]);

 Logger.Debug(fmh => fmh("\n{0}\n{1}", fdr.Table.TableName, sb.ToString(0, sb.Length-1)));

 return sb.ToString(0, sb.Length - 1);
 }

 private FeatureDataRow FindGeoNearPoint(object/*Coordinate*/ coord)
 {
 var mapPosition = (Coordinate) coord;
 var env = new Envelope(mapPosition);
 env.ExpandBy(5 * Map.PixelWidth);
 var g = NetTopologySuite.Geometries.Prepared.PreparedGeometryFactory.Prepare(Map.Factory.ToGeometry(env));

 var fdrs = new List<Tuple<double, FeatureDataRow>>();
 var fds = new FeatureDataSet();
 var tableCount = 0;

 var layersToQuery = GetLayersToQuery(Map);

 for (var i = layersToQuery.Count - 1; i >= 0; i--)
 {
 if (_cts.Token.IsCancellationRequested)
 {
 Logger.Debug("Cancellation requested");
 return null;
 }

 var l = layersToQuery[i];
 if (l.Enabled && l.MinVisible < Map.Zoom &&
 l.MaxVisible >= Map.Zoom)
 {
 if (!l.IsQueryEnabled) continue;
 l.ExecuteIntersectionQuery(env, fds);
 for (var j = tableCount; j < fds.Tables.Count; j++)
 {
 var fdt = fds.Tables[j];
 for (var k = 0; k < fdt.Rows.Count; k++)
 {
 var fdr = (FeatureDataRow) fdt.Rows[k];
 if (g.Intersects(fdr.Geometry))
 {
 var distance = g.Geometry.InteriorPoint.Distance(fdr.Geometry);
 if (fdr.Geometry.Dimension == Dimension.Surface)
 distance += 5* Map.PixelWidth;
 fdrs.Add(Tuple.Create(distance, fdr));
 }
 }
 }
 tableCount = fds.Tables.Count;
 }

 }
 if (fdrs.Count > 0)
 {
 fdrs.Sort((t1, t2) => t1.Item1.CompareTo(t2.Item1));
 return fdrs[0].Item2;
 }
 return null;
 }

 private static List<ICanQueryLayer> GetLayersToQuery(Map map)
 {
 var res = new List<ICanQueryLayer>();
 for (var i = 0; i < map.BackgroundLayer.Count; i++)
 {
 if (map.BackgroundLayer[i] is ICanQueryLayer)
 {
 if (((ICanQueryLayer)map.BackgroundLayer[i]).IsQueryEnabled)
 res.Add((ICanQueryLayer)map.BackgroundLayer[i]);
 }
 }
 for (var i = 0; i < map.Layers.Count; i++)
 {
 if (map.Layers[i] is ICanQueryLayer)
 {
 if (((ICanQueryLayer)map.Layers[i]).IsQueryEnabled)
 res.Add((ICanQueryLayer)map.Layers[i]);
 }
 }
 return res;
 }

 public MapBox MapControl { get; private set; }

 public override bool DoMouseLeave()
 {
 Logger.Debug(fmh => fmh("MouseLeave"));
 //_toolTip.RemoveAll();
 return base.DoMouseLeave();
 }

 public override bool DoMouseMove(Coordinate mapPosition, MouseEventArgs mouseEventArgs)
 {
 Logger.Debug(fmh => fmh("MouseMove {1} at {0}", mapPosition, mouseEventArgs.Button));
 //_toolTip.RemoveAll();
 return base.DoMouseMove(mapPosition, mouseEventArgs);
 }

 public override bool DoMouseUp(Coordinate mapPosition, MouseEventArgs mouseEventArgs)
 {
 Logger.Debug(fmh => fmh("MouseUp {1} at {0}", mapPosition, mouseEventArgs.Button));
 return base.DoMouseUp(mapPosition, mouseEventArgs);
 }

 public override bool DoMouseWheel(Coordinate mapPosition, MouseEventArgs mouseEventArgs)
 {
 Logger.Debug(fmh => fmh("MouseWheel {1} at {0}", mapPosition, mouseEventArgs.Button));
 return base.DoMouseWheel(mapPosition, mouseEventArgs);
 }

 public override void Cancel()
 {
 Logger.Debug(fmh => fmh("Cancel"));
 base.Cancel();
 }

 public override void DoPaint(PaintEventArgs e)
 {
 Logger.Debug(fmh => fmh("Paint"));
 base.DoPaint(e);
 }
 }
}