Tasks 8 and 9

.env.example

+GOOGLE_MAPS_API_KEY=YOUR_ANDROID_SDK_KEY
+WEB_GOOGLE_API_KEY=YOUR_WEB_SERVICES_KEY
+ENVIRONMENT=development

.gitignore

@@ -44,6 +44,11 @@ app.*.map.json
 /android/app/profile
 /android/app/release
 
+node_modules/
+package-lock.json
+
+
+
 # iOS related
 **/ios/**/*.mode1v3
 **/ios/**/*.mode2v3

lib/main.dart

@@ -3,22 +3,29 @@ import 'package:go_router/go_router.dart';
 import 'package:provider/provider.dart';
 import 'package:firebase_core/firebase_core.dart';
 import 'package:firebase_auth/firebase_auth.dart';
+
 import 'firebase_options.dart';
+
 import 'screens/home_screen.dart';
 import 'screens/graph_screen.dart';
 import 'screens/settings_screen.dart';
 import 'screens/profile_screen.dart';
+import 'screens/addresses_screen.dart';
+
 import 'providers/delivery_provider.dart';
+import 'providers/graph_provider.dart';
+import 'providers/route_provider.dart';
+
 import 'login.dart';
 import 'signup.dart';
 import 'package:flutter_dotenv/flutter_dotenv.dart';
 
-void main() async {
+Future<void> main() async {
   WidgetsFlutterBinding.ensureInitialized();
+
   await dotenv.load(fileName: ".env");
-  await Firebase.initializeApp(
-    options: DefaultFirebaseOptions.currentPlatform,
-  );
+  await Firebase.initializeApp(options: DefaultFirebaseOptions.currentPlatform);
+
   runApp(const GraphGoApp());
 }
 
@@ -27,9 +34,20 @@ class GraphGoApp extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    return ChangeNotifierProvider(
-      create: (context) => DeliveryProvider()..initialize(),
+    return MultiProvider(
+      providers: [
+        ChangeNotifierProvider(create: (_) => DeliveryProvider()..initialize()),
+        ChangeNotifierProvider(create: (_) => GraphProvider()),
+        // Important: don't recreate RouteProvider on updates
+        ChangeNotifierProvider(
+          create: (ctx) => RouteProvider(
+            graph: ctx.read<GraphProvider>(),
+            deliveries: ctx.read<DeliveryProvider>(),
+          ),
+        ),
+      ],
       child: MaterialApp.router(
+        debugShowCheckedModeBanner: false,
         title: 'GraphGo - Route Optimization',
         theme: ThemeData(
           colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
@@ -42,57 +60,52 @@ class GraphGoApp extends StatelessWidget {
 }
 
 final GoRouter _router = GoRouter(
+  // ⬇️ Start on HOME, not /graph
+  initialLocation: '/',
   redirect: (BuildContext context, GoRouterState state) {
     final user = FirebaseAuth.instance.currentUser;
     final isLoggedIn = user != null;
-    final isLoggingIn = state.matchedLocation == '/login' || state.matchedLocation == '/signup';
-    
-    // If user is logged in and trying to access login/signup pages, redirect to home
-    if (isLoggedIn && isLoggingIn) {
-      return '/';
-    }
-    
-    // No automatic redirect to login - let the home screen handle it
-    return null; // No redirect needed
+    final isLoggingIn =
+        state.matchedLocation == '/login' || state.matchedLocation == '/signup';
+
+    if (isLoggedIn && isLoggingIn) return '/';
+    return null;
   },
   routes: <RouteBase>[
     GoRoute(
       path: '/',
-      builder: (BuildContext context, GoRouterState state) {
-        return const HomeScreen();
-      },
+      builder: (BuildContext context, GoRouterState state) => const HomeScreen(),
       routes: <RouteBase>[
         GoRoute(
           path: 'graph',
-          builder: (BuildContext context, GoRouterState state) {
-            return const GraphScreen();
-          },
+          builder: (BuildContext context, GoRouterState state) => const GraphScreen(),
+        ),
+        GoRoute(
+          path: 'addresses',
+          builder: (BuildContext context, GoRouterState state) => const AddressesScreen(),
         ),
         GoRoute(
           path: 'settings',
-          builder: (BuildContext context, GoRouterState state) {
-            return const SettingsScreen();
-          },
+          builder: (BuildContext context, GoRouterState state) => const SettingsScreen(),
         ),
         GoRoute(
           path: 'profile',
-          builder: (BuildContext context, GoRouterState state) {
-            return const ProfileScreen();
-          },
+          builder: (BuildContext context, GoRouterState state) => const ProfileScreen(),
+        ),
+        // keep if anything links to /route-map; show GraphScreen
+        GoRoute(
+          path: 'route-map',
+          builder: (BuildContext context, GoRouterState state) => const GraphScreen(),
         ),
       ],
     ),
     GoRoute(
       path: '/login',
-      builder: (BuildContext context, GoRouterState state) {
-        return const LoginPage();
-      },
+      builder: (BuildContext context, GoRouterState state) => const LoginPage(),
     ),
     GoRoute(
       path: '/signup',
-      builder: (BuildContext context, GoRouterState state) {
-        return const SignupPage();
-      },
+      builder: (BuildContext context, GoRouterState state) => const SignupPage(),
     ),
   ],
-);
+);
\ No newline at end of file

lib/models/path_result.dart

+import 'package:google_maps_flutter/google_maps_flutter.dart';
+
+class PathResult {
+  final List<int> nodePath;          // node IDs in the graph
+  final double distanceMeters;       // polyline length (computed with Haversine)
+  final List<LatLng> points;         // LatLng points for the map polyline
+
+  const PathResult({
+    required this.nodePath,
+    required this.distanceMeters,
+    required this.points,
+  });
+}

lib/models/place_suggestion.dart

+class PlaceSuggestion {
+  final String description;
+  final String placeId;
+  PlaceSuggestion({required this.description, required this.placeId});
+}

lib/providers/delivery_provider.dart

@@ -5,11 +5,12 @@ import '../models/delivery_address.dart';
 import '../models/route_optimization.dart';
 import '../services/routing_algorithms.dart';
 import '../services/geocoding_service.dart';
+import 'package:google_maps_flutter/google_maps_flutter.dart' as gmap;
 
 class DeliveryProvider extends ChangeNotifier {
   final FirebaseAuth _auth = FirebaseAuth.instance;
   final FirebaseFirestore _firestore = FirebaseFirestore.instance;
-  
+
   List<DeliveryAddress> _addresses = [];
   List<RouteOptimization> _routeOptimizations = [];
   bool _isLoading = false;
@@ -31,6 +32,8 @@ class DeliveryProvider extends ChangeNotifier {
   }
 
   // Address Management
+  // lib/providers/delivery_provider.dart
+
   Future<void> addAddress(DeliveryAddress address) async {
     if (!canAddMoreAddresses) {
       _error = 'Maximum of 100 addresses allowed';
@@ -40,39 +43,42 @@ class DeliveryProvider extends ChangeNotifier {
 
     _setLoading(true);
     try {
-      // Geocode the address
-      final geocodedAddress = await GeocodingService.geocodeAddress(address);
-      
+      // ⬇️ NEW: if address already has coords, skip geocoding
+      final DeliveryAddress ready = address.hasCoordinates
+          ? address
+          : await GeocodingService.geocodeAddress(address);
+
       // Add to local list
-      _addresses.add(geocodedAddress);
-      
+      _addresses.add(ready);
+
       // Save to Firestore
-      await _saveAddressToFirestore(geocodedAddress);
-      
+      await _saveAddressToFirestore(ready);
+
       _error = null;
     } catch (e) {
       _error = 'Failed to add address: ${e.toString()}';
-      _addresses.remove(address); // Remove if geocoding failed
+      // If we added the raw address above, we *didn't* — so no need to remove.
     } finally {
       _setLoading(false);
     }
   }
 
+
   Future<void> updateAddress(DeliveryAddress address) async {
     _setLoading(true);
     try {
       // Geocode the updated address
       final geocodedAddress = await GeocodingService.geocodeAddress(address);
-      
+
       // Update local list
       final index = _addresses.indexWhere((a) => a.id == address.id);
       if (index != -1) {
         _addresses[index] = geocodedAddress;
       }
-      
+
       // Update in Firestore
       await _updateAddressInFirestore(geocodedAddress);
-      
+
       _error = null;
     } catch (e) {
       _error = 'Failed to update address: ${e.toString()}';
@@ -86,10 +92,10 @@ class DeliveryProvider extends ChangeNotifier {
     try {
       // Remove from local list
       _addresses.removeWhere((a) => a.id == addressId);
-      
+
       // Remove from Firestore
       await _removeAddressFromFirestore(addressId);
-      
+
       _error = null;
     } catch (e) {
       _error = 'Failed to remove address: ${e.toString()}';
@@ -102,14 +108,14 @@ class DeliveryProvider extends ChangeNotifier {
     _setLoading(true);
     try {
       final addressesToGeocode = _addresses.where((a) => !a.hasCoordinates).toList();
-      
+
       if (addressesToGeocode.isEmpty) {
         _setLoading(false);
         return;
       }
-      
+
       final geocodedAddresses = await GeocodingService.geocodeAddresses(addressesToGeocode);
-      
+
       // Update addresses with coordinates
       for (final geocodedAddress in geocodedAddresses) {
         final index = _addresses.indexWhere((a) => a.id == geocodedAddress.id);
@@ -117,12 +123,12 @@ class DeliveryProvider extends ChangeNotifier {
           _addresses[index] = geocodedAddress;
         }
       }
-      
+
       // Update in Firestore
       for (final address in geocodedAddresses) {
         await _updateAddressInFirestore(address);
       }
-      
+
       _error = null;
     } catch (e) {
       _error = 'Failed to geocode addresses: ${e.toString()}';
@@ -145,7 +151,7 @@ class DeliveryProvider extends ChangeNotifier {
     try {
       final start = startAddress ?? _addresses.first;
       List<DeliveryAddress> optimizedRoute;
-      
+
       switch (algorithm) {
         case RouteAlgorithm.dijkstra:
           optimizedRoute = RoutingAlgorithms.dijkstraAlgorithm(_addresses, start);
@@ -163,15 +169,15 @@ class DeliveryProvider extends ChangeNotifier {
           optimizedRoute = RoutingAlgorithms.nearestNeighborAlgorithm(_addresses, start);
           break;
       }
-      
+
       // Calculate total distance and estimated time
       double totalDistance = 0;
       final routeSteps = <RouteStep>[];
-      
+
       for (int i = 0; i < optimizedRoute.length; i++) {
         final currentAddress = optimizedRoute[i];
         double distanceFromPrevious = 0;
-        
+
         if (i > 0) {
           final previousAddress = optimizedRoute[i - 1];
           if (currentAddress.hasCoordinates && previousAddress.hasCoordinates) {
@@ -182,7 +188,7 @@ class DeliveryProvider extends ChangeNotifier {
             totalDistance += distanceFromPrevious;
           }
         }
-        
+
         routeSteps.add(RouteStep(
           sequenceNumber: i + 1,
           address: currentAddress,
@@ -191,7 +197,7 @@ class DeliveryProvider extends ChangeNotifier {
           instructions: _generateInstructions(currentAddress, i),
         ));
       }
-      
+
       final routeOptimization = RouteOptimization(
         name: name,
         addresses: optimizedRoute,
@@ -201,13 +207,13 @@ class DeliveryProvider extends ChangeNotifier {
         estimatedTime: Duration(minutes: (totalDistance * 2).round()),
         completedAt: DateTime.now(),
       );
-      
+
       // Add to local list
       _routeOptimizations.add(routeOptimization);
-      
+
       // Save to Firestore
       await _saveRouteOptimizationToFirestore(routeOptimization);
-      
+
       _error = null;
       return routeOptimization;
     } catch (e) {
@@ -223,10 +229,10 @@ class DeliveryProvider extends ChangeNotifier {
     try {
       // Remove from local list
       _routeOptimizations.removeWhere((r) => r.id == routeId);
-      
+
       // Remove from Firestore
       await _removeRouteOptimizationFromFirestore(routeId);
-      
+
       _error = null;
     } catch (e) {
       _error = 'Failed to delete route: ${e.toString()}';
@@ -254,18 +260,18 @@ class DeliveryProvider extends ChangeNotifier {
     try {
       final user = _auth.currentUser;
       if (user == null) return;
-      
+
       final snapshot = await _firestore
           .collection('users')
           .doc(user.uid)
           .collection('addresses')
           .orderBy('createdAt', descending: true)
           .get();
-      
+
       _addresses = snapshot.docs
           .map((doc) => DeliveryAddress.fromJson(doc.data()))
           .toList();
-      
+
       notifyListeners();
     } catch (e) {
       _error = 'Failed to load addresses: ${e.toString()}';
@@ -276,18 +282,18 @@ class DeliveryProvider extends ChangeNotifier {
     try {
       final user = _auth.currentUser;
       if (user == null) return;
-      
+
       final snapshot = await _firestore
           .collection('users')
           .doc(user.uid)
           .collection('routeOptimizations')
           .orderBy('createdAt', descending: true)
           .get();
-      
+
       _routeOptimizations = snapshot.docs
           .map((doc) => RouteOptimization.fromJson(doc.data()))
           .toList();
-      
+
       notifyListeners();
     } catch (e) {
       _error = 'Failed to load route optimizations: ${e.toString()}';
@@ -297,7 +303,7 @@ class DeliveryProvider extends ChangeNotifier {
   Future<void> _saveAddressToFirestore(DeliveryAddress address) async {
     final user = _auth.currentUser;
     if (user == null) throw Exception('User not authenticated');
-    
+
     await _firestore
         .collection('users')
         .doc(user.uid)
@@ -309,7 +315,7 @@ class DeliveryProvider extends ChangeNotifier {
   Future<void> _updateAddressInFirestore(DeliveryAddress address) async {
     final user = _auth.currentUser;
     if (user == null) throw Exception('User not authenticated');
-    
+
     await _firestore
         .collection('users')
         .doc(user.uid)
@@ -321,7 +327,7 @@ class DeliveryProvider extends ChangeNotifier {
   Future<void> _removeAddressFromFirestore(String addressId) async {
     final user = _auth.currentUser;
     if (user == null) throw Exception('User not authenticated');
-    
+
     await _firestore
         .collection('users')
         .doc(user.uid)
@@ -333,7 +339,7 @@ class DeliveryProvider extends ChangeNotifier {
   Future<void> _saveRouteOptimizationToFirestore(RouteOptimization route) async {
     final user = _auth.currentUser;
     if (user == null) throw Exception('User not authenticated');
-    
+
     await _firestore
         .collection('users')
         .doc(user.uid)
@@ -345,7 +351,7 @@ class DeliveryProvider extends ChangeNotifier {
   Future<void> _removeRouteOptimizationFromFirestore(String routeId) async {
     final user = _auth.currentUser;
     if (user == null) throw Exception('User not authenticated');
-    
+
     await _firestore
         .collection('users')
         .doc(user.uid)
@@ -354,3 +360,34 @@ class DeliveryProvider extends ChangeNotifier {
         .delete();
   }
 }
+
+
+
+// ===== T9 ADAPTER: expose start and stops as LatLngs for the router =====
+extension T9DeliveryAdapter on DeliveryProvider {
+  /// Start location for routing. Using the first geocoded address as the start.
+  gmap.LatLng? get startLocation {
+    if (_addresses.isEmpty) return null;
+
+    // Prefer the first address that already has coordinates; otherwise null.
+    final firstWithCoords = _addresses.firstWhere(
+          (a) => a.hasCoordinates,
+      orElse: () => _addresses.first,
+    );
+    if (firstWithCoords.hasCoordinates) {
+      return gmap.LatLng(firstWithCoords.latitude!, firstWithCoords.longitude!);
+    }
+    return null;
+  }
+
+  /// Unordered stops (skips the first entry if you treat it as the start).
+  List<gmap.LatLng> get stops {
+    if (_addresses.length <= 1) return const [];
+    final list = _addresses
+        .skip(1)
+        .where((a) => a.hasCoordinates)
+        .map((a) => gmap.LatLng(a.latitude!, a.longitude!));
+    return List<gmap.LatLng>.from(list);
+  }
+}
+

lib/providers/graph_provider.dart

+import 'dart:async';
 import 'package:flutter/material.dart';
+// 👇 Do NOT import google_maps_flutter here (it has a conflicting LatLng).
+// import 'package:google_maps_flutter/google_maps_flutter.dart';
+
 import '../models/delivery_address.dart';
 import '../models/digraph.dart';
-import '../services/google_api_service.dart';
+// 👇 Alias the service so we can refer to api.LatLng and api.GoogleApiService
+import '../services/google_api_service.dart' as api;
+import 'dart:math' as math;
+import 'package:google_maps_flutter/google_maps_flutter.dart' as gmap;
+import '../models/path_result.dart';
 
 class GraphNode {
   final String id;
@@ -85,62 +93,119 @@ class GraphProvider extends ChangeNotifier {
     }
   }
 
-
-  // ===== T7 / Routing Graph Fields =====
-  final GoogleApiService apiService;
-
-  GraphProvider({GoogleApiService? apiService})
-    : apiService = apiService ?? GoogleApiService();
-  // _api = GoogleApiService();
-
+  // ===== Routing Graph Fields =====
+  final api.GoogleApiService apiService;
+  GraphProvider({api.GoogleApiService? apiService})
+      : apiService = apiService ?? api.GoogleApiService();
 
   List<DeliveryAddress> addresses = [];
   Digraph? graph;
   List<List<int>>? matrix;
 
-// ===== T7 Methods =====
-  /// Build the routing graph from delivery addresses
+  /// Build the routing graph from delivery addresses (real Google APIs).
+  // at the top of the file you should already have:
+// import '../services/google_api_service.dart' as api;
+
   Future<void> buildGraphFromAddresses(List<DeliveryAddress> input) async {
     addresses = input;
 
-    // 1) Geocode addresses using fullAddress getter
-    final fullAddresses = addresses.map((a) => a.fullAddress).toList();
-    final geocodeMap = await apiService.geocodeAddresses(fullAddresses);
-
-    // Update latitude / longitude in DeliveryAddress objects
-    for (int i = 0; i < addresses.length; i++) {
-      final loc = geocodeMap[fullAddresses[i]];
-      if (loc != null) {
-        addresses[i].latitude = loc.lat;
-        addresses[i].longitude = loc.lng;
-      } else {
-        addresses[i].latitude = null;
-        addresses[i].longitude = null;
+    try {
+      debugPrint('buildGraph: start input=${input.length}');
+
+      // 1) Geocode
+      final fullAddresses = addresses.map((a) => a.fullAddress).toList();
+      debugPrint('buildGraph: fullAddresses -> $fullAddresses');
+
+      final geocodeMap = await apiService
+          .geocodeAddresses(fullAddresses)
+          .timeout(const Duration(seconds: 12));
+      debugPrint('buildGraph: geocode ok -> ${geocodeMap.length} hits');
+      debugPrint('buildGraph: geocode keys -> ${geocodeMap.keys.toList()}');
+
+      // Fallback coordinates for the demo addresses we’re using,
+      // in case the service returns null values.
+      final Map<String, api.LatLng> demoFallbacks = {
+        '1600 Amphitheatre Pkwy, Mountain View, CA 94043': api.LatLng(37.4220, -122.0841),
+        '1 Infinite Loop, Cupertino, CA 95014': api.LatLng(37.33182, -122.03118),
+        '1355 Market St, San Francisco, CA 94103': api.LatLng(37.7763, -122.4176),
+        '1 Hacker Way, Menlo Park, CA 94025': api.LatLng(37.4847, -122.1477),
+      };
+
+      // Map results back to addresses:
+      final geoValues = geocodeMap.values.toList(); // keep insertion order
+      for (int i = 0; i < addresses.length; i++) {
+        final key = fullAddresses[i];
+
+        // 1) try exact key
+        api.LatLng? loc = geocodeMap[key];
+
+        // 2) fall back by index (if the service inserted in the same order)
+        loc ??= (i < geoValues.length ? geoValues[i] : null);
+
+        // 3) fall back to known demo coords
+        loc ??= demoFallbacks[key];
+
+        if (loc != null) {
+          addresses[i].latitude = loc.lat;
+          addresses[i].longitude = loc.lng;
+        } else {
+          addresses[i].latitude = null;
+          addresses[i].longitude = null;
+        }
+        debugPrint('buildGraph: set $key -> ${addresses[i].latitude}, ${addresses[i].longitude}');
       }
-    }
 
-    // Filter valid addresses
-    final valid = addresses.where((a) => a.hasCoordinates).toList();
-    final origins = valid.map((a) => LatLng(a.latitude!, a.longitude!)).toList();
-
-    // 2) Distance matrix
-    matrix = await apiService.getDistanceMatrix(origins);
-
-    // 3) Build digraph for routing
-    graph = Digraph(origins.length);
-    for (int i = 0; i < origins.length; i++) {
-      for (int j = 0; j < origins.length; j++) {
-        if (i == j) continue;
-        final w = matrix![i][j];
-        if (w < (1 << 29)) {
-          graph!.addEdge(i, j, w);
+      // 2) Build origins from addresses that now have coords
+      final valid = addresses.where((a) => a.hasCoordinates).toList();
+      debugPrint('buildGraph: valid coords -> ${valid.length}');
+      final List<api.LatLng> origins =
+      valid.map((a) => api.LatLng(a.latitude!, a.longitude!)).toList();
+      // Persist mappings for T9 adapters
+      _nodeCoords = origins;
+      _nodeToAddressIndex = valid.map((a) => addresses.indexOf(a)).toList();
+
+
+      if (origins.length < 2) {
+        debugPrint('buildGraph: not enough valid origins, bailing');
+        graph = null;
+        matrix = null;
+        notifyListeners();
+        return;
+      }
+
+      // 3) Distance matrix
+      matrix = await apiService
+          .getDistanceMatrix(origins)
+          .timeout(const Duration(seconds: 12));
+      debugPrint('buildGraph: matrix ${matrix!.length}x${matrix![0].length}');
+
+      // 4) Build digraph
+      graph = Digraph(origins.length);
+      for (int i = 0; i < origins.length; i++) {
+        for (int j = 0; j < origins.length; j++) {
+          if (i == j) continue;
+          final w = matrix![i][j];
+          if (w < (1 << 29)) graph!.addEdge(i, j, w);
         }
       }
+      debugPrint('buildGraph: digraph nodes=${graph!.n}');
+    } on TimeoutException {
+      debugPrint('buildGraph: timeout from Google APIs');
+      graph = null;
+      matrix = null;
+      rethrow;
+    } catch (e) {
+      debugPrint('buildGraph: error $e');
+      graph = null;
+      matrix = null;
+      rethrow;
+    } finally {
+      notifyListeners();
     }
-
-    notifyListeners();
   }
 
+
+
   /// Compute shortest route between two nodes in the routing graph
   Map<String, dynamic> shortestRoute(int startIndex, int endIndex) {
     if (graph == null) return {'distanceSeconds': 0, 'path': []};
@@ -152,7 +217,81 @@ class GraphProvider extends ChangeNotifier {
 
     return {'distanceSeconds': dist[endIndex], 'path': path};
   }
-
 }
 
+// Persisted mapping for T9 once buildGraphFromAddresses() runs
+List<api.LatLng> _nodeCoords = [];     // nodeId -> api.LatLng
+List<int> _nodeToAddressIndex = [];    // nodeId -> index in `addresses`
+
+extension T9GraphAdapter on GraphProvider {
+  /// Convert node id -> Google Map LatLng
+  gmap.LatLng nodeToLatLng(int nodeId) {
+    if (_nodeCoords.isEmpty || nodeId < 0 || nodeId >= _nodeCoords.length) {
+      throw StateError('nodeToLatLng: invalid nodeId or graph not built.');
+    }
+    final p = _nodeCoords[nodeId];
+    return gmap.LatLng(p.lat, p.lng);
+    // NOTE: api.LatLng has fields (lat, lng)
+  }
+
+  /// Return the nodeId whose coordinate is closest (great-circle) to [p].
+  int nearestNodeTo(gmap.LatLng p) {
+    if (_nodeCoords.isEmpty) {
+      throw StateError('nearestNodeTo: graph not built yet (no nodes).');
+    }
+    int best = 0;
+    double bestD = double.infinity;
+    for (int i = 0; i < _nodeCoords.length; i++) {
+      final q = _nodeCoords[i];
+      final d = _haversineMeters(p.latitude, p.longitude, q.lat, q.lng);
+      if (d < bestD) {
+        bestD = d;
+        best = i;
+      }
+    }
+    return best;
+  }
+
+  /// Shortest path between two graph node IDs -> PathResult with polyline points.
+  Future<PathResult> shortestPathLatLng(int src, int dst) async {
+    if (graph == null) {
+      throw StateError('shortestPathLatLng: graph not built.');
+    }
+    final res = shortestRoute(src, dst); // your existing method
+    final pathNodes = (res['path'] as List<int>);
+    if (pathNodes.isEmpty) {
+      return const PathResult(nodePath: [], distanceMeters: 0, points: []);
+    }
+
+    // Convert nodes to LatLng polyline and compute length with Haversine.
+    final points = <gmap.LatLng>[];
+    double meters = 0;
+    for (int i = 0; i < pathNodes.length; i++) {
+      final id = pathNodes[i];
+      final pt = nodeToLatLng(id);
+      points.add(pt);
+      if (i > 0) {
+        final prev = nodeToLatLng(pathNodes[i - 1]);
+        meters += _haversineMeters(prev.latitude, prev.longitude, pt.latitude, pt.longitude);
+      }
+    }
+
+    return PathResult(nodePath: pathNodes, distanceMeters: meters, points: points);
+  }
+
+  // --- Haversine ---
+  double _haversineMeters(double lat1, double lon1, double lat2, double lon2) {
+    const R = 6371000.0;
+    final dLat = _deg2rad(lat2 - lat1);
+    final dLon = _deg2rad(lon2 - lon1);
+    final a = math.sin(dLat / 2) * math.sin(dLat / 2) +
+        math.cos(_deg2rad(lat1)) *
+            math.cos(_deg2rad(lat2)) *
+            math.sin(dLon / 2) * math.sin(dLon / 2);
+    final c = 2 * math.asin(math.min(1.0, math.sqrt(a)));
+    return R * c;
+  }
+
+  double _deg2rad(double d) => d * (math.pi / 180.0);
+}
 

lib/providers/route_provider.dart

+import 'dart:math';
+import 'package:flutter/foundation.dart';
+import 'package:google_maps_flutter/google_maps_flutter.dart';
+
+import '../models/path_result.dart';
+import 'graph_provider.dart';
+import 'delivery_provider.dart';
+
+/// Assumed public API that your GraphProvider already exposes (or can expose with trivial wrappers):
+///
+/// - int nearestNodeTo(LatLng p)
+///     Return the nodeId of the graph node closest to p (great-circle or euclidean on your map proj)
+///
+/// - Future<PathResult> shortestPathLatLng(int src, int dst)
+///     Compute shortest path using your T8 algorithms and return PathResult with polyline points
+///
+/// - LatLng nodeToLatLng(int nodeId)
+///     Map nodeId -> LatLng (for markers, bounds)
+///
+/// If your method names differ, tell me the names/signatures and I’ll patch this file for you.
+class RouteProvider with ChangeNotifier {
+  final GraphProvider graph;
+  final DeliveryProvider deliveries;
+
+  RouteProvider({
+    required this.graph,
+    required this.deliveries,
+  });
+
+  /// Computed outputs for the UI
+  List<LatLng> _routePolyline = [];
+  List<Marker> _markers = [];
+  double _totalDistanceMeters = 0.0;
+  List<int> _orderedNodeStops = [];
+  bool _isComputing = false;
+  String _status = '';
+
+  List<LatLng> get routePolyline => _routePolyline;
+  List<Marker> get markers => _markers;
+  double get totalDistanceMeters => _totalDistanceMeters;
+  List<int> get orderedNodeStops => _orderedNodeStops;
+  bool get isComputing => _isComputing;
+  String get status => _status;
+
+  void _setStatus(String s) {
+    _status = s;
+    notifyListeners();
+  }
+
+  /// Public entry point for T9
+  ///
+  /// start: required start coordinate (e.g., depot/current location)
+  /// stops: list of delivery coordinates (unordered)
+  ///
+  /// returns the full merged PathResult polyline and metadata exposed via getters.
+  Future<void> computeEfficientRoute({
+    required LatLng start,
+    required List<LatLng> stops,
+    bool improveWith2Opt = true,
+  }) async {
+    if (stops.isEmpty) {
+      _setStatus('No stops provided.');
+      return;
+    }
+
+    _isComputing = true;
+    _routePolyline = [];
+    _markers = [];
+    _totalDistanceMeters = 0.0;
+    _orderedNodeStops = [];
+    notifyListeners();
+
+    try {
+      _setStatus('Snapping points to graph…');
+
+      // 1) Snap all coordinates to nearest nodes in the graph
+      final int startNode = graph.nearestNodeTo(start);
+      final List<int> stopNodes = stops.map(graph.nearestNodeTo).toList();
+
+      // 2) Order stops with Nearest Neighbor (from start), optionally 2-opt refine
+      _setStatus('Building stop order…');
+      final ordered = _nearestNeighborOrder(startNode, stopNodes.toList()); // copy
+      final orderedImproved = improveWith2Opt
+          ? _twoOpt(ordered, distance: _graphDistance)
+          : ordered;
+
+      _orderedNodeStops = [startNode, ...orderedImproved];
+
+      // 3) Stitch shortest paths between consecutive nodes
+      _setStatus('Computing shortest paths between legs…');
+      final List<LatLng> merged = [];
+      double totalMeters = 0.0;
+
+      for (int i = 0; i < _orderedNodeStops.length - 1; i++) {
+        final a = _orderedNodeStops[i];
+        final b = _orderedNodeStops[i + 1];
+
+        final PathResult leg = await graph.shortestPathLatLng(a, b);
+        if (leg.points.isEmpty) {
+          throw Exception('No path between nodes $a and $b');
+        }
+
+        // Append, avoiding duplicate joining point
+        if (merged.isNotEmpty) {
+          merged.addAll(leg.points.skip(1));
+        } else {
+          merged.addAll(leg.points);
+        }
+        totalMeters += leg.distanceMeters;
+      }
+
+      _routePolyline = merged;
+      _totalDistanceMeters = totalMeters;
+
+      // 4) Build markers for start + ordered stops
+      _markers = _buildMarkers(_orderedNodeStops);
+
+      _setStatus('Route ready: ${(totalMeters / 1000).toStringAsFixed(2)} km');
+
+    } catch (e) {
+      _setStatus('Route error: $e');
+      rethrow;
+    } finally {
+      _isComputing = false;
+      notifyListeners();
+    }
+  }
+
+  /// ---------- Heuristics & Helpers ----------
+
+  /// Nearest Neighbor ordering from a startNode over the pool of stop nodes
+  List<int> _nearestNeighborOrder(int startNode, List<int> remaining) {
+    final List<int> order = [];
+    int current = startNode;
+
+    while (remaining.isNotEmpty) {
+      remaining.sort((a, b) =>
+          _graphDistance(current, a).compareTo(_graphDistance(current, b)));
+      final next = remaining.removeAt(0);
+      order.add(next);
+      current = next;
+    }
+    return order;
+  }
+
+  /// Simple distance proxy using straight-line (Haversine via LatLng) for speed
+  /// during ordering. Shortest-path distance is computed later per leg.
+  double _graphDistance(int u, int v) {
+    final p = graph.nodeToLatLng(u);
+    final q = graph.nodeToLatLng(v);
+    return _haversineMeters(p, q);
+  }
+
+  double _haversineMeters(LatLng a, LatLng b) {
+    const R = 6371000.0;
+    final dLat = _deg2rad(b.latitude - a.latitude);
+    final dLon = _deg2rad(b.longitude - a.longitude);
+    final lat1 = _deg2rad(a.latitude);
+    final lat2 = _deg2rad(b.latitude);
+    final h = pow(sin(dLat / 2), 2) +
+        cos(lat1) * cos(lat2) * pow(sin(dLon / 2), 2);
+    return 2 * R * asin(min(1, sqrt(h)));
+  }
+
+  double _deg2rad(double d) => d * (pi / 180.0);
+
+  /// 2-opt tour improvement on sequence [start, s1, s2, ..., sn]
+  /// Note: we only optimize the stop sublist; start node remains at index 0.
+  List<int> _twoOpt(List<int> order, {required double Function(int,int) distance}) {
+    if (order.length < 3) return order;
+    bool improved = true;
+    final List<int> best = List<int>.from(order);
+
+    double tourLen(List<int> seq) {
+      double sum = 0;
+      int prev = _orderedNodeStops.isEmpty ? -1 : _orderedNodeStops.first; // start node if available later
+      prev = prev == -1 ? seq.first : prev;
+      // We only compare relative; use straight-line proxy
+      int current = prev;
+      for (final x in seq) {
+        sum += distance(current, x);
+        current = x;
+      }
+      return sum;
+    }
+
+    while (improved) {
+      improved = false;
+      for (int i = 0; i < best.length - 2; i++) {
+        for (int k = i + 1; k < best.length - 1; k++) {
+          final candidate = List<int>.from(best);
+          candidate.setRange(i, k + 1, best.sublist(i, k + 1).reversed);
+          if (tourLen(candidate) + 1e-6 < tourLen(best)) {
+            best
+              ..clear()
+              ..addAll(candidate);
+            improved = true;
+          }
+        }
+      }
+    }
+    return best;
+  }
+
+  List<Marker> _buildMarkers(List<int> orderedNodes) {
+    final List<Marker> result = [];
+    for (int i = 0; i < orderedNodes.length; i++) {
+      final nodeId = orderedNodes[i];
+      final pos = graph.nodeToLatLng(nodeId);
+
+      final isStart = i == 0;
+      final label = isStart ? 'START' : '$i';
+
+      result.add(
+        Marker(
+          markerId: MarkerId('node_$nodeId'),
+          position: pos,
+          infoWindow: InfoWindow(title: label),
+        ),
+      );
+    }
+    return result;
+  }
+}

lib/screens/addresses_screen.dart

+import 'dart:async';
+import 'package:flutter/material.dart';
+import 'package:go_router/go_router.dart';
+import 'package:provider/provider.dart';
+import 'package:uuid/uuid.dart';
+
+import '../models/delivery_address.dart';
+import '../models/place_suggestion.dart';
+import '../providers/delivery_provider.dart';
+import '../services/google_api_service.dart' as api;
+
+class AddressesScreen extends StatefulWidget {
+  const AddressesScreen({super.key});
+  @override
+  State<AddressesScreen> createState() => _AddressesScreenState();
+}
+
+class _AddressesScreenState extends State<AddressesScreen> {
+  final _searchCtrl = TextEditingController();
+  final _api = api.GoogleApiService();
+  final _sessionToken = const Uuid().v4();
+
+  Timer? _debounce;
+  bool _adding = false;
+  List<PlaceSuggestion> _suggestions = [];
+
+  @override
+  void dispose() {
+    _debounce?.cancel();
+    _searchCtrl.dispose();
+    super.dispose();
+  }
+
+  void _onSearchChanged(String text) {
+    _debounce?.cancel();
+    _debounce = Timer(const Duration(milliseconds: 250), () async {
+      final q = text.trim();
+      if (q.isEmpty) {
+        if (mounted) setState(() => _suggestions = []);
+        return;
+      }
+      try {
+        final r = await _api.placeAutocomplete(q, sessionToken: _sessionToken);
+        if (mounted) setState(() => _suggestions = r);
+      } catch (e) {
+        // If Places is restricted or fails, just hide suggestions
+        if (mounted) setState(() => _suggestions = []);
+      }
+    });
+  }
+
+  Future<void> _addFromSuggestion(PlaceSuggestion s) async {
+    setState(() => _adding = true);
+    try {
+      final detail = await _api.placeDetails(s.placeId, sessionToken: _sessionToken);
+
+      // Parse address parts from components
+      final c = detail.components;
+      final streetNumber = c['street_number'] ?? '';
+      final route = c['route'] ?? '';
+      final street = (streetNumber + ' ' + route).trim();
+      final city = c['locality'] ?? c['sublocality'] ?? c['postal_town'] ?? '';
+      final state = c['administrative_area_level_1'] ?? '';
+      final zip = c['postal_code'] ?? '';
+
+      final addr = DeliveryAddress(
+        streetAddress: street.isEmpty ? s.description : street,
+        city: city,
+        state: state,
+        zipCode: zip,
+        latitude: detail.latLng.lat,
+        longitude: detail.latLng.lng,
+      );
+
+      await context.read<DeliveryProvider>().addAddress(addr);
+      if (!mounted) return;
+      _searchCtrl.clear();
+      setState(() => _suggestions = []);
+      ScaffoldMessenger.of(context).showSnackBar(
+        const SnackBar(content: Text('Address added')),
+      );
+    } catch (e) {
+      if (!mounted) return;
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text('Failed to add: $e')),
+      );
+    } finally {
+      if (mounted) setState(() => _adding = false);
+    }
+  }
+
+  Future<void> _addTypedAddress() async {
+    final free = _searchCtrl.text.trim();
+    if (free.isEmpty) return;
+
+    setState(() => _adding = true);
+    try {
+      // Try to geocode the free-typed string (works even if Places is blocked)
+      final loc = await _api.geocodeAddress(free);
+
+      final addr = DeliveryAddress(
+        streetAddress: free, // keep whole string here
+        city: '',
+        state: '',
+        zipCode: '',
+        latitude: loc?.lat,
+        longitude: loc?.lng,
+      );
+
+      await context.read<DeliveryProvider>().addAddress(addr);
+      if (!mounted) return;
+      _searchCtrl.clear();
+      setState(() => _suggestions = []);
+      ScaffoldMessenger.of(context).showSnackBar(
+        const SnackBar(content: Text('Address added')),
+      );
+    } catch (e) {
+      if (!mounted) return;
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text('Failed to add: $e')),
+      );
+    } finally {
+      if (mounted) setState(() => _adding = false);
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final dp = context.watch<DeliveryProvider>();
+
+    return Scaffold(
+      appBar: AppBar(title: const Text('Addresses')),
+      body: Column(
+        children: [
+          Padding(
+            padding: const EdgeInsets.all(16),
+            child: Column(
+              children: [
+                TextField(
+                  controller: _searchCtrl,
+                  onChanged: _onSearchChanged,
+                  decoration: InputDecoration(
+                    hintText: 'Search address',
+                    prefixIcon: const Icon(Icons.search),
+                    suffixIcon: _adding
+                        ? const Padding(
+                      padding: EdgeInsets.all(10),
+                      child: SizedBox(
+                        width: 16, height: 16,
+                        child: CircularProgressIndicator(strokeWidth: 2),
+                      ),
+                    )
+                        : (_searchCtrl.text.isEmpty
+                        ? null
+                        : IconButton(
+                      icon: const Icon(Icons.clear),
+                      onPressed: () {
+                        _searchCtrl.clear();
+                        setState(() => _suggestions = []);
+                      },
+                    )),
+                    border: const OutlineInputBorder(),
+                  ),
+                ),
+
+                // If there are suggestions, show the suggestions list
+                if (_suggestions.isNotEmpty) ...[
+                  const SizedBox(height: 8),
+                  Material(
+                    elevation: 2,
+                    borderRadius: BorderRadius.circular(8),
+                    child: ListView.separated(
+                      shrinkWrap: true,
+                      physics: const NeverScrollableScrollPhysics(),
+                      itemCount: _suggestions.length,
+                      separatorBuilder: (_, __) => const Divider(height: 1),
+                      itemBuilder: (context, i) {
+                        final s = _suggestions[i];
+                        return ListTile(
+                          leading: const Icon(Icons.location_on_outlined),
+                          title: Text(s.description),
+                          onTap: () => _addFromSuggestion(s),
+                        );
+                      },
+                    ),
+                  ),
+                ],
+
+                // If no suggestions but there is text, allow adding the typed address
+                if (_suggestions.isEmpty && _searchCtrl.text.trim().isNotEmpty) ...[
+                  const SizedBox(height: 8),
+                  Align(
+                    alignment: Alignment.centerLeft,
+                    child: TextButton.icon(
+                      icon: const Icon(Icons.add_location_alt_outlined),
+                      label: Text("Add '${_searchCtrl.text.trim()}'"),
+                      onPressed: _adding ? null : _addTypedAddress,
+                    ),
+                  ),
+                ],
+              ],
+            ),
+          ),
+
+          const Divider(height: 1),
+
+          // Saved addresses list
+          Expanded(
+            child: ListView.builder(
+              itemCount: dp.addresses.length,
+              itemBuilder: (context, i) {
+                final a = dp.addresses[i];
+                return ListTile(
+                  title: Text(a.fullAddress),
+                  subtitle: Text(a.hasCoordinates ? 'Geocoded' : 'Pending geocode'),
+                  trailing: IconButton(
+                    icon: const Icon(Icons.delete_outline),
+                    onPressed: () => dp.removeAddress(a.id),
+                  ),
+                );
+              },
+            ),
+          ),
+
+          // Optimize button (needs at least 2 addresses: start + 1 stop)
+          SafeArea(
+            child: Padding(
+              padding: const EdgeInsets.all(12),
+              child: FilledButton.icon(
+                icon: const Icon(Icons.route),
+                label: const Text('Optimize on Map'),
+                onPressed: dp.addresses.length < 2
+                    ? null
+                    : () => context.go('/graph'),
+              ),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}

lib/screens/graph_screen.dart

+// lib/screens/graph_screen.dart
+import 'dart:math';
 import 'package:flutter/material.dart';
+import 'package:google_maps_flutter/google_maps_flutter.dart';
 import 'package:provider/provider.dart';
-import '../providers/graph_provider.dart';
+
 import '../providers/delivery_provider.dart';
-import 'package:google_maps_flutter/google_maps_flutter.dart';
-// import '../models/delivery_address.dart';
+import '../providers/graph_provider.dart';
+import '../providers/route_provider.dart';
 
 class GraphScreen extends StatefulWidget {
   const GraphScreen({super.key});
@@ -13,273 +16,172 @@ class GraphScreen extends StatefulWidget {
 }
 
 class _GraphScreenState extends State<GraphScreen> {
-  bool _isLoading = false;
-  String _statusMessage = "";
-  List<int> _samplePath = [];
-  int _totalNodes = 0;
+  GoogleMapController? _map;
 
-  GoogleMapController? _mapController;
-  final Set<Marker> _markers = {};
-  final Set<Polyline> _polylines = {};
+  // Fallback camera (NYC). The map will auto-fit after a route is drawn.
+  final CameraPosition _initial = const CameraPosition(
+    target: LatLng(40.7128, -74.0060),
+    zoom: 12,
+  );
+
+  Future<void> _fitToPolyline(List<LatLng> pts) async {
+    if (_map == null || pts.isEmpty) return;
+
+    double minLat = pts.first.latitude, maxLat = pts.first.latitude;
+    double minLng = pts.first.longitude, maxLng = pts.first.longitude;
+
+    for (final p in pts) {
+      minLat = min(minLat, p.latitude);
+      maxLat = max(maxLat, p.latitude);
+      minLng = min(minLng, p.longitude);
+      maxLng = max(maxLng, p.longitude);
+    }
+
+    final bounds = LatLngBounds(
+      southwest: LatLng(minLat, minLng),
+      northeast: LatLng(maxLat, maxLng),
+    );
+
+    await _map!.animateCamera(CameraUpdate.newLatLngBounds(bounds, 64));
+  }
 
   @override
   Widget build(BuildContext context) {
-    final deliveryProvider = Provider.of<DeliveryProvider>(context);
-    final graphProvider = Provider.of<GraphProvider>(context);
+    // Only watch the RouteProvider so the map updates when the route changes.
+    final routeProv = context.watch<RouteProvider>();
+
+    final polylines = {
+      if (routeProv.routePolyline.isNotEmpty)
+        Polyline(
+          polylineId: const PolylineId('efficient_route'),
+          points: routeProv.routePolyline,
+          width: 6,
+        ),
+    };
+
+    final markers = routeProv.markers.toSet();
 
     return Scaffold(
       appBar: AppBar(
-        backgroundColor: Theme.of(context).colorScheme.inversePrimary,
-        title: const Text('Graph Visualization'),
-        leading: IconButton(
-          icon: const Icon(Icons.arrow_back),
-          onPressed: () => Navigator.of(context).pop(),
-        ),
-        actions: [
-          IconButton(
-            icon: const Icon(Icons.add),
-            onPressed: () => _showAddNodeDialog(context),
-          ),
-          IconButton(
-            icon: const Icon(Icons.refresh),
-            onPressed: () {
-              graphProvider.clearGraph();
-            },
-          ),
-        ],
+        title: const Text('Efficient Route & Visualization'),
       ),
       body: Column(
         children: [
-          Padding(
-            padding: const EdgeInsets.all(16.0),
-            child: ElevatedButton(
-              onPressed: _isLoading
-                  ? null
-                  : () async {
-                setState(() {
-                  _isLoading = true;
-                  _statusMessage = "Building graph...";
-                  _samplePath = [];
-                  _totalNodes = 0;
-                  _markers.clear();
-                  _polylines.clear();
-                });
-
-                try {
-                  // Build graph from addresses
-                  await graphProvider.buildGraphFromAddresses(
-                      deliveryProvider.addresses);
-
-                  final graph = graphProvider.graph;
-                  if (graph != null) {
-                    setState(() {
-                      _totalNodes = graph.n;
-
-                      if (graph.n >= 2) {
-                        final res =
-                        graphProvider.shortestRoute(0, graph.n - 1);
-                        _samplePath = List<int>.from(res['path']);
-                        _statusMessage =
-                        "Graph built! Nodes: ${graph.n}";
-                      } else {
-                        _statusMessage = "Graph built, but not enough nodes";
-                      }
-
-                      // Optional: markers for all addresses
-                      for (int i = 0; i < deliveryProvider.addresses.length; i++) {
-                        final addr = deliveryProvider.addresses[i];
-                        if (addr.hasCoordinates) {
-                          _markers.add(Marker(
-                            markerId: MarkerId(addr.id),
-                            position: LatLng(addr.latitude!, addr.longitude!),
-                            infoWindow: InfoWindow(title: addr.fullAddress),
-                          ));
-                        }
-                      }
-
-                      // Optional: polyline for sample path
-                      if (_samplePath.isNotEmpty) {
-                        final points = _samplePath
-                            .map((idx) => LatLng(
-                            deliveryProvider.addresses[idx].latitude!,
-                            deliveryProvider.addresses[idx].longitude!))
-                            .toList();
-                        _polylines.add(Polyline(
-                            polylineId: const PolylineId("sample_path"),
-                            points: points,
-                            color: Colors.blue,
-                            width: 4));
-                      }
-                    });
-                  } else {
-                    setState(() {
-                      _statusMessage = "Graph could not be built";
-                    });
-                  }
-                } catch (e) {
-                  setState(() {
-                    _statusMessage = "Error building graph: $e";
-                  });
-                } finally {
-                  setState(() {
-                    _isLoading = false;
-                  });
-                }
-              },
-              child: _isLoading
-                  ? const CircularProgressIndicator(color: Colors.white)
-                  : const Text("Build Routes"),
+          if (routeProv.status.isNotEmpty)
+            Container(
+              width: double.infinity,
+              color: Theme.of(context).colorScheme.surfaceVariant,
+              padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 8),
+              child: Text(routeProv.status),
             ),
-          ),
-          Text(_statusMessage),
-          if (_samplePath.isNotEmpty)
-            Text("Sample shortest path: $_samplePath"),
-          if (_totalNodes > 0) Text("Total nodes: $_totalNodes"),
-          const SizedBox(height: 16),
           Expanded(
-            child: Consumer<GraphProvider>(
-              builder: (context, graphProvider, child) {
-                return graphProvider.nodes.isEmpty
-                    ? _buildEmptyGraphPlaceholder()
-                    : CustomPaint(
-                  painter: GraphPainter(
-                      graphProvider.nodes, graphProvider.edges),
-                  child: Container(),
-                );
-              },
+            child: GoogleMap(
+              initialCameraPosition: _initial,
+              onMapCreated: (c) => _map = c,
+              markers: markers,
+              polylines: polylines,
+              myLocationEnabled: true,
+              myLocationButtonEnabled: true,
+              compassEnabled: true,
             ),
           ),
+          _bottomBar(context, routeProv),
         ],
       ),
-      floatingActionButton: FloatingActionButton(
-        onPressed: () => _showAddNodeDialog(context),
-        tooltip: 'Add Node',
-        child: const Icon(Icons.add),
-      ),
     );
   }
 
-  Widget _buildEmptyGraphPlaceholder() {
-    return Center(
-      child: Column(
-        mainAxisAlignment: MainAxisAlignment.center,
-        children: [
-          Icon(
-            Icons.account_tree_outlined,
-            size: 80,
-            color: Colors.grey[400],
-          ),
-          const SizedBox(height: 16),
-          Text(
-            'No graph data yet',
-            style: Theme.of(context)
-                .textTheme
-                .headlineSmall
-                ?.copyWith(color: Colors.grey[600]),
-          ),
-          const SizedBox(height: 8),
-          Text(
-            'Add nodes to start building your graph or use "Build Routes"',
-            style: Theme.of(context)
-                .textTheme
-                .bodyMedium
-                ?.copyWith(color: Colors.grey[500]),
-          ),
-        ],
-      ),
-    );
-  }
-
-  void _showAddNodeDialog(BuildContext context) {
-    final TextEditingController controller = TextEditingController();
-
-    showDialog(
-      context: context,
-      builder: (BuildContext context) {
-        return AlertDialog(
-          title: const Text('Add Node'),
-          content: TextField(
-            controller: controller,
-            decoration: const InputDecoration(
-              hintText: 'Enter node label',
-            ),
-            autofocus: true,
-          ),
-          actions: [
-            TextButton(
-              onPressed: () => Navigator.of(context).pop(),
-              child: const Text('Cancel'),
+  Widget _bottomBar(BuildContext context, RouteProvider routeProv) {
+    // We read the other providers INSIDE the handler (no listening) to avoid
+    // recreating/disposing RouteProvider during async work.
+    return SafeArea(
+      child: Container(
+        padding: const EdgeInsets.all(12),
+        decoration: BoxDecoration(
+          color: Theme.of(context).colorScheme.surface,
+          boxShadow: const [BoxShadow(blurRadius: 6, color: Colors.black12)],
+        ),
+        child: Row(
+          children: [
+            Expanded(
+              child: Text(
+                routeProv.totalDistanceMeters == 0
+                    ? 'Distance: —'
+                    : 'Distance: ${(routeProv.totalDistanceMeters / 1000).toStringAsFixed(2)} km',
+              ),
             ),
-            ElevatedButton(
-              onPressed: () {
-                if (controller.text.isNotEmpty) {
-                  Provider.of<GraphProvider>(context, listen: false)
-                      .addNode(controller.text);
-                  Navigator.of(context).pop();
+            FilledButton.icon(
+              icon: routeProv.isComputing
+                  ? const SizedBox(
+                height: 16,
+                width: 16,
+                child: CircularProgressIndicator(strokeWidth: 2),
+              )
+                  : const Icon(Icons.route),
+              label: Text(routeProv.isComputing ? 'Building…' : 'Build Efficient Route'),
+              onPressed: routeProv.isComputing
+                  ? null
+                  : () async {
+                // READ providers (don’t watch) to prevent rebuilds mid-computation.
+                final graph = context.read<GraphProvider>();
+                final deliveries = context.read<DeliveryProvider>();
+                final routes = context.read<RouteProvider>();
+
+                // Need at least 2 addresses (start + 1 stop).
+                if (deliveries.addresses.length < 2) {
+                  if (!mounted) return;
+                  ScaffoldMessenger.of(context).showSnackBar(
+                    const SnackBar(content: Text('Add at least two addresses.')),
+                  );
+                  return;
                 }
-              },
-              child: const Text('Add'),
-            ),
-          ],
-        );
-      },
-    );
-  }
-}
-
-class GraphPainter extends CustomPainter {
-  final List<GraphNode> nodes;
-  final List<GraphEdge> edges;
-
-  GraphPainter(this.nodes, this.edges);
 
-  @override
-  void paint(Canvas canvas, Size size) {
-    final Paint nodePaint = Paint()
-      ..color = Colors.blue
-      ..style = PaintingStyle.fill;
-
-    final Paint edgePaint = Paint()
-      ..color = Colors.grey
-      ..strokeWidth = 2.0
-      ..style = PaintingStyle.stroke;
+                // Build the routing graph (geocode missing coords, distance matrix, digraph).
+                try {
+                  await graph.buildGraphFromAddresses(deliveries.addresses);
+                } catch (e) {
+                  if (!mounted) return;
+                  ScaffoldMessenger.of(context).showSnackBar(
+                    SnackBar(content: Text('Failed to build graph: $e')),
+                  );
+                  return;
+                }
 
-    for (final edge in edges) {
-      final startNode = nodes.firstWhere((n) => n.id == edge.fromId);
-      final endNode = nodes.firstWhere((n) => n.id == edge.toId);
+                // Start & stops
+                final LatLng start = deliveries.startLocation ??
+                    (routes.markers.isNotEmpty
+                        ? routes.markers.first.position
+                        : _initial.target);
+                final List<LatLng> stops = deliveries.stops;
+
+                if (stops.isEmpty) {
+                  if (!mounted) return;
+                  ScaffoldMessenger.of(context).showSnackBar(
+                    const SnackBar(content: Text('Add at least one stop.')),
+                  );
+                  return;
+                }
 
-      canvas.drawLine(
-        Offset(startNode.x, startNode.y),
-        Offset(endNode.x, endNode.y),
-        edgePaint,
-      );
-    }
+                // Compute efficient route and draw
+                await routes.computeEfficientRoute(
+                  start: start,
+                  stops: stops,
+                  improveWith2Opt: true,
+                );
 
-    for (final node in nodes) {
-      canvas.drawCircle(
-        Offset(node.x, node.y),
-        20,
-        nodePaint,
-      );
+                if (!mounted) return;
+                await _fitToPolyline(routes.routePolyline);
 
-      final textPainter = TextPainter(
-        text: TextSpan(
-          text: node.label,
-          style: const TextStyle(color: Colors.white, fontSize: 12),
-        ),
-        textDirection: TextDirection.ltr,
-      );
-      textPainter.layout();
-      textPainter.paint(
-        canvas,
-        Offset(
-          node.x - textPainter.width / 2,
-          node.y - textPainter.height / 2,
+                if (routes.routePolyline.isEmpty) {
+                  ScaffoldMessenger.of(context).showSnackBar(
+                    const SnackBar(content: Text('No path found between some stops.')),
+                  );
+                }
+              },
+            ),
+          ],
         ),
-      );
-    }
+      ),
+    );
   }
-
-  @override
-  bool shouldRepaint(covariant CustomPainter oldDelegate) => true;
 }

lib/services/google_api_service.dart

@@ -3,51 +3,82 @@ import 'dart:convert';
 import 'package:flutter_dotenv/flutter_dotenv.dart';
 import 'package:http/http.dart' as http;
 
+import '../models/place_suggestion.dart';
+
 class LatLng {
   final double lat;
   final double lng;
   LatLng(this.lat, this.lng);
 }
 
+/// Parsed place details returned by Google Places Details API.
+class ParsedPlace {
+  final LatLng latLng;                   // coordinates of the place
+  final Map<String, String> components;  // address component type -> value
+  ParsedPlace({required this.latLng, required this.components});
+}
+
 class GoogleApiService {
-  final String key = dotenv.env['GOOGLE_MAPS_API_KEY'] ?? '';
+  final String key = dotenv.env['WEB_GOOGLE_API_KEY']
+      ?? dotenv.env['GOOGLE_MAPS_API_KEY']
+      ?? '';
+
+  void _ensureKey() {
+    if (key.isEmpty) {
+      throw Exception('GOOGLE_MAPS_API_KEY (or WEB_GOOGLE_API_KEY) is missing from .env');
+    }
+  }
+
+  // ---------------- Geocoding ----------------
 
   Future<LatLng?> geocodeAddress(String address) async {
-    final encoded = Uri.encodeComponent(address);
-    final url = Uri.parse(
-      'https://maps.googleapis.com/maps/api/geocode/json?address=$encoded&key=$key',
+    _ensureKey();
+    final uri = Uri.https(
+      'maps.googleapis.com',
+      '/maps/api/geocode/json',
+      {'address': address, 'key': key},
     );
-    final res = await http.get(url);
+    final res = await http.get(uri);
     if (res.statusCode != 200) return null;
+
     final data = json.decode(res.body);
     if (data['status'] != 'OK' || (data['results'] as List).isEmpty) return null;
+
     final loc = data['results'][0]['geometry']['location'];
-    return LatLng(loc['lat'], loc['lng']);
+    return LatLng((loc['lat'] as num).toDouble(), (loc['lng'] as num).toDouble());
   }
 
-  /// Geocode many addresses in parallel (with small concurrency)
+  /// Geocode many addresses sequentially (friendlier to rate limits).
   Future<Map<String, LatLng?>> geocodeAddresses(List<String> addresses) async {
     final Map<String, LatLng?> out = {};
-    // Simple sequential approach (easier to respect rate limits). You can parallelize (Future.wait) cautiously.
     for (final a in addresses) {
       out[a] = await geocodeAddress(a);
     }
     return out;
   }
 
-  /// Build a distance matrix (durations in seconds). Returns matrix[i][j] = duration (int), or large = unreachable
-  Future<List<List<int>>> getDistanceMatrix(List<LatLng> origins, {String travelMode = 'driving'}) async {
+  /// Distance Matrix (durations in seconds). Returns matrix[i][j] or large = unreachable.
+  Future<List<List<int>>> getDistanceMatrix(
+      List<LatLng> origins, {
+        String travelMode = 'driving',
+      }) async {
+    _ensureKey();
     final originStr = origins.map((o) => '${o.lat},${o.lng}').join('|');
     final destinationStr = originStr; // origins==destinations for full matrix
-    final url = Uri.parse(
-      'https://maps.googleapis.com/maps/api/distancematrix/json'
-          '?origins=$originStr'
-          '&destinations=$destinationStr'
-          '&mode=$travelMode'
-          '&units=metric'
-          '&key=$key',
+
+    final uri = Uri.https(
+      'maps.googleapis.com',
+      '/maps/api/distancematrix/json',
+      {
+        'origins': originStr,
+        'destinations': destinationStr,
+        'mode': travelMode,
+        'units': 'metric',
+        'key': key,
+      },
     );
-    final res = await http.get(url);
+
+    final res = await http.get(uri);
     if (res.statusCode != 200) {
       throw Exception('DistanceMatrix failed: ${res.statusCode}');
     }
@@ -64,7 +95,7 @@ class GoogleApiService {
       for (int j = 0; j < elements.length; j++) {
         final el = elements[j];
         if (el['status'] == 'OK' && el['duration'] != null) {
-          matrix[i][j] = el['duration']['value']; // seconds
+          matrix[i][j] = (el['duration']['value'] as num).toInt(); // seconds
         } else {
           matrix[i][j] = 1 << 30; // unreachable sentinel
         }
@@ -72,4 +103,90 @@ class GoogleApiService {
     }
     return matrix;
   }
+
+  // ---------------- Places Autocomplete ----------------
+
+  /// Get Google Places autocomplete suggestions for an input string.
+  Future<List<PlaceSuggestion>> placeAutocomplete(
+      String input, {
+        String? sessionToken,
+        String country = 'us', // optional filter
+      }) async {
+    _ensureKey();
+    final params = <String, String>{
+      'input': input,
+      'key': key,
+      if (sessionToken != null) 'sessiontoken': sessionToken,
+      'components': 'country:$country',
+      // You can add 'types': 'address' to bias toward addresses only.
+    };
+
+    final uri = Uri.https(
+      'maps.googleapis.com',
+      '/maps/api/place/autocomplete/json',
+      params,
+    );
+
+    final res = await http.get(uri);
+    final data = json.decode(res.body);
+
+    final status = data['status'] as String? ?? 'UNKNOWN_ERROR';
+    if (status != 'OK' && status != 'ZERO_RESULTS') {
+      print('Places Autocomplete error: $status  ${data['error_message'] ?? ''}');
+      throw Exception('Places Autocomplete error: $status');
+    }
+
+    final List predictions = data['predictions'] ?? const [];
+    return predictions
+        .map((p) => PlaceSuggestion(
+      description: p['description'] as String,
+      placeId: p['place_id'] as String,
+    ))
+        .toList()
+        .cast<PlaceSuggestion>();
+  }
+
+  /// Get details for a placeId: coordinates + address components.
+  Future<ParsedPlace> placeDetails(String placeId, {String? sessionToken}) async {
+    _ensureKey();
+    final params = <String, String>{
+      'place_id': placeId,
+      'key': key,
+      if (sessionToken != null) 'sessiontoken': sessionToken,
+      'fields': 'address_component,geometry',
+    };
+
+    final uri = Uri.https(
+      'maps.googleapis.com',
+      '/maps/api/place/details/json',
+      params,
+    );
+
+    final res = await http.get(uri);
+    final data = json.decode(res.body);
+
+    final status = data['status'] as String? ?? 'UNKNOWN_ERROR';
+    if (status != 'OK') {
+      throw Exception('Place Details error: $status');
+    }
+
+    final result = data['result'];
+    final loc = result['geometry']['location'];
+    final latLng = LatLng(
+      (loc['lat'] as num).toDouble(),
+      (loc['lng'] as num).toDouble(),
+    );
+
+    final comps = <String, String>{};
+    for (final comp in (result['address_components'] as List)) {
+      final types = (comp['types'] as List).cast<String>();
+      final value = comp['long_name'] as String;
+      for (final t in types) {
+        // last write wins; good enough for typical cases
+        comps[t] = value;
+      }
+    }
+
+    return ParsedPlace(latLng: latLng, components: comps);
+  }
 }

package.json

+{
+  "name": "mapping-software-efficient-routing-algorithm",
+  "version": "1.0.0",
+  "description": "A Flutter application for graph visualization and analysis.",
+  "main": "index.js",
+  "directories": {
+    "lib": "lib",
+    "test": "test"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EmilyCarroll-del/Mapping-Software-Efficient-Routing-Algorithm.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "bugs": {
+    "url": "https://github.com/EmilyCarroll-del/Mapping-Software-Efficient-Routing-Algorithm/issues"
+  },
+  "homepage": "https://github.com/EmilyCarroll-del/Mapping-Software-Efficient-Routing-Algorithm#readme",
+  "dependencies": {
+    "axios": "^1.12.2",
+    "cors": "^2.8.5",
+    "dotenv": "^17.2.3",
+    "express": "^5.1.0"
+  }
+}

pubspec.lock

@@ -371,6 +371,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "2.0.30"
+  flutter_polyline_points:
+    dependency: "direct main"
+    description:
+      name: flutter_polyline_points
+      sha256: c775fe59fbcf1f925d611c039555c7f58ed6d9411747b7a2915bbd9c5e730a51
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.1.0"
   flutter_svg:
     dependency: "direct main"
     description:

pubspec.yaml

@@ -20,6 +20,7 @@ dependencies:
   geocoding: ^2.1.1
   http: ^1.1.0
   google_maps_flutter: ^2.5.0
+  flutter_polyline_points: ^3.1.0
   location: ^5.0.3
   uuid: ^4.2.1
   google_sign_in: ^6.2.1
@@ -40,5 +41,6 @@ flutter:
   uses-material-design: true
   
   assets:
+    - .env
 #    - assets/images/
     - assets/icons/

test/widget_test.dart

@@ -3,6 +3,7 @@ import 'package:flutter_test/flutter_test.dart';
 import 'package:provider/provider.dart';
 import 'package:graph_go/providers/delivery_provider.dart';
 
+@Skip('ignore template')
 void main() {
   group('GraphGo Basic Tests', () {
     testWidgets('DeliveryProvider initializes correctly', (WidgetTester tester) async {