// Copyright 2014-, SharpMapTeam
//
// This file is part of SharpMap.
// SharpMap is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// SharpMap 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 Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public License
// along with SharpMap; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 

using System.ComponentModel;
using System.Drawing.Drawing2D;
using KeyEventArgs = System.Windows.Input.KeyEventArgs;
using MouseEventArgs = System.Windows.Forms.MouseEventArgs;

namespace SharpMap.UI.WPF
{
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
 using System.Drawing;
 using System.Linq;
 using System.Windows;
 using System.Windows.Forms.Integration;
 using System.Windows.Input;

 using GeoAPI.Geometries;

 using Data.Providers;
 using Forms;
 using Layers;
 using Rendering.Decoration;
 using Rendering.Decoration.ScaleBar;

 using KeyEventArgs = KeyEventArgs;
 using MouseEventArgs = MouseEventArgs;

 /// <summary>
 /// Extends WindowsFormsHost and encapsulates SharpMap specific code.
 /// </summary>
 public class SharpMapHost : WindowsFormsHost, INotifyPropertyChanged
 {
 // Dependency Property to store MapLayers.
 public static readonly DependencyProperty MapLayersProperty =
 DependencyProperty.Register("MapLayers", typeof (ObservableCollection<ILayer>), typeof (SharpMapHost), new PropertyMetadata(SetMapLayersCallback));

 // Dependency Property store store BackgroundLayer.
 public static readonly DependencyProperty BackgroundLayerProperty =
 DependencyProperty.Register("BackgroundLayer", typeof (Layer), typeof (SharpMapHost), new PropertyMetadata(SetBackgroundLayerCallback));

 // Dependency Property to store ActiveTool.
 public static readonly DependencyProperty ActiveToolProperty =
 DependencyProperty.Register("ActiveTool", typeof (MapBox.Tools), typeof (SharpMapHost), new PropertyMetadata(SetActiveToolCallback));

 // Dependency Property to store MaxExtent.
 public static readonly DependencyProperty MaxExtentProperty =
 DependencyProperty.Register("MaxExtent", typeof (Envelope), typeof (SharpMapHost), new PropertyMetadata(SetMaxExtentCallback));

 // Dependency Property to store MapExtent.
 public static readonly DependencyProperty MapExtentProperty =
 DependencyProperty.Register("MapExtent", typeof (Envelope), typeof (SharpMapHost), new PropertyMetadata(MapExtentCallback));

 // Dependency Property to store Rotation kept in MapTransform
 public static readonly DependencyProperty MapRotationProperty =
 DependencyProperty.Register("MapRotation", typeof(float), typeof(SharpMapHost), new PropertyMetadata(MapRotationCallback));


 // Dependency Property used when a new geometry is defined.
 public static readonly DependencyProperty DefinedGeometryProperty =
 DependencyProperty.Register("DefinedGeometry", typeof (IGeometry), typeof (SharpMapHost), new PropertyMetadata(GeometryDefinedCallback));

 // Dependency Property used when right click in a MapFeature.
 public static readonly DependencyProperty FeatureRightClickedCommandProperty =
 DependencyProperty.Register("FeatureRightClickedCommand", typeof (ICommand), typeof (SharpMapHost));

 private readonly MapBox _mapBox;

 private VectorLayer _editLayer;

 private GeometryProvider _editLayerGeoProvider;

 private Coordinate _currentMouseCoordinate;

 /// <summary>
 /// Initializes a new instance of the <see cref="SharpMapHost"/> class. 
 /// </summary>
 public SharpMapHost()
 {
 _mapBox = new MapBox{
 BackColor = Color.White,
 Map = new Map{
 SRID = 900913
 }
 };
 Child = _mapBox;

 MapLayers = new ObservableCollection<ILayer>();

 var scaleBar = new ScaleBar{
 Anchor = MapDecorationAnchor.LeftBottom
 };
 _mapBox.Map.Decorations.Add(scaleBar);
 _mapBox.PanOnClick = false;

 KeyDown += OnKeyDown;

 _mapBox.MouseMove += MapBoxOnMouseMove;
 }

 public ObservableCollection<ILayer> MapLayers
 {
 get
 {
 return (ObservableCollection<ILayer>) GetValue(MapLayersProperty);
 }
 set
 {
 SetValue(MapLayersProperty, value);
 }
 }

 public Layer BackgroundLayer
 {
 get
 {
 return (Layer) GetValue(BackgroundLayerProperty);
 }
 set
 {
 SetValue(BackgroundLayerProperty, value);
 }
 }

 public MapBox.Tools ActiveTool
 {
 get
 {
 return (MapBox.Tools) GetValue(ActiveToolProperty);
 }
 set
 {
 SetValue(ActiveToolProperty, value);
 }
 }

 public string CurrentMouseCoordinateString
 {
 get
 {
 return _currentMouseCoordinate != null ? string.Format("{0:0}, {1:0}", _currentMouseCoordinate.X, _currentMouseCoordinate.Y) : "";
 }
 }

 public Coordinate CurrentMouseCoordinate
 {
 get
 {
 return _currentMouseCoordinate;
 }
 }

 public Envelope MaxExtent
 {
 get
 {
 return (Envelope) GetValue(MaxExtentProperty);
 }

 set
 {
 SetValue(MaxExtentProperty, value);
 }
 }

 public Envelope MapExtent
 {
 get
 {
 return _mapBox.Map.Envelope;
 }

 set
 {
 SetValue(MapExtentProperty, value);
 }
 }

 public float MapRotation
 {
 get
 {
 return _mapBox.Map.MapTransformRotation;
 }

 set
 {
 SetValue(MapRotationProperty, value);
 }
 }
 public IGeometry DefinedGeometry
 {
 get
 {
 return (IGeometry) GetValue(DefinedGeometryProperty);
 }

 set
 {
 SetValue(DefinedGeometryProperty, value);
 }
 }

 /// <summary>
 /// The command that is invoked when a feature is right clicked
 /// </summary>
 public ICommand FeatureRightClickedCommand
 {
 get
 {
 return GetValue(FeatureRightClickedCommandProperty) as ICommand;
 }

 set
 {
 SetValue(FeatureRightClickedCommandProperty, value);
 }
 }

 /// <summary>
 /// Gets called when changes on MapLayers
 /// </summary>
 /// <param name="sender">The sender object</param>
 /// <param name="args">The event arguments</param>
 private static void SetMapLayersCallback(object sender, DependencyPropertyChangedEventArgs args)
 {
 var host = sender as SharpMapHost;
 if (host == null)
 {
 return;
 }

 var oldLayers = args.OldValue as ObservableCollection<ILayer>;
 if (oldLayers != null)
 {
 oldLayers.CollectionChanged -= host.OnMapLayerChanged;
 }

 var newLayers = args.NewValue as ObservableCollection<ILayer>;
 if (newLayers != null)
 {
 newLayers.CollectionChanged += host.OnMapLayerChanged;
 }
 }

 /// <summary>
 /// Gets called when changes on BackgroundLayer
 /// </summary>
 /// <param name="sender">The sender object</param>
 /// <param name="args">The event arguments</param>
 private static void SetBackgroundLayerCallback(object sender, DependencyPropertyChangedEventArgs args)
 {
 var host = sender as SharpMapHost;
 if (host == null)
 {
 return;
 }

 var mapBox = host._mapBox;
 var layer = args.NewValue as Layer;
 if (layer != null)
 {
 mapBox.Map.BackgroundLayer.Add(layer);
 }

 mapBox.Refresh();
 }

 /// <summary>
 /// Gets called when changes on ActiveTool
 /// </summary>
 /// <param name="sender">The sender object</param>
 /// <param name="args">The event arguments</param>
 private static void SetActiveToolCallback(object sender, DependencyPropertyChangedEventArgs args)
 {
 var host = sender as SharpMapHost;
 if (host == null)
 {
 return;
 }

 var mapBox = host._mapBox;
 var newTool = (MapBox.Tools) args.NewValue;
 mapBox.ActiveTool = newTool;
 }

 /// <summary>
 /// Gets called when changes on MaxExtent
 /// </summary>
 /// <param name="sender">The sender object</param>
 /// <param name="args">The event arguments</param>
 private static void SetMaxExtentCallback(object sender, DependencyPropertyChangedEventArgs args)
 {
 var host = sender as SharpMapHost;
 if (host == null)
 {
 return;
 }

 var mapBox = host._mapBox;
 var extent = (Envelope) args.NewValue;
 if (extent != null)
 {
 mapBox.Map.EnforceMaximumExtents = true;
 mapBox.Map.MaximumExtents = extent;
 }
 }

 /// <summary>
 /// Gets called when changes on MapExtent
 /// </summary>
 /// <param name="sender">The sender object</param>
 /// <param name="args">The event arguments</param>
 private static void MapExtentCallback(object sender, DependencyPropertyChangedEventArgs args)
 {
 var host = sender as SharpMapHost;
 if (host == null)
 {
 return;
 }

 var mapBox = host._mapBox;
 var extent = (Envelope) args.NewValue;
 mapBox.Map.ZoomToBox(extent);
 mapBox.Refresh();
 }

 /// <summary>
 /// Gets called when changes on MapExtent
 /// </summary>
 /// <param name="sender">The sender object</param>
 /// <param name="args">The event arguments</param>
 private static void MapRotationCallback(object sender, DependencyPropertyChangedEventArgs args)
 {
 var host = sender as SharpMapHost;
 if (host == null)
 {
 return;
 }

 var mapBox = host._mapBox;
 float rotation = (float)args.NewValue;
 var mapTransform = new Matrix();
 mapTransform.RotateAt(rotation, new PointF(mapBox.Width / 2f, mapBox.Height / 2f));
 mapBox.Map.MapTransform = mapTransform;
 mapBox.Refresh();
 }

 /// <summary>
 /// Gets called when changes on GeometryDefined
 /// </summary>
 /// <param name="sender">The sender object</param>
 /// <param name="args">The event arguments</param>
 private static void GeometryDefinedCallback(object sender, DependencyPropertyChangedEventArgs args)
 {
 var host = sender as SharpMapHost;
 if (host == null)
 {
 return;
 }

 if (host._editLayer == null)
 {
 host._editLayer = new VectorLayer("EditLayer");
 host._editLayerGeoProvider = new GeometryProvider(new List<IGeometry>());
 host._editLayer.DataSource = host._editLayerGeoProvider;
 host.MapLayers.Add(host._editLayer);
 }

 host._editLayerGeoProvider.Geometries.Clear();
 var geom = (IGeometry) args.NewValue;
 if (geom != null)
 {
 host._editLayerGeoProvider.Geometries.Add(geom);
 }

 host._mapBox.Refresh();
 }

 /// <summary>
 /// Gets called when keyboard key pressed. Pans the map according to arrow keys.
 /// </summary>
 /// <param name="sender">The sender object</param>
 /// <param name="keyEventArgs">The event arguments</param>
 private void OnKeyDown(object sender, KeyEventArgs keyEventArgs)
 {
 var currentEnvelope = _mapBox.Map.Envelope;
 var dX = currentEnvelope.Width/2;
 var dY = currentEnvelope.Height/2;

 var x = _mapBox.Map.Center.X;
 var y = _mapBox.Map.Center.Y;

 switch (keyEventArgs.Key)
 {
 case Key.Left:
 x -= dX;
 keyEventArgs.Handled = true;
 break;
 case Key.Right:
 x += dX;
 keyEventArgs.Handled = true;
 break;
 case Key.Up:
 y += dY;
 keyEventArgs.Handled = true;
 break;
 case Key.Down:
 y -= dY;
 keyEventArgs.Handled = true;
 break;
 }

 _mapBox.Map.Center = new Coordinate(x, y);
 _mapBox.Refresh();
 }

 /// <summary>
 /// Gets called when changes in MapLayers
 /// </summary>
 /// <param name="sender">The sender object</param>
 /// <param name="e">The event arguments</param>
 private void OnMapLayerChanged(object sender, NotifyCollectionChangedEventArgs e)
 {
 switch (e.Action)
 {
 case NotifyCollectionChangedAction.Add:
 {
 var layers = e.NewItems;
 if (layers != null)
 {
 foreach (var layer in layers)
 {
 var castedLayer = layer as ILayer;
 if (castedLayer != null && _mapBox.Map.Layers.All(l => l.LayerName != castedLayer.LayerName))
 _mapBox.Map.Layers.Add(castedLayer);
 }
 }
 }

 break;
 case NotifyCollectionChangedAction.Remove:
 {
 var layers = e.OldItems;
 if (layers != null)
 {
 foreach (var layer in layers)
 {
 var castedLayer = layer as ILayer;
 if (castedLayer != null && _mapBox.Map.Layers.Any(l => l.LayerName == castedLayer.LayerName))
 _mapBox.Map.Layers.Remove(castedLayer);
 }
 }
 }

 break;
 case NotifyCollectionChangedAction.Reset:
 _mapBox.Map.Layers.Clear();
 break;
 }

 _mapBox.Refresh();
 }

 public void ZoomToExtents()
 {
 _mapBox.Map.ZoomToExtents();
 _mapBox.Refresh();
 }

 public void ZoomToEnvelope(Envelope env)
 {
 _mapBox.Map.ZoomToBox(env);
 _mapBox.Refresh();
 }

 /// <summary>
 /// Gets called when mouse moves over map
 /// </summary>
 /// <param name="worldPos">The click coordinate</param>
 /// <param name="mouseEventArgs">The event arguments</param>
 private void MapBoxOnMouseMove(Coordinate worldPos, MouseEventArgs mouseEventArgs)
 {
 _currentMouseCoordinate = worldPos;
 if (PropertyChanged != null)
 {
 PropertyChanged(this, new PropertyChangedEventArgs("CurrentMouseCoordinate"));
 PropertyChanged(this, new PropertyChangedEventArgs("CurrentMouseCoordinateString"));
 }
 }


 public event PropertyChangedEventHandler PropertyChanged;

 }
}