prs/prs.desktop/Panels/Maps/MapsPanel.xaml.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Linq.Expressions;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using Comal.Classes;
using Comal.Stores;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.Wpf;
using Syncfusion.UI.Xaml.Maps;
using System.ComponentModel;
using System.Drawing;
using Point = System.Windows.Point;

namespace PRSDesktop
{
    
    public class GPSHistory
    {
        public DateTime Date { get; set; }
        public string Description { get; set; }
        public double Latitude { get; set; }
        public double Longitude { get; set; }
    }

    /// <summary>
    ///     Interaction logic for MapsPanel.xaml
    /// </summary>
    public partial class MapsPanel : UserControl, IPanel<GPSTracker>
    {
        private LiveMapsSettings _settings;

        private bool bFirst = true;

        private readonly int ZOOMEDIN = 16;

        public MapsPanel()
        {
            InitializeComponent();
        }

        public bool IsReady { get; set; }

        public void CreateToolbarButtons(IPanelHost host)
        {
        }

        public string SectionName => "Maps";

        public DataModel DataModel(Selection selection)
        {
            return new MapsDataModel();
        }

        public void Heartbeat(TimeSpan time)
        {
        }

        public void Refresh()
        {
            ViewModel.Refresh();
        }

        public Dictionary<string, object[]> Selected()
        {
            return new Dictionary<string, object[]>();
        }

        public void Setup()
        {
            _settings = new UserConfiguration<LiveMapsSettings>().Load();

            ViewModel.Setup()
            
            ViewModel.
            ViewType.SelectionChanged += ViewTypeSelectionChanged;
            
            ViewModel.EntityGroup = _settings.EntityGroup

            var groups = ViewType.SelectedIndex > -1 ? LoadGroups(ViewType.SelectedItem as string) : LoadGroups("");
            ViewGroup.ItemsSource = groups;
            ViewGroup.SelectedIndex = ViewGroup.Items.Count > _settings.ViewGroup ? _settings.ViewGroup : -1;
            ViewGroup.SelectionChanged += ViewGroupSelectionChanged;
        }

        public void Shutdown(CancelEventArgs? cancel)
        {
        }

        public event DataModelUpdateEvent? OnUpdateDataModel;


        public Dictionary<Type, CoreTable> DataEnvironment()
        {
            return new Dictionary<Type, CoreTable>();
        }



        private void ViewTypeSelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            var sel = e.AddedItems.Count > 0 ? e.AddedItems[0] as string : null;
            if (string.IsNullOrWhiteSpace(sel))
                return;

            var groups = LoadGroups(sel);
            ViewGroup.SelectionChanged -= ViewGroupSelectionChanged;
            ViewGroup.ItemsSource = groups;
            ViewGroup.SelectionChanged += ViewGroupSelectionChanged;
            ViewGroup.SelectedIndex = groups.Any() ? 0 : -1;
        }

        

        private void ViewGroupSelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            _settings.ViewType = ViewType.SelectedIndex;
            _settings.ViewGroup = ViewGroup.SelectedIndex;
            new UserConfiguration<LiveMapsSettings>().Save(_settings);
            Refresh();
        }

        private void LoadDayMarkers()
        {
            ViewModel.Markers.Clear();
        }

        private void ResetZoom()
        {
            var nwLon = double.MaxValue;
            var nwLat = double.MinValue;
            var seLon = double.MinValue;
            var seLat = double.MaxValue;

            foreach (var marker in ViewModel.Markers)
            {
                var lat = double.Parse(marker.Latitude);
                var lon = double.Parse(marker.Longitude);
                if (lat != 0.0F && lon != 0.00)
                {
                    nwLat = lat > nwLat ? lat : nwLat;
                    seLat = lat < seLat ? lat : seLat;
                    nwLon = lon < nwLon ? lon : nwLon;
                    seLon = lon > seLon ? lon : seLon;
                }
            }

            var layer = Map.Layers[0] as ImageryLayer;
            var cLat = (nwLat + seLat) / 2.0F;
            var cLon = (nwLon + seLon) / 2.0F;
            layer.Center = new Point(cLat, cLon);
            layer.DistanceType = DistanceType.KiloMeter;
            var c = new Location { Latitude = cLat, Longitude = cLon };
            var nw = new Location { Latitude = nwLat, Longitude = nwLon };
            layer.Radius = c.DistanceTo(nw, UnitOfLength.Kilometers) / 2.0F;
        }

        private void ZoomIn_Click(object sender, RoutedEventArgs e)
        {
            CenterMap();
            if (Map.ZoomLevel < 20)
            {
                Map.ZoomLevel++;
                LoadMarkerList();
            }
        }

        private void ZoomOut_Click(object sender, RoutedEventArgs e)
        {
            CenterMap();
            if (Map.ZoomLevel > 1)
            {
                Map.ZoomLevel--;
                LoadMarkerList();
            }
        }

        private void Map_PreviewMouseWheel(object sender, MouseWheelEventArgs e)
        {
            //CenterMap();

            if (e.Delta > 0)
            {
                if (Zoom.Value < 20)
                    Zoom.Value++;
                e.Handled = true;
            }
            else if (e.Delta < 0)
            {
                if (Zoom.Value > 1)
                    Zoom.Value--;
                e.Handled = true;
            }
        }

        private void CenterMap()
        {
            var layer = Map.Layers[0] as ImageryLayer;
            var center = layer.GetLatLonFromPoint(new Point(Map.ActualWidth / 2.0F, Map.ActualHeight / 2.0F));
            layer.Center = new Point(center.Y, center.X);
        }

        private void Map_PreviewMouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            var layer = Map.Layers[0] as ImageryLayer;
            var center = layer.GetLatLonFromPoint(e.GetPosition(Map));
            layer.Center = new Point(center.Y, center.X);
            if (Map.ZoomLevel < 20)
            {
                Map.ZoomLevel++;
                LoadMarkerList();
            }

            e.Handled = true;
        }

        private void Image_PreviewMouseDown(object sender, MouseButtonEventArgs e)
        {
            var border = sender as Border;

            //Point pBorder = border.TransformToAncestor(Map).Transform(new Point(0, 0));

            //var left = pBorder.X - 2;
            //var top = pBorder.Y - 2;
            //var right = left + border.ActualWidth + 4;
            //var bottom = top + border.ActualHeight + 4;

            //ImageryLayer layer = Map.Layers[0] as ImageryLayer;
            //var nw = layer.GetLatLonFromPoint(new Point(left, top));
            //var se = layer.GetLatLonFromPoint(new Point(right, bottom));

            var found = border.DataContext as MapMarker;
            Markers.SelectedItem = found;

            if (e.ClickCount > 1 && e.ButtonState == MouseButtonState.Pressed && e.ChangedButton == MouseButton.Left)
                ZoomToMarker(found);
            //foreach (var marker in viewmodel.Markers)
            //{

            //    if (IsMarkerVisible(marker, nw, se))
            //    {
            //        found = marker;
            //        break;
            //    }
            //}
            //if (found != null)
            //{
            //    Description.Text = found.Description;
            //    LastUpdate.Text = String.Format("{0:dd MMM yy hh:mm:ss}", found.Updated);
            //    Device.Text = found.UpdatedBy;
            //    History.Visibility = String.IsNullOrWhiteSpace(found.DeviceID) ? Visibility.Collapsed : Visibility.Visible;
            //    LoadDeviceHistory(found.DeviceID);
            //    viewmodel.Selected = found;
            //}
            //else
            //{
            //    Description.Text = "";
            //    LastUpdate.Text = "";
            //    Device.Text = "";
            //    History.Visibility = Visibility.Collapsed;
            //}
        }

        private void Date_DateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var marker = Markers.SelectedItem as MapMarker;
            if (marker == null)
                return;
            LoadDeviceHistory(marker.DeviceID);
        }
        
        private class WayPoint
        {
            public PointF Location { get; set; }
            public DateTime From { get; set; }
            public DateTime To { get; set; }
        }

        private void LoadDeviceHistory(string deviceID)
        {
            
            new Client<GPSTrackerLocation>().Query(
                new Filter<GPSTrackerLocation>(x => x.DeviceID).IsEqualTo(deviceID)
                    .And(x => x.Location.Timestamp).IsGreaterThanOrEqualTo(Date.Date.Date)
                    .And(x => x.Location.Timestamp).IsLessThan(Date.Date.Date.AddDays(1)),
                null,
                new SortOrder<GPSTrackerLocation>(x => x.Location.Timestamp, SortDirection.Descending),
                (table, error) =>
                {
                    
                    var movements = new ObservableCollection<GPSHistory>();
                    if (table != null)
                    {
                        var updates = new List<GPSTrackerLocation>();
                        var last = new Location { Latitude = 0.0F, Longitude = 0.0F };

                        var q = new List<CoreRow>();
                        for (var i = 0; i < Math.Min(3, table.Rows.Count); i++)
                            q.Add(table.Rows[i]);

                        if (q.Count > 0)
                            AddHistory(movements, updates, q[0]);

                        for (var i = 3; i < table.Rows.Count; i++)
                        {
                            if (Moved(q, 0, 1) || Moved(q, 1, 2))
                                AddHistory(movements, updates, q[1]);

                            // Slide the window up
                            q.RemoveAt(0);
                            q.Add(table.Rows[i]);
                        }

                        // If there are only two records in the table,
                        // make sure we add the second
                        if (q.Count == 2)
                            AddHistory(movements, updates, q[1]);

                        // if there are three or more records,
                        // make sure we add the last
                        if (Moved(q, 2, 3))
                            AddHistory(movements, updates, q[2]);

                        //foreach (var row in table.Rows)
                        //{
                        //    InABox.Core.Location cur = new InABox.Core.Location() { Latitude = row.Get<GPSTrackerLocation, double>(x => x.Location.Latitude), Longitude = row.Get<GPSTrackerLocation, double>(x => x.Location.Longitude) };
                        //    if ((cur.Latitude != 0.0F) && (cur.Longitude != 0.0F)) // && (cur.DistanceTo(last, UnitOfLength.Kilometers) * 1000F > 500F))
                        //    {
                        //        AddHistory(movements, updates, row);
                        //        last = cur;
                        //    }
                        //}

                        if (updates.Any())
                            new Client<GPSTrackerLocation>().Save(updates, "", (o, e) => { });

                        if (!movements.Any())
                        {
                            var history = new GPSHistory
                            {
                                Date = DateTime.Today,
                                Description = "No Activity Recorded",
                                Latitude = 0.0F,
                                Longitude = 0.0F
                            };
                             movements.Add(history);
                        }
                    }
                    
                    List<WayPoint> waypoints = new List<WayPoint>();
                    WayPoint? previous = null;
                    foreach (var movement in movements.OrderBy(x=>x.Date))
                    {
                        var current = new PointF((float)movement.Longitude, (float)movement.Latitude);
                        
                        if (previous == null || Location.DistanceBetween(previous.Location, current, UnitOfLength.Kilometers) >= 0.05)
                        {
                            previous = new WayPoint()
                            {
                                Location = new PointF((float)movement.Longitude, (float)movement.Latitude),
                                From = movement.Date,
                                To = movement.Date
                            };
                            waypoints.Add(previous);
                        }
                        else
                            previous.To = movement.Date;
                    }

                    Dispatcher.BeginInvoke(() =>
                    {
                        foreach (var waypoint in waypoints.Where(x=>x.To - x.From >= TimeSpan.FromMinutes(15)))
                        {
                            ViewModel.AddWayPoint(new MapMarker()
                            {
                                Label = $"{waypoint.From:h:mm}-{waypoint.To:h:mm}",
                                Latitude = string.Format("{0:F6}", waypoint.Location.Y),
                                Longitude = string.Format("{0:F6}", waypoint.Location.X),
                            });
                        }
                        ViewModel.Refresh();
                        History.ItemsSource = null;
                        History.ItemsSource = movements;
                    });
                }
            );
            

        }

        private bool Moved(List<CoreRow> rows, int row1, int row2)
        {
            if (rows.Count <= row1)
                return false;

            if (rows.Count <= row2)
                return false;
            //InABox.Core.Location c0 = new InABox.Core.Location() { Latitude = rows[row1].Get<GPSTrackerLocation, double>(x => x.Location.Latitude), Longitude = rows[row1].Get<GPSTrackerLocation, double>(x => x.Location.Longitude) };
            //InABox.Core.Location c1 = new InABox.Core.Location() { Latitude = rows[row2].Get<GPSTrackerLocation, double>(x => x.Location.Latitude), Longitude = rows[row2].Get<GPSTrackerLocation, double>(x => x.Location.Longitude) };
            //return c1.DistanceTo(c0, UnitOfLength.Kilometers) * 1000F > 25F;
            var bDate = DateTime.Equals(
                rows[row1].Get<GPSTrackerLocation, DateTime>(x => x.Created).Date,
                rows[row2].Get<GPSTrackerLocation, DateTime>(x => x.Created).Date
            );

            var bAddress = string.Equals(
                rows[row1].Get<GPSTrackerLocation, string>(x => x.Location.Address),
                rows[row2].Get<GPSTrackerLocation, string>(x => x.Location.Address)
            );

            return /* !bDate || */ !bAddress;
        }

        private void AddHistory(ObservableCollection<GPSHistory> movements, List<GPSTrackerLocation> updates, CoreRow row)
        {
            var cur = new Location
            {
                Latitude = row.Get<GPSTrackerLocation, double>(x => x.Location.Latitude),
                Longitude = row.Get<GPSTrackerLocation, double>(x => x.Location.Longitude)
            };
            var address = row.Get<GPSTrackerLocation, string>(x => x.Location.Address);
            if (string.IsNullOrWhiteSpace(address))
            {
                address = StoreUtils.ReverseGeocode(cur.Latitude, cur.Longitude);
                var update = row.ToObject<GPSTrackerLocation>();
                update.Location.Address = address;
                updates.Add(update);
            }

            var history = new GPSHistory
            {
                Date = row.Get<GPSTrackerLocation, DateTime>(x => x.Location.Timestamp),
                Description = address,
                Latitude = cur.Latitude,
                Longitude = cur.Longitude
            };
            Dispatcher.Invoke(() => { movements.Add(history); });
        }

        private static bool IsMarkerVisible(MapMarker marker, Point northwest, Point southeast)
        {
            if (northwest.X == 0 && northwest.Y == 0)
                return true;

            var lat = double.Parse(marker.Latitude);
            var lon = double.Parse(marker.Longitude);

            var lat1 = northwest.Y < 0 ? lat <= northwest.Y : lat > northwest.Y;
            var lat2 = southeast.Y < 0 ? lat >= southeast.Y : lat <= southeast.Y;
            var lon1 = northwest.X < 0 ? lon <= northwest.X : lon > northwest.X;
            var lon2 = southeast.X < 0 ? lon >= southeast.X : lon <= southeast.X;

            return lat1 && lat2 && lon1 && lon2;
        }

        private void LoadMarkerList()
        {
            //var timer = new DispatcherTimer() { Interval = TimeSpan.FromMilliseconds(1) };
            //timer.Tick += ((t,e) => 
            //{
            //timer.IsEnabled = false;
            ViewModel.Refresh();

            var layer = Map.Layers[0] as ImageryLayer;
            var nw = layer.GetLatLonFromPoint(new Point(0F, 0F));
            var se = layer.GetLatLonFromPoint(new Point(Map.ActualWidth, Map.ActualHeight));
            var markers = ViewModel.Markers.Where(marker => ShowAll.IsChecked == true ? true : IsMarkerVisible(marker, nw, se))
                .OrderBy(x => x.Description);
            Markers.ItemsSource = markers.ToArray();
            //});
            //timer.IsEnabled = true;
        }

        private void Map_PreviewMouseUp(object sender, MouseButtonEventArgs e)
        {
            LoadMarkerList();
        }

        private void Markers_MouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            var marker = Markers.SelectedItem as MapMarker;
            ZoomToMarker(marker);
        }

        private void ZoomToMarker(MapMarker marker)
        {
            if (marker == null)
                return;
            
            if (double.Parse(marker.Latitude) != 0.0F && double.Parse(marker.Longitude) != 0.0F)
            {
                var layer = Map.Layers[0] as ImageryLayer;
                layer.Center = new Point(double.Parse(marker.Latitude), double.Parse(marker.Longitude));
                Map.ZoomLevel = ZOOMEDIN;
            }
        }

        private void Markers_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            var marker = Markers.SelectedItem as MapMarker;
            ViewModel.Selected = Markers.SelectedItem as MapMarker;

            if (marker != null)
            {
                Description.Text = marker.Description;
                LastUpdate.Text = string.Format("{0:dd MMM yy hh:mm:ss}", marker.Updated);
                Device.Text = marker.UpdatedBy;
                History.Visibility = string.IsNullOrWhiteSpace(marker.DeviceID) ? Visibility.Collapsed : Visibility.Visible;
                LoadDeviceHistory(marker.DeviceID);
            }
            else
            {
                Description.Text = "";
                LastUpdate.Text = "";
                Device.Text = "";
                History.Visibility = Visibility.Collapsed;
            }
        }

        private void Viewstyle_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            var layer = typeof(ImageryLayer);
            var type = LayerType.OSM;
            var style = BingMapStyle.Road;

            if (Viewstyle.SelectedItem == BingStandardViewStyle)
            {
                layer = typeof(ImageryLayer);
                type = LayerType.Bing;
                style = BingMapStyle.Road;
            }
            else if (Viewstyle.SelectedItem == BingTerrainViewStyle)
            {
                layer = typeof(ImageryLayer);
                type = LayerType.Bing;
                style = BingMapStyle.Aerial;
            }
            else if (Viewstyle.SelectedItem == BingTerrainLabelsViewStyle)
            {
                layer = typeof(ImageryLayer);
                type = LayerType.Bing;
                style = BingMapStyle.AerialWithLabels;
            }
            else if (Viewstyle.SelectedItem == GoogleMapsViewStyle)
            {
                layer = typeof(GoogleImageryLayer);
            }
            else
            {
                layer = typeof(ImageryLayer);
                type = LayerType.OSM;
            }

            var cur = Map.Layers[0] as ImageryLayer;
            if (!cur.GetType().Equals(layer))
            {
                var center = cur.Center;
                var radius = cur.Radius;
                var template = cur.MarkerTemplate;
                Map.Layers.Clear();
                if (layer == typeof(ImageryLayer))
                    Map.Layers.Add(new ImageryLayer());
                else if (layer == typeof(GoogleImageryLayer))
                    Map.Layers.Add(new GoogleImageryLayer());
                cur = Map.Layers[0] as ImageryLayer;
                cur.Center = center;
                cur.Radius = radius;
                cur.MarkerTemplate = template;
                cur.Markers = ViewModel.Markers;
                cur.BingMapKey = "5kn7uPPBBGKdmWYiwHJL~LjUY7IIgFzGdXpkpWT7Fsw~AmlksNuYOBHNQ3cOa61Nz2ghvK5EbrBZ3aQqvTS4OjcPxTBGNGsj2hKc058CgtgJ";
            }

            if (cur.LayerType != type)
                cur.LayerType = type;
            if (cur.BingMapStyle != style)
                cur.BingMapStyle = style;
        }

        private void IncludeVisibleMarkers_Checked(object sender, RoutedEventArgs e)
        {
            LoadMarkerList();
        }

        private void ResetView_Click(object sender, RoutedEventArgs e)
        {
            ResetZoom();
        }

        private void History_MouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            var history = History.SelectedItem as GPSHistory;
            if (history == null)
                return;
            if (history.Latitude != 0.0F && history.Longitude != 0.0F)
            {
                var layer = Map.Layers[0] as ImageryLayer;
                layer.Center = new Point(history.Latitude, history.Longitude);
                Map.ZoomLevel = ZOOMEDIN;
            }
        }

        private void Zoom_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
        {
            if (Map == null)
                return;
            Map.ZoomLevel = (int)e.NewValue;
            LoadMarkerList();
        }

 

        private void TabView_PageChanged(object sender, SelectionChangedEventArgs e)
        {
            ViewModel.View = TabView.SelectedIndex == 0
                ? LiveMapView.All
                : LiveMapView.Selected;
            // ImageryLayer.MarkerTemplate = TabView.SelectedIndex == 0
            //     ? TryFindResource("MapMarkerTemplate") as DataTemplate
            //     : TryFindResource("MapWayPointTemplate") as DataTemplate;
        }
    }
}