Pre-fetch larger areas to reduce calls to overpass; split large requests up

lib/services/map_data_submodules/nodes_from_overpass.dart

@@ -8,17 +8,79 @@ import '../../models/node_profile.dart';
 import '../../models/osm_node.dart';
 import '../../models/pending_upload.dart';
 import '../../app_state.dart';
+import '../../dev_config.dart';
 import '../network_status.dart';
+import '../overpass_node_limit_exception.dart';
 
 /// Fetches surveillance nodes from the Overpass OSM API for the given bounds and profiles.
+/// If the query fails due to too many nodes, automatically splits the area and retries.
 Future<List<OsmNode>> fetchOverpassNodes({
   required LatLngBounds bounds,
   required List<NodeProfile> profiles,
   UploadMode uploadMode = UploadMode.production,
   required int maxResults,
+}) async {
+  return _fetchOverpassNodesWithSplitting(
+    bounds: bounds,
+    profiles: profiles,
+    uploadMode: uploadMode,
+    maxResults: maxResults,
+    splitDepth: 0,
+  );
+}
+
+/// Internal method that handles splitting when node limit is exceeded.
+Future<List<OsmNode>> _fetchOverpassNodesWithSplitting({
+  required LatLngBounds bounds,
+  required List<NodeProfile> profiles,
+  UploadMode uploadMode = UploadMode.production,
+  required int maxResults,
+  required int splitDepth,
 }) async {
   if (profiles.isEmpty) return [];
   
+  const int maxSplitDepth = kMaxPreFetchSplitDepth; // Maximum times we'll split (4^3 = 64 max sub-areas)
+  
+  try {
+    return await _fetchSingleOverpassQuery(
+      bounds: bounds,
+      profiles: profiles,
+      maxResults: maxResults,
+    );
+  } on OverpassNodeLimitException {
+    // If we've hit max split depth, give up to avoid infinite recursion
+    if (splitDepth >= maxSplitDepth) {
+      debugPrint('[fetchOverpassNodes] Max split depth reached, giving up on area: $bounds');
+      return [];
+    }
+    
+    // Split the bounds into 4 quadrants and try each separately
+    debugPrint('[fetchOverpassNodes] Splitting area into quadrants (depth: $splitDepth)');
+    final quadrants = _splitBounds(bounds);
+    final List<OsmNode> allNodes = [];
+    
+    for (final quadrant in quadrants) {
+      final nodes = await _fetchOverpassNodesWithSplitting(
+        bounds: quadrant,
+        profiles: profiles,
+        uploadMode: uploadMode,
+        maxResults: 0, // No limit on individual quadrants to avoid double-limiting
+        splitDepth: splitDepth + 1,
+      );
+      allNodes.addAll(nodes);
+    }
+    
+    debugPrint('[fetchOverpassNodes] Collected ${allNodes.length} nodes from ${quadrants.length} quadrants');
+    return allNodes;
+  }
+}
+
+/// Perform a single Overpass query without splitting logic.
+Future<List<OsmNode>> _fetchSingleOverpassQuery({
+  required LatLngBounds bounds,
+  required List<NodeProfile> profiles,
+  required int maxResults,
+}) async {
   const String overpassEndpoint = 'https://overpass-api.de/api/interpreter';
   
   // Build the Overpass query
@@ -34,7 +96,19 @@ Future<List<OsmNode>> fetchOverpassNodes({
     );
     
     if (response.statusCode != 200) {
-      debugPrint('[fetchOverpassNodes] Overpass API error: ${response.body}');
+      final errorBody = response.body;
+      debugPrint('[fetchOverpassNodes] Overpass API error: $errorBody');
+      
+      // Check if it's a node limit exceeded error
+      if (errorBody.contains('too many') || 
+          errorBody.contains('50000') || 
+          errorBody.contains('50,000') ||
+          errorBody.contains('limit') ||
+          errorBody.contains('runtime error')) {
+        debugPrint('[fetchOverpassNodes] Detected node limit error, will attempt splitting');
+        throw OverpassNodeLimitException('Query exceeded node limit', serverResponse: errorBody);
+      }
+      
       NetworkStatus.instance.reportOverpassIssue();
       return [];
     }
@@ -62,6 +136,9 @@ Future<List<OsmNode>> fetchOverpassNodes({
     return nodes;
     
   } catch (e) {
+    // Re-throw OverpassNodeLimitException so splitting logic can catch it
+    if (e is OverpassNodeLimitException) rethrow;
+    
     debugPrint('[fetchOverpassNodes] Exception: $e');
     
     // Report network issues for connection errors
@@ -100,6 +177,35 @@ $outputClause
 ''';
 }
 
+/// Split a LatLngBounds into 4 quadrants (NW, NE, SW, SE).
+List<LatLngBounds> _splitBounds(LatLngBounds bounds) {
+  final centerLat = (bounds.north + bounds.south) / 2;
+  final centerLng = (bounds.east + bounds.west) / 2;
+  
+  return [
+    // Southwest quadrant (bottom-left)
+    LatLngBounds(
+      LatLng(bounds.south, bounds.west),
+      LatLng(centerLat, centerLng),
+    ),
+    // Southeast quadrant (bottom-right)
+    LatLngBounds(
+      LatLng(bounds.south, centerLng),
+      LatLng(centerLat, bounds.east),
+    ),
+    // Northwest quadrant (top-left)
+    LatLngBounds(
+      LatLng(centerLat, bounds.west),
+      LatLng(bounds.north, centerLng),
+    ),
+    // Northeast quadrant (top-right)
+    LatLngBounds(
+      LatLng(centerLat, centerLng),
+      LatLng(bounds.north, bounds.east),
+    ),
+  ];
+}
+
 /// Clean up pending uploads that now appear in Overpass results
 void _cleanupCompletedUploads(List<OsmNode> overpassNodes) {
   try {