using System;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.Linq;
using System.Threading.Tasks;

namespace MapsNavigationSystem
{
    #region Geospatial Primitives

    public readonly struct GeoPoint : IEquatable<GeoPoint>
    {
        public double Latitude { get; }
        public double Longitude { get; }

        public GeoPoint(double latitude, double longitude)
        {
            Latitude = latitude;
            Longitude = longitude;
        }

        public bool Equals(GeoPoint other) =>
            Latitude.Equals(other.Latitude) &&
            Longitude.Equals(other.Longitude);

        public override bool Equals(object? obj) =>
            obj is GeoPoint p && Equals(p);

        public override int GetHashCode() =>
            HashCode.Combine(Latitude, Longitude);

        public override string ToString() =>
            $"({Latitude:F6}, {Longitude:F6})";

        public static double HaversineDistance(
            GeoPoint a, GeoPoint b)
        {
            const double R = 6371000; // Earth radius in meters
            double dLat = ToRadians(b.Latitude - a.Latitude);
            double dLon = ToRadians(b.Longitude - a.Longitude);
            double lat1 = ToRadians(a.Latitude);
            double lat2 = ToRadians(b.Latitude);

            double h = Math.Sin(dLat / 2) *
                       Math.Sin(dLat / 2) +
                       Math.Cos(lat1) * Math.Cos(lat2) *
                       Math.Sin(dLon / 2) *
                       Math.Sin(dLon / 2);
            return R * 2 * Math.Atan2(
                Math.Sqrt(h), Math.Sqrt(1 - h));
        }

        private static double ToRadians(
            double degrees) => degrees * Math.PI / 180.0;
    }

    public readonly struct BoundingBox
    {
        public GeoPoint SouthWest { get; }
        public GeoPoint NorthEast { get; }

        public BoundingBox(GeoPoint sw, GeoPoint ne)
        {
            SouthWest = sw;
            NorthEast = ne;
        }

        public bool Contains(GeoPoint point) =>
            point.Latitude >= SouthWest.Latitude &&
            point.Latitude <= NorthEast.Latitude &&
            point.Longitude >= SouthWest.Longitude &&
            point.Longitude <= NorthEast.Longitude;
    }

    #endregion

#region Geospatial Index - S2-like Cell System public class GeoCellIndex { private readonly int _level; private readonly Dictionary<long, List<GeoPoint>> _cells; public GeoCellIndex(int level = 18) { _level = level; _cells = new Dictionary<long, List<GeoPoint>>(); } public long GetCellId(GeoPoint point) { double latRad = point.Latitude * Math.PI / 180.0; double lngRad = point.Longitude * Math.PI / 180.0; int face = GetFace(latRad, lngRad); double u = Math.Tan(lngRad); double v = Math.Tan(latRad) / Math.Cos(lngRad); long cellId = face << (_level * 2); long i = 0; double s = Math.PI / 2; for (int k = 1; k <= _level; k++) { int section = 0; double midLat = latRad + (v >= 0 ? s / 2 : -s / 2); double midLng = lngRad + (u >= 0 ? s / 2 : -s / 2); if (Math.Abs(latRad) > Math.Abs(midLat)) section |= 2; if (Math.Abs(lngRad) > Math.Abs(midLng)) section |= 1; i = (i << 2) | section; s /= 2; } cellId |= i; return cellId; } public List<GeoPoint> Query( GeoPoint center, double radiusMeters) { var results = new List<GeoPoint>(); long centerCell = GetCellId(center); long cellRange = (long)(radiusMeters / GetCellSizeMeters()) + 1; for (long dx = -cellRange; dx <= cellRange; dx++) { long neighborCell = centerCell + dx; if (_cells.TryGetValue( neighborCell, out var points)) { foreach (var point in points) { if (GeoPoint.HaversineDistance( center, point) <= radiusMeters) results.Add(point); } } } return results; } public void Insert(GeoPoint point) { long cellId = GetCellId(point); if (!_cells.ContainsKey(cellId)) _cells[cellId] = new List<GeoPoint>(); _cells[cellId].Add(point); } public int Count => _cells.Values.Sum(l => l.Count); private int GetFace( double latRad, double lngRad) => (int)((latRad + Math.PI / 2) / (Math.PI / 3)); private double GetCellSizeMeters() => 40075000.0 / Math.Pow(2, _level) * Math.Cos(0); } #endregion #region Road Graph and Routing public enum RoadType { Highway = 0, MajorRoad = 1, MinorRoad = 2, Residential = 3, Pedestrian = 4, BikePath = 5 } public class RoadNode { public string Id { get; set; } = string.Empty; public GeoPoint Location { get; set; } public int Importance { get; set; } public List<RoadEdge> Edges { get; set; } = new(); public RoadNode(string id, GeoPoint location, int importance = 0) { Id = id; Location = location; Importance = importance; } } public class RoadEdge { public string Id { get; set; } = string.Empty; public string FromNodeId { get; set; } = string.Empty; public string ToNodeId { get; set; } = string.Empty; public string RoadName { get; set; } = string.Empty; public double DistanceMeters { get; set; } public double SpeedLimitKmh { get; set; } public RoadType RoadType { get; set; } public bool IsOneWay { get; set; } public double CurrentSpeedKmh { get; set; } public List<GeoPoint> Polyline { get; set; } = new(); public double FreeFlowTimeSeconds => DistanceMeters / (SpeedLimitKmh / 3.6); public double CurrentTimeSeconds => CurrentSpeedKmh > 0 ? DistanceMeters / (CurrentSpeedKmh / 3.6) : FreeFlowTimeSeconds * 2.0; public double CongestionLevel => CurrentSpeedKmh > 0 ? 1.0 - (CurrentSpeedKmh / SpeedLimitKmh) : 1.0; } public class RoadGraph { private readonly Dictionary<string, RoadNode> _nodes = new(); private readonly Dictionary<string, RoadEdge> _edges = new(); private readonly GeoCellIndex _nodeIndex; public RoadGraph() { _nodeIndex = new GeoCellIndex(level: 15); } public void AddNode(RoadNode node) { _nodes[node.Id] = node; _nodeIndex.Insert(node.Location); } public void AddEdge(RoadEdge edge) { _edges[edge.Id] = edge; if (_nodes.TryGetValue( edge.FromNodeId, out var fromNode)) fromNode.Edges.Add(edge); } public RoadNode? FindNearestNode( GeoPoint point) { var candidates = _nodeIndex.Query(point, 500); RoadNode? nearest = null; double minDist = double.MaxValue; foreach (var candidate in candidates) { var node = _nodes.Values .FirstOrDefault(n => n.Location.Equals(candidate)); if (node != null) { double dist = GeoPoint.HaversineDistance( point, node.Location); if (dist < minDist) { minDist = dist; nearest = node; } } } return nearest; } public (List<string> path, double totalTimeSeconds) FindShortestPath( string startNodeId, string endNodeId) { var distances = new Dictionary<string, double>(); var previous = new Dictionary<string, string?>(); var visited = new HashSet<string>(); var pq = new SortedSet< (double dist, string nodeId)>(); foreach (var nodeId in _nodes.Keys) distances[nodeId] = double.MaxValue; distances[startNodeId] = 0; previous[startNodeId] = null; pq.Add((0, startNodeId)); while (pq.Count > 0) { var cur = pq.Min; pq.Remove(pq.Min); if (!visited.Add(cur.nodeId)) continue; if (cur.nodeId == endNodeId) break; if (!_nodes.TryGetValue( cur.nodeId, out var currentNode)) continue; foreach (var edge in currentNode.Edges) { if (visited.Contains( edge.ToNodeId)) continue; double edgeTime = edge.CurrentTimeSeconds; double newDist = cur.dist + edgeTime; if (newDist < distances.GetValueOrDefault( edge.ToNodeId, double.MaxValue)) { distances[edge.ToNodeId] = newDist; previous[edge.ToNodeId] = cur.nodeId; pq.Add((newDist, edge.ToNodeId)); } } } var path = ReconstructPath( previous, endNodeId); double totalTime = distances.GetValueOrDefault( endNodeId, double.MaxValue); return (path, totalTime); } public (List<string> path, double totalTimeSeconds) FindPathAStar( string startNodeId, string endNodeId) { if (!_nodes.ContainsKey(startNodeId) || !_nodes.ContainsKey(endNodeId)) return (new List<string>(), double.MaxValue); var gScore = new Dictionary<string, double>(); var fScore = new Dictionary<string, double>(); var previous = new Dictionary<string, string?>(); var closedSet = new HashSet<string>(); var openSet = new SortedSet< (double f, string nodeId)>(); gScore[startNodeId] = 0; fScore[startNodeId] = Heuristic(startNodeId, endNodeId); openSet.Add( (fScore[startNodeId], startNodeId)); while (openSet.Count > 0) { var (_, currentId) = openSet.Min; openSet.Remove(openSet.Min); if (currentId == endNodeId) break; closedSet.Add(currentId); if (!_nodes.TryGetValue( currentId, out var currentNode)) continue; foreach (var edge in currentNode.Edges) { if (closedSet.Contains( edge.ToNodeId)) continue; double tentativeG = gScore[currentId] + edge.CurrentTimeSeconds; double currentG = gScore.GetValueOrDefault( edge.ToNodeId, double.MaxValue); if (tentativeG < currentG) { previous[edge.ToNodeId] = currentId; gScore[edge.ToNodeId] = tentativeG; double f = tentativeG + Heuristic( edge.ToNodeId, endNodeId); fScore[edge.ToNodeId] = f; openSet.Add((f, edge.ToNodeId)); } } } var path = ReconstructPath( previous, endNodeId); double totalTime = gScore.GetValueOrDefault( endNodeId, double.MaxValue); return (path, totalTime); } private double Heuristic( string nodeId, string endNodeId) { if (_nodes.TryGetValue(nodeId, out var node) && _nodes.TryGetValue(endNodeId, out var endNode)) { return GeoPoint .HaversineDistance( node.Location, endNode.Location) / 33.3; } return 0; } private List<string> ReconstructPath( Dictionary<string, string?> previous, string endNodeId) { var path = new List<string>(); string? current = endNodeId; while (current != null) { path.Insert(0, current); previous.TryGetValue( current, out current); } return path.Count > 1 ? path : new List<string>(); } public int NodeCount => _nodes.Count; public int EdgeCount => _edges.Count; public IReadOnlyCollection<RoadNode> Nodes => _nodes.Values; } #endregion #region Map Tile System public enum TileFormat { Png, Webp, Pbf } public class MapTile { public int Zoom { get; set; } public int X { get; set; } public int Y { get; set; } public TileFormat Format { get; set; } public byte[] Data { get; set; } = Array.Empty<byte>(); public DateTime RenderedAt { get; set; } public long Version { get; set; } public string TileId => $"{Zoom}/{X}/{Y}"; public string ToUrl(string baseUrl) => $"{baseUrl}/tiles/{Zoom}/{X}/{Y}" + $".{Format.ToString().ToLower()}"; } public class TileCache { private readonly ConcurrentDictionary< string, MapTile> _l1Cache; private readonly int _l1MaxSize; public TileCache( int l1MaxSize = 10000) { _l1MaxSize = l1MaxSize; _l1Cache = new ConcurrentDictionary< string, MapTile>(); } public MapTile? GetTile( int zoom, int x, int y, TileFormat format) { string key = $"{zoom}/{x}/{y}/{format}"; return _l1Cache.TryGetValue( key, out var tile) ? tile : null; } public void PutTile(MapTile tile) { string key = tile.TileId + "/" + tile.Format; if (_l1Cache.Count >= _l1MaxSize) { var oldest = _l1Cache .OrderBy(kvp => kvp.Value.RenderedAt) .Take(_l1MaxSize / 4) .Select(kvp => kvp.Key) .ToList(); foreach (var k in oldest) _l1Cache.TryRemove(k, out _); } _l1Cache[key] = tile; } public List<MapTile> PrefetchRouteTiles( List<GeoPoint> routePolyline, int minZoom = 12, int maxZoom = 16) { var tiles = new List<MapTile>(); var visited = new HashSet<string>(); for (int zoom = minZoom; zoom <= maxZoom; zoom++) { foreach (var point in routePolyline) { var (tx, ty) = LatLngToTile( point.Latitude, point.Longitude, zoom); for (int dx = -2; dx <= 2; dx++) { for (int dy = -2; dy <= 2; dy++) { int x = tx + dx; int y = ty + dy; string key = $"{zoom}/{x}/{y}"; if (visited.Add(key)) { tiles.Add( new MapTile { Zoom = zoom, X = x, Y = y, Format = TileFormat.Pbf, RenderedAt = DateTime.UtcNow }); } } } } } return tiles; } public static (int x, int y) LatLngToTile( double lat, double lng, int zoom) { int n = (int)Math.Pow(2, zoom); int x = (int)((lng + 180.0) / 360.0 * n); int y = (int)( (1.0 - Math.Log( Math.Tan(lat * Math.PI / 180.0) + 1.0 / Math.Cos( lat * Math.PI / 180.0) ) / Math.PI) / 2.0 * n); return ( Math.Clamp(x, 0, n - 1), Math.Clamp(y, 0, n - 1)); } public int CacheSize => _l1Cache.Count; } #endregion #region Traffic System public class TrafficSegment { public string SegmentId { get; set; } = string.Empty; public DateTime RecordedAt { get; set; } public double CurrentSpeedKmh { get; set; } public double FreeFlowSpeedKmh { get; set; } public int SampleCount { get; set; } public string Source { get; set; } = "gps"; public double CongestionLevel => FreeFlowSpeedKmh > 0 ? Math.Clamp(1.0 - (CurrentSpeedKmh / FreeFlowSpeedKmh), 0, 1) : 0; public string TrafficLevel => CongestionLevel switch { < 0.25 => "GREEN", < 0.50 => "YELLOW", < 0.75 => "ORANGE", _ => "RED" }; } public class GpsPing { public string DeviceId { get; set; } = string.Empty; public GeoPoint Location { get; set; } public double SpeedKmh { get; set; } public double Heading { get; set; } public DateTime Timestamp { get; set; } public double AccuracyMeters { get; set; } } public class TrafficService { private readonly ConcurrentDictionary< string, List<TrafficSegment>> _segmentHistory; private readonly ConcurrentDictionary< string, TrafficSegment> _currentTraffic; private readonly RoadGraph _roadGraph; public TrafficService( RoadGraph roadGraph) { _roadGraph = roadGraph; _segmentHistory = new ConcurrentDictionary< string, List<TrafficSegment>>(); _currentTraffic = new ConcurrentDictionary< string, TrafficSegment>(); } public void ProcessGpsPing( GpsPing ping) { string? matchedSegment = MapMatchToSegment(ping); if (matchedSegment == null) return; var segment = _currentTraffic .GetOrAdd(matchedSegment, _ => new TrafficSegment { SegmentId = matchedSegment }); lock (segment) { double oldAvg = segment.CurrentSpeedKmh * segment.SampleCount; segment.SampleCount++; segment.CurrentSpeedKmh = (oldAvg + ping.SpeedKmh) / segment.SampleCount; segment.RecordedAt = DateTime.UtcNow; segment.Source = "gps"; } } public TrafficSegment? GetTrafficForSegment( string segmentId) { return _currentTraffic.TryGetValue( segmentId, out var segment) ? segment : null; } public List<TrafficSegment> GetTrafficForArea( BoundingBox bounds) { return _currentTraffic.Values .ToList(); } public void UpdateEdgeWeights() { foreach (var (segmentId, traffic) in _currentTraffic) { if ((DateTime.UtcNow - traffic.RecordedAt) .TotalMinutes > 5) continue; foreach (var node in _roadGraph.Nodes) { foreach (var edge in node.Edges) { if (edge.Id == segmentId) { edge.CurrentSpeedKmh = traffic .CurrentSpeedKmh; } } } } } private string? MapMatchToSegment( GpsPing ping) { var nearest = _roadGraph.FindNearestNode( ping.Location); if (nearest == null) return null; double dist = GeoPoint.HaversineDistance( ping.Location, nearest.Location); if (dist > 100) return null; return nearest.Edges .FirstOrDefault()?.Id; } public int ActiveSegmentCount => _currentTraffic.Count; } #endregion #region Place Search (POI) public class PlaceOfInterest { public string PlaceId { get; set; } = string.Empty; public string Name { get; set; } = string.Empty; public GeoPoint Location { get; set; } public string Category { get; set; } = string.Empty; public double Rating { get; set; } public int ReviewCount { get; set; } public double PopularityScore { get; set; } public bool IsOpenNow { get; set; } public string FormattedAddress { get; set; } = string.Empty; public double ComputeRelevanceScore( GeoPoint userLocation, string query) { double textScore = Name.Contains(query, StringComparison .OrdinalIgnoreCase) ? 1.0 : 0.3; double distance = GeoPoint.HaversineDistance( userLocation, Location); double proximityScore = Math.Exp(-distance / 1000); double popularityScore = PopularityScore / 100.0; double ratingScore = Rating / 5.0; return 0.35 * textScore + 0.25 * proximityScore + 0.20 * popularityScore + 0.10 * ratingScore + 0.10 * (IsOpenNow ? 1.0 : 0.3); } } public class PlaceSearchService { private readonly List< PlaceOfInterest> _places = new(); private readonly GeoCellIndex _placeIndex; public PlaceSearchService() { _placeIndex = new GeoCellIndex(level: 16); } public void AddPlace( PlaceOfInterest place) { _places.Add(place); _placeIndex.Insert(place.Location); } public List<PlaceOfInterest> Search( string query, GeoPoint userLocation, double radiusMeters = 5000, int maxResults = 20) { var nearbyPoints = _placeIndex.Query( userLocation, radiusMeters); return _places .Where(p => nearbyPoints.Contains( p.Location)) .Select(p => new { Place = p, Score = p .ComputeRelevanceScore( userLocation, query) }) .OrderByDescending( x => x.Score) .Take(maxResults) .Select(x => x.Place) .ToList(); } public List<PlaceOfInterest> Autocomplete( string prefix, GeoPoint userLocation, int maxResults = 5) { return _places .Where(p => p.Name.StartsWith(prefix, StringComparison .OrdinalIgnoreCase)) .OrderByDescending(p => p.ComputeRelevanceScore( userLocation, prefix)) .Take(maxResults) .ToList(); } public int TotalPlaces => _places.Count; } #endregion #region Navigation Engine public class NavigationInstruction { public int StepIndex { get; set; } public string Instruction { get; set; } = string.Empty; public string StreetName { get; set; } = string.Empty; public double DistanceMeters { get; set; } public double DurationSeconds { get; set; } public string ManeuverType { get; set; } = string.Empty; public GeoPoint StartPoint { get; set; } public GeoPoint EndPoint { get; set; } public string VoicePrompt => $"In {FormatDistance(DistanceMeters)}, " + $"{ManeuverType} onto {StreetName}"; private string FormatDistance( double meters) => meters < 1000 ? $"{meters:F0} meters" : $"{meters / 1000:F1} km"; } public class NavigationState { public enum NavStatus { Idle, RouteCalculated, Navigating, Rerouting, OffRoute, DestinationReached } public NavStatus Status { get; set; } = NavStatus.Idle; public List<string> RouteNodeIds { get; set; } = new(); public int CurrentStepIndex { get; set; } public GeoPoint CurrentPosition { get; set; } public double TotalDistanceMeters { get; set; } public double ElapsedTimeSeconds { get; set; } public double RemainingTimeSeconds { get; set; } public double SpeedKmh { get; set; } } public class NavigationEngine { private readonly RoadGraph _roadGraph; private readonly TrafficService _trafficService; private NavigationState _state; private List<NavigationInstruction> _instructions; public NavigationEngine( RoadGraph roadGraph, TrafficService trafficService) { _roadGraph = roadGraph; _trafficService = trafficService; _state = new NavigationState(); _instructions = new List<NavigationInstruction>(); } public NavigationState StartNavigation( GeoPoint origin, GeoPoint destination) { var startNode = _roadGraph.FindNearestNode( origin); var endNode = _roadGraph.FindNearestNode( destination); if (startNode == null || endNode == null) { _state.Status = NavigationState .NavStatus.OffRoute; return _state; } _trafficService.UpdateEdgeWeights(); var (path, totalTime) = _roadGraph.FindPathAStar( startNode.Id, endNode.Id); if (path.Count == 0) { _state.Status = NavigationState .NavStatus.OffRoute; return _state; } _state.RouteNodeIds = path; _state.CurrentStepIndex = 0; _state.CurrentPosition = origin; _state.Status = NavigationState .NavStatus.Navigating; _state.ElapsedTimeSeconds = 0; _state.RemainingTimeSeconds = totalTime; _instructions = GenerateInstructions(path); _state.TotalDistanceMeters = CalculateTotalDistance(path); return _state; } public NavigationState UpdatePosition( GeoPoint newPosition, double speedKmh) { if (_state.Status != NavigationState .NavStatus.Navigating) return _state; _state.CurrentPosition = newPosition; _state.SpeedKmh = speedKmh; _state.ElapsedTimeSeconds += 2; bool isOffRoute = CheckIfOffRoute(newPosition); if (isOffRoute) { _state.Status = NavigationState .NavStatus.Rerouting; return _state; } UpdateCurrentStep(newPosition); UpdateRemainingTime(); if (_state.CurrentStepIndex >= _instructions.Count) { _state.Status = NavigationState .NavStatus .DestinationReached; } return _state; } public NavigationState Reroute( GeoPoint currentPosition, GeoPoint destination) { return StartNavigation( currentPosition, destination); } public NavigationInstruction? GetCurrentInstruction() { if (_state.CurrentStepIndex < _instructions.Count) return _instructions[ _state.CurrentStepIndex]; return null; } public List<NavigationInstruction> GetAllInstructions() => new(_instructions); private List<NavigationInstruction> GenerateInstructions( List<string> path) { var instructions = new List<NavigationInstruction>(); for (int i = 1; i < path.Count; i++) { if (!_roadGraph.Nodes.Any( n => n.Id == path[i - 1])) continue; var fromNode = _roadGraph.Nodes.First( n => n.Id == path[i - 1]); var toNode = _roadGraph.Nodes.FirstOrDefault( n => n.Id == path[i]); if (toNode == null) continue; var edge = fromNode.Edges .FirstOrDefault( e => e.ToNodeId == path[i]); if (edge == null) continue; double bearing = CalculateBearing( fromNode.Location, toNode.Location); string maneuver = GetManeuverType(bearing, i < path.Count - 1); instructions.Add( new NavigationInstruction { StepIndex = i - 1, Instruction = $"Continue on " + $"{edge.RoadName}", StreetName = edge.RoadName, DistanceMeters = edge.DistanceMeters, DurationSeconds = edge.CurrentTimeSeconds, ManeuverType = maneuver, StartPoint = fromNode.Location, EndPoint = toNode.Location }); } return instructions; } private bool CheckIfOffRoute( GeoPoint position) { if (_state.CurrentStepIndex >= _instructions.Count) return false; var currentInstruction = _instructions[ _state.CurrentStepIndex]; double distToStep = GeoPoint.HaversineDistance( position, currentInstruction.EndPoint); bool isNearAnyStep = _instructions.Any(inst => GeoPoint.HaversineDistance( position, inst.StartPoint) < 100 || GeoPoint.HaversineDistance( position, inst.EndPoint) < 100); return distToStep > 200 && !isNearAnyStep; } private void UpdateCurrentStep( GeoPoint position) { while (_state.CurrentStepIndex < _instructions.Count - 1) { var nextStep = _instructions[ _state.CurrentStepIndex + 1]; double distToNext = GeoPoint.HaversineDistance( position, nextStep.StartPoint); if (distToNext < 50) _state.CurrentStepIndex++; else break; } } private void UpdateRemainingTime() { double remaining = 0; for (int i = _state.CurrentStepIndex; i < _instructions.Count; i++) { remaining += _instructions[i] .DurationSeconds; } _state.RemainingTimeSeconds = remaining; } private double CalculateTotalDistance( List<string> path) { double total = 0; for (int i = 1; i < path.Count; i++) { var fromNode = _roadGraph.Nodes.FirstOrDefault( n => n.Id == path[i - 1]); var toNode = _roadGraph.Nodes.FirstOrDefault( n => n.Id == path[i]); if (fromNode != null && toNode != null) { total += GeoPoint.HaversineDistance( fromNode.Location, toNode.Location); } } return total; } private double CalculateBearing( GeoPoint from, GeoPoint to) { double dLon = (to.Longitude - from.Longitude) * Math.PI / 180.0; double lat1 = from.Latitude * Math.PI / 180.0; double lat2 = to.Latitude * Math.PI / 180.0; double y = Math.Sin(dLon) * Math.Cos(lat2); double x = Math.Cos(lat1) * Math.Sin(lat2) - Math.Sin(lat1) * Math.Cos(lat2) * Math.Cos(dLon); double bearing = Math.Atan2(y, x) * 180.0 / Math.PI; return (bearing + 360) % 360; } private string GetManeuverType( double bearing, bool hasMoreSteps) { if (!hasMoreSteps) return "arrive at destination"; return bearing switch { >= 337.5 or < 22.5 => "go straight", >= 22.5 and < 67.5 => "turn slight right", >= 67.5 and < 112.5 => "turn right", >= 112.5 and < 157.5 => "turn sharp right", >= 157.5 and < 202.5 => "make a U-turn", >= 202.5 and < 247.5 => "turn sharp left", >= 247.5 and < 292.5 => "turn left", >= 292.5 and < 337.5 => "turn slight left", _ => "continue" }; } } #endregion }