namespace GeoSus.Server;

using System.Collections.Concurrent;
using System.Net.Http.Json;
using System.Text.Json;
using System.Text.Json.Serialization;
using Microsoft.Extensions.Logging;

/// <summary>
/// Service for fetching and processing OpenStreetMap data via Overpass API
/// </summary>
public class OverpassService
{
    private readonly ServerConfig _config;
    private readonly ILogger _logger;
    private readonly HttpClient _httpClient;
    private readonly ConcurrentDictionary<string, MapData> _cache = new();
    
    public OverpassService(ServerConfig config, ILogger logger)
    {
        _config = config;
        _logger = logger;
        _httpClient = new HttpClient
        {
            Timeout = TimeSpan.FromSeconds(config.OverpassTimeoutSec)
        };
    }
    
    /// <summary>
    /// Fetch map data for a circular area, with caching
    /// </summary>
    public async Task<MapData?> GetMapDataAsync(Position center, double radiusMeters)
    {
        var cacheKey = $"{center.Lat:F5}_{center.Lon:F5}_{radiusMeters:F0}";
        
        if (_cache.TryGetValue(cacheKey, out var cached))
        {
            _logger.LogDebug("Map data cache hit for {CacheKey}", cacheKey);
            return cached;
        }
        
        try
        {
            var mapData = await FetchMapDataAsync(center, radiusMeters);
            if (mapData != null)
            {
                _cache[cacheKey] = mapData;
                
                // Clean old cache entries if too many
                if (_cache.Count > _config.OverpassCacheMaxEntries)
                {
                    var oldest = _cache.Keys.First();
                    _cache.TryRemove(oldest, out _);
                }
            }
            return mapData;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to fetch Overpass data for {Center}, radius {Radius}m", center, radiusMeters);
            return null;
        }
    }
    
    public async Task<MapData?> FetchMapDataAsync(Position center, double radiusMeters)
    {
        // Build Overpass QL query
        var query = BuildOverpassQuery(center, radiusMeters);
        
        _logger.LogInformation("Fetching Overpass data for center {Center}, radius {Radius}m", center, radiusMeters);
        
        var response = await _httpClient.PostAsync(
            _config.OverpassApiUrl,
            new FormUrlEncodedContent(new[] { new KeyValuePair<string, string>("data", query) })
        );
        
        if (!response.IsSuccessStatusCode)
        {
            _logger.LogError("Overpass API returned {StatusCode}: {Content}", 
                response.StatusCode, await response.Content.ReadAsStringAsync());
            return null;
        }
        
        var json = await response.Content.ReadAsStringAsync();
        var overpassResult = JsonSerializer.Deserialize<OverpassResult>(json, new JsonSerializerOptions
        {
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
        });
        
        if (overpassResult == null)
        {
            _logger.LogError("Failed to parse Overpass response");
            return null;
        }
        
        return ProcessOverpassResult(overpassResult, center, radiusMeters);
    }
    
    private string BuildOverpassQuery(Position center, double radiusMeters)
    {
        // Query for: roads, paths, buildings, amenities
        // We use "around" to get data within radius of center point
        return $@"
[out:json][timeout:{_config.OverpassTimeoutSec}];
(
  // Walkable ways (roads, paths, sidewalks)
  way[""highway""~""footway|path|pedestrian|steps|track|residential|tertiary|secondary|primary|service|living_street|cycleway|bridleway""]
    (around:{radiusMeters},{center.Lat},{center.Lon});
  
  // Buildings
  way[""building""]
    (around:{radiusMeters},{center.Lat},{center.Lon});
  relation[""building""]
    (around:{radiusMeters},{center.Lat},{center.Lon});
  
  // Interesting POIs for task placement
  node[""amenity""]
    (around:{radiusMeters},{center.Lat},{center.Lon});
  way[""amenity""]
    (around:{radiusMeters},{center.Lat},{center.Lon});
  
  // Parks and green areas
  way[""leisure""~""park|playground|garden""]
    (around:{radiusMeters},{center.Lat},{center.Lon});
  relation[""leisure""~""park|playground|garden""]
    (around:{radiusMeters},{center.Lat},{center.Lon});
);
out body;
>;
out skel qt;
";
    }
    
    private MapData ProcessOverpassResult(OverpassResult result, Position center, double radiusMeters)
    {
        var mapData = new MapData
        {
            Center = center,
            RadiusMeters = radiusMeters,
            FetchedAt = DateTime.UtcNow
        };
        
        // Index nodes by ID for quick lookup
        var nodesById = new Dictionary<long, OverpassNode>();
        foreach (var element in result.Elements)
        {
            if (element.Type == "node" && element.Lat.HasValue && element.Lon.HasValue)
            {
                nodesById[element.Id] = new OverpassNode
                {
                    Id = element.Id,
                    Lat = element.Lat.Value,
                    Lon = element.Lon.Value,
                    Tags = element.Tags
                };
            }
        }
        
        // Process ways
        foreach (var element in result.Elements.Where(e => e.Type == "way"))
        {
            if (element.Nodes == null || element.Nodes.Count < 2) continue;
            
            var wayNodes = new List<Position>();
            foreach (var nodeId in element.Nodes)
            {
                if (nodesById.TryGetValue(nodeId, out var node))
                {
                    wayNodes.Add(new Position(node.Lat, node.Lon));
                }
            }
            
            if (wayNodes.Count < 2) continue;
            
            var tags = element.Tags ?? new Dictionary<string, string>();
            
            // Classify way type
            if (tags.ContainsKey("building"))
            {
                mapData.Buildings.Add(new MapBuilding
                {
                    Id = $"b_{element.Id}",
                    Outline = wayNodes,
                    BuildingType = tags.GetValueOrDefault("building", "yes"),
                    Name = tags.GetValueOrDefault("name"),
                    Levels = int.TryParse(tags.GetValueOrDefault("building:levels", "1"), out var l) ? l : 1
                });
            }
            else if (tags.ContainsKey("highway"))
            {
                var highwayType = tags["highway"];
                mapData.Pathways.Add(new MapPathway
                {
                    Id = $"p_{element.Id}",
                    Points = wayNodes,
                    PathType = ClassifyPathType(highwayType),
                    Name = tags.GetValueOrDefault("name"),
                    IsWalkable = IsWalkableHighway(highwayType),
                    Width = EstimatePathWidth(highwayType),
                    IsPubliclyAccessible = IsPubliclyAccessibleWay(highwayType, tags)
                });
            }
            else if (tags.ContainsKey("leisure"))
            {
                mapData.Areas.Add(new MapArea
                {
                    Id = $"a_{element.Id}",
                    Outline = wayNodes,
                    AreaType = MapAreaType.Park,
                    Name = tags.GetValueOrDefault("name")
                });
            }
            else if (tags.ContainsKey("amenity"))
            {
                // Calculate centroid for POI
                var centroid = CalculateCentroid(wayNodes);
                mapData.PointsOfInterest.Add(new MapPOI
                {
                    Id = $"poi_{element.Id}",
                    Position = centroid,
                    PoiType = ClassifyAmenity(tags["amenity"]),
                    Name = tags.GetValueOrDefault("name")
                });
            }
        }
        
        // Process standalone POI nodes
        foreach (var element in result.Elements.Where(e => e.Type == "node" && e.Tags != null))
        {
            var tags = element.Tags!;
            if (tags.ContainsKey("amenity") && element.Lat.HasValue && element.Lon.HasValue)
            {
                mapData.PointsOfInterest.Add(new MapPOI
                {
                    Id = $"poi_{element.Id}",
                    Position = new Position(element.Lat.Value, element.Lon.Value),
                    PoiType = ClassifyAmenity(tags["amenity"]),
                    Name = tags.GetValueOrDefault("name")
                });
            }
        }
        
        // Build reachability graph and compute reachable positions
        BuildReachabilityData(mapData, center, radiusMeters);
        
        _logger.LogInformation(
            "Processed map data: {Buildings} buildings, {Pathways} pathways, {POIs} POIs, {ReachablePoints} reachable points",
            mapData.Buildings.Count, mapData.Pathways.Count, mapData.PointsOfInterest.Count, mapData.ReachablePositions.Count);
        
        return mapData;
    }
    
    private void BuildReachabilityData(MapData mapData, Position center, double radiusMeters)
    {
        // Build a graph of walkable paths and find connected components from center
        var graph = new PathGraph();
        
        // Add all walkable pathway segments to graph
        foreach (var pathway in mapData.Pathways.Where(p => p.IsWalkable))
        {
            for (int i = 0; i < pathway.Points.Count - 1; i++)
            {
                graph.AddEdge(pathway.Points[i], pathway.Points[i + 1]);
            }
        }
        
        // Find all positions reachable from center (or nearest walkable point to center)
        var startNode = graph.FindNearestNode(center);
        if (startNode == null)
        {
            _logger.LogWarning("No walkable paths found near center, using all pathway points as reachable");
            // Fallback: all pathway points are considered reachable
            foreach (var pathway in mapData.Pathways.Where(p => p.IsWalkable))
            {
                mapData.ReachablePositions.AddRange(pathway.Points);
            }
            return;
        }
        
        // BFS from start node to find all reachable nodes
        var reachable = graph.GetReachableNodes(startNode.Value, radiusMeters);
        
        // Filter to only include points within the play area
        foreach (var pos in reachable)
        {
            if (pos.DistanceTo(center) <= radiusMeters)
            {
                mapData.ReachablePositions.Add(pos);
            }
        }
        
        // Also mark pathways as reachable or not
        foreach (var pathway in mapData.Pathways)
        {
            var reachablePoints = pathway.Points.Count(p => 
                mapData.ReachablePositions.Any(rp => rp.DistanceTo(p) < 5));
            pathway.IsFullyReachable = reachablePoints == pathway.Points.Count;
            pathway.IsPartiallyReachable = reachablePoints > 0;
        }
        
        _logger.LogDebug("Reachability analysis: {Reachable} of {Total} positions are reachable from center",
            mapData.ReachablePositions.Count, 
            mapData.Pathways.Sum(p => p.Points.Count));
    }
    
    private PathType ClassifyPathType(string highway)
    {
        return highway switch
        {
            "footway" or "pedestrian" or "path" => PathType.Footway,
            "steps" => PathType.Steps,
            "cycleway" => PathType.Cycleway,
            "residential" or "living_street" => PathType.Residential,
            "service" => PathType.Service,
            "tertiary" or "secondary" or "primary" => PathType.Road,
            "track" or "bridleway" => PathType.Track,
            _ => PathType.Other
        };
    }
    
    private bool IsWalkableHighway(string highway)
    {
        // Everything except motorways is considered walkable
        return highway switch
        {
            "motorway" or "motorway_link" or "trunk" or "trunk_link" => false,
            _ => true
        };
    }

    /// <summary>
    /// P11: Strict public-access check for task placement. Returns true only
    /// when the way is unambiguously safe and legal for a foot player to
    /// stand on. Bandwidth's directive: "brutal check even at the cost of
    /// quality" - we'd rather refuse 80% of marginal candidates than place
    /// one task on a private driveway or a busy primary road. The `any
    /// pathway point` fallback in GetRandomReachablePosition still works for
    /// rural/forest scenarios where this filter rejects everything.
    ///
    /// Hard rejects:
    ///   - access tag in {private, no, customers, permit, forestry,
    ///     agricultural, military, employees, delivery}
    ///   - foot tag in {no, private, discouraged}
    ///   - highway types known to be unsafe foot terrain (busy roads) or
    ///     ambiguous (service ways often = parking lots / driveways unless
    ///     explicitly tagged otherwise).
    /// </summary>
    private bool IsPubliclyAccessibleWay(string highway, Dictionary<string, string> tags)
    {
        // Hard-reject the highway types we never want a task on.
        switch (highway)
        {
            case "motorway":
            case "motorway_link":
            case "trunk":
            case "trunk_link":
            case "primary":
            case "primary_link":
            case "secondary":
            case "secondary_link":
            case "tertiary":
            case "tertiary_link":
                // Roads people drive fast on - even if foot is technically
                // allowed, putting a task target here invites tragedy.
                return false;
            case "construction":
            case "proposed":
            case "abandoned":
            case "razed":
                // Not even a real path right now.
                return false;
            case "raceway":
            case "bus_guideway":
            case "escape":
                // Specialized infrastructure, never appropriate.
                return false;
        }

        // Access tag: explicit private/restricted = reject.
        if (tags.TryGetValue("access", out var access))
        {
            access = access.ToLowerInvariant();
            switch (access)
            {
                case "private":
                case "no":
                case "customers":
                case "permit":
                case "forestry":
                case "agricultural":
                case "military":
                case "employees":
                case "delivery":
                case "destination":
                    return false;
            }
        }

        // foot tag: explicit foot=no = reject regardless of highway type.
        if (tags.TryGetValue("foot", out var foot))
        {
            foot = foot.ToLowerInvariant();
            switch (foot)
            {
                case "no":
                case "private":
                case "discouraged":
                    return false;
            }
        }

        // motor_vehicle / vehicle tags can flag a way as no-vehicles only,
        // which usually implies pedestrians are welcome - we don't reject
        // on those, just note them as positive evidence in the explicit-
        // approval branch below.

        // Service ways: commonly driveways, parking lots, alleys. Reject by
        // default unless the access/foot/service tag explicitly opens it up.
        if (highway == "service")
        {
            // service=alley is generally walkable; service=driveway, parking_aisle,
            // emergency_access are not.
            if (tags.TryGetValue("service", out var serviceType))
            {
                serviceType = serviceType.ToLowerInvariant();
                if (serviceType == "alley") return true;
                // All other service subtypes default to "no" without explicit access=yes.
                if (access != null && (access == "yes" || access == "permissive" || access == "public"))
                    return true;
                return false;
            }
            // No service subtag - too ambiguous, reject.
            // (Players can still walk on these IRL, but for "absolutely public"
            // we want clearer signal.)
            if (access == "yes" || access == "permissive" || access == "public")
                return true;
            return false;
        }

        // bridleway: technically horse paths; foot may or may not be allowed.
        // Require explicit foot=yes/designated to opt in.
        if (highway == "bridleway")
        {
            if (foot != null && (foot == "yes" || foot == "designated" || foot == "permissive"))
                return true;
            return false;
        }

        // Highway types we trust as inherently public foot terrain.
        switch (highway)
        {
            case "footway":
            case "path":
            case "pedestrian":
            case "steps":
            case "cycleway":
            case "residential":
            case "living_street":
            case "track":
                return true;
        }

        // Everything else: reject by default. The brutal-mode point is to
        // not gamble on tags we don't recognize.
        return false;
    }
    
    private double EstimatePathWidth(string highway)
    {
        return highway switch
        {
            "footway" or "path" => 1.5,
            "pedestrian" => 5.0,
            "steps" => 2.0,
            "cycleway" => 2.0,
            "residential" => 6.0,
            "living_street" => 5.0,
            "service" => 4.0,
            "tertiary" => 7.0,
            "secondary" => 9.0,
            "primary" => 11.0,
            _ => 3.0
        };
    }
    
    private MapPOIType ClassifyAmenity(string amenity)
    {
        return amenity switch
        {
            "cafe" or "restaurant" or "fast_food" or "bar" or "pub" => MapPOIType.FoodDrink,
            "bank" or "atm" => MapPOIType.Finance,
            "pharmacy" or "hospital" or "clinic" or "doctors" => MapPOIType.Health,
            "school" or "university" or "library" => MapPOIType.Education,
            "fuel" or "parking" => MapPOIType.Transport,
            "shop" or "supermarket" or "convenience" => MapPOIType.Shop,
            "toilets" or "bench" or "drinking_water" => MapPOIType.Amenity,
            _ => MapPOIType.Other
        };
    }
    
    private Position CalculateCentroid(List<Position> points)
    {
        if (points.Count == 0) return new Position(0, 0);
        var lat = points.Average(p => p.Lat);
        var lon = points.Average(p => p.Lon);
        return new Position(lat, lon);
    }
    
    /// <summary>
    /// Get a random reachable position suitable for placing a task or repair station.
    ///
    /// P11 cascade (each tier falls through to the next on empty result):
    ///   1. Reachable AND on a publicly-accessible way (brutal mode preferred).
    ///   2. Any reachable position (covers the rare case where reachability
    ///      analysis hit a way we don't deem "absolutely public" but is
    ///      still pathway-connected).
    ///   3. Any walkable pathway point in radius (used in dense urban OR
    ///      rural - the fallback Bandwidth specifically asked for: "When
    ///      starting a game when there are almost no roads at all (at a
    ///      field or in a forest) we can place tasks wherever").
    /// </summary>
    public Position? GetRandomReachablePosition(MapData mapData, Random random, double minDistFromCenter = 0)
    {
        // Tier 1: reachable AND on a publicly-accessible way.
        var publicWayPoints = CollectPubliclyAccessiblePoints(mapData);
        var candidates = mapData.ReachablePositions
            .Where(p => p.DistanceTo(mapData.Center) >= minDistFromCenter)
            .Where(p => publicWayPoints.Contains(p))
            .ToList();

        if (candidates.Count == 0)
        {
            // Tier 2: any reachable, ignoring the public-only filter.
            candidates = mapData.ReachablePositions
                .Where(p => p.DistanceTo(mapData.Center) >= minDistFromCenter)
                .ToList();
        }

        if (candidates.Count == 0)
        {
            // Tier 3: any walkable pathway point in radius (rural fallback).
            candidates = mapData.Pathways
                .Where(p => p.IsWalkable)
                .SelectMany(p => p.Points)
                .Where(p => p.DistanceTo(mapData.Center) <= mapData.RadiusMeters)
                .ToList();
        }

        if (candidates.Count == 0)
            return null;

        return candidates[random.Next(candidates.Count)];
    }

    /// <summary>
    /// Set of all positions that lie on a publicly-accessible pathway. Built
    /// once per call site (cheap; pathway count is bounded by the radius).
    /// HashSet of Position relies on Position.Equals/GetHashCode being
    /// content-based; if that ever changes, swap to a custom comparer.
    /// </summary>
    private HashSet<Position> CollectPubliclyAccessiblePoints(MapData mapData)
    {
        var set = new HashSet<Position>();
        foreach (var path in mapData.Pathways)
        {
            if (!path.IsPubliclyAccessible) continue;
            foreach (var p in path.Points)
                set.Add(p);
        }
        return set;
    }
    
    /// <summary>
    /// Get multiple well-distributed reachable positions (e.g., for placing
    /// multiple tasks). Same P11 tier cascade as GetRandomReachablePosition:
    /// public-only first, fall through to reachable-any, then any walkable
    /// pathway point if even that's empty.
    /// </summary>
    public List<Position> GetDistributedReachablePositions(MapData mapData, int count, Random random, double minSpacing = 20)
    {
        var result = new List<Position>();

        // Tier 1: reachable AND public.
        var publicWayPoints = CollectPubliclyAccessiblePoints(mapData);
        var available = mapData.ReachablePositions
            .Where(p => publicWayPoints.Contains(p))
            .ToList();

        // Tier 2: any reachable.
        if (available.Count == 0)
            available = mapData.ReachablePositions.ToList();

        // Tier 3: any walkable pathway point in radius. Logged so the server
        // op can see when the brutal filter exhausted itself - useful in
        // testing to know whether the area has decent OSM coverage.
        if (available.Count == 0)
        {
            available = mapData.Pathways
                .Where(p => p.IsWalkable)
                .SelectMany(p => p.Points)
                .Where(p => p.DistanceTo(mapData.Center) <= mapData.RadiusMeters)
                .Distinct()
                .ToList();
            if (available.Count > 0)
                _logger.LogInformation("[Overpass] Task placement falling back to any-pathway-point - no publicly-accessible reachable geometry within radius {R}m of {Lat},{Lon}",
                    mapData.RadiusMeters, mapData.Center.Lat, mapData.Center.Lon);
        }

        // Shuffle available positions
        for (int i = available.Count - 1; i > 0; i--)
        {
            int j = random.Next(i + 1);
            (available[i], available[j]) = (available[j], available[i]);
        }

        foreach (var pos in available)
        {
            if (result.Count >= count) break;

            // Check minimum spacing from already selected positions
            bool tooClose = result.Any(r => r.DistanceTo(pos) < minSpacing);
            if (!tooClose)
            {
                result.Add(pos);
            }
        }
        
        // If we couldn't find enough spaced positions, fill with any available
        if (result.Count < count)
        {
            foreach (var pos in available)
            {
                if (result.Count >= count) break;
                if (!result.Contains(pos))
                {
                    result.Add(pos);
                }
            }
        }
        
        return result;
    }
    
    /// <summary>
    /// Get positions near POIs (better for task placement as they have semantic meaning)
    /// </summary>
    public List<Position> GetPOIBasedPositions(MapData mapData, int count, Random random)
    {
        var result = new List<Position>();
        
        // Prefer POIs that are reachable
        var reachablePOIs = mapData.PointsOfInterest
            .Where(poi => mapData.ReachablePositions.Any(rp => rp.DistanceTo(poi.Position) < 10))
            .ToList();
        
        // Shuffle
        for (int i = reachablePOIs.Count - 1; i > 0; i--)
        {
            int j = random.Next(i + 1);
            (reachablePOIs[i], reachablePOIs[j]) = (reachablePOIs[j], reachablePOIs[i]);
        }
        
        foreach (var poi in reachablePOIs.Take(count))
        {
            result.Add(poi.Position);
        }
        
        // Fill remaining with distributed positions
        if (result.Count < count)
        {
            var additional = GetDistributedReachablePositions(mapData, count - result.Count, random);
            result.AddRange(additional);
        }
        
        return result;
    }
}

#region Overpass API Response Types

internal class OverpassResult
{
    [JsonPropertyName("elements")]
    public List<OverpassElement> Elements { get; set; } = new();
}

internal class OverpassElement
{
    [JsonPropertyName("type")]
    public string Type { get; set; } = "";
    
    [JsonPropertyName("id")]
    public long Id { get; set; }
    
    [JsonPropertyName("lat")]
    public double? Lat { get; set; }
    
    [JsonPropertyName("lon")]
    public double? Lon { get; set; }
    
    [JsonPropertyName("nodes")]
    public List<long>? Nodes { get; set; }
    
    [JsonPropertyName("tags")]
    public Dictionary<string, string>? Tags { get; set; }
}

internal class OverpassNode
{
    public long Id { get; set; }
    public double Lat { get; set; }
    public double Lon { get; set; }
    public Dictionary<string, string>? Tags { get; set; }
}

#endregion

#region Path Graph for Reachability

internal class PathGraph
{
    private readonly Dictionary<Position, HashSet<Position>> _adjacency = new();
    private readonly List<Position> _allNodes = new();
    
    public void AddEdge(Position a, Position b)
    {
        if (!_adjacency.ContainsKey(a))
        {
            _adjacency[a] = new HashSet<Position>();
            _allNodes.Add(a);
        }
        if (!_adjacency.ContainsKey(b))
        {
            _adjacency[b] = new HashSet<Position>();
            _allNodes.Add(b);
        }
        
        _adjacency[a].Add(b);
        _adjacency[b].Add(a);
    }
    
    public Position? FindNearestNode(Position target)
    {
        if (_allNodes.Count == 0) return null;
        
        Position? nearest = null;
        double minDist = double.MaxValue;
        
        foreach (var node in _allNodes)
        {
            var dist = node.DistanceTo(target);
            if (dist < minDist)
            {
                minDist = dist;
                nearest = node;
            }
        }
        
        return nearest;
    }
    
    public HashSet<Position> GetReachableNodes(Position start, double maxDistance)
    {
        var visited = new HashSet<Position>();
        var queue = new Queue<Position>();
        
        queue.Enqueue(start);
        visited.Add(start);
        
        while (queue.Count > 0)
        {
            var current = queue.Dequeue();
            
            if (!_adjacency.TryGetValue(current, out var neighbors))
                continue;
            
            foreach (var neighbor in neighbors)
            {
                if (!visited.Contains(neighbor) && neighbor.DistanceTo(start) <= maxDistance)
                {
                    visited.Add(neighbor);
                    queue.Enqueue(neighbor);
                }
            }
        }
        
        return visited;
    }
}

#endregion