Add reverse geocoding functionality and enhance driver details retrieval with location information

chat/geocoding.py

@@ -126,6 +126,105 @@ class GeocodingService:
             "confidence": "low (mock - default)"
         }
 
+    def reverse_geocode(self, lat: float, lng: float) -> Dict:
+        """
+        Reverse geocode coordinates to address
+
+        Args:
+            lat: Latitude
+            lng: Longitude
+
+        Returns:
+            Dict with keys: address, city, state, country, formatted_address
+        """
+        if self.use_mock:
+            return self._reverse_geocode_mock(lat, lng)
+        else:
+            try:
+                return self._reverse_geocode_google(lat, lng)
+            except Exception as e:
+                logger.error(f"Google Maps reverse geocoding failed: {e}, falling back to mock")
+                return self._reverse_geocode_mock(lat, lng)
+
+    def _reverse_geocode_google(self, lat: float, lng: float) -> Dict:
+        """Real Google Maps API reverse geocoding"""
+        try:
+            # Call Google Maps Reverse Geocoding API
+            result = self.gmaps_client.reverse_geocode((lat, lng))
+
+            if not result:
+                logger.warning(f"Google Maps API found no results for: ({lat}, {lng})")
+                return self._reverse_geocode_mock(lat, lng)
+
+            # Get first result
+            first_result = result[0]
+
+            # Extract address components
+            address_components = first_result.get('address_components', [])
+            city = ""
+            state = ""
+            country = ""
+
+            for component in address_components:
+                types = component.get('types', [])
+                if 'locality' in types:
+                    city = component.get('long_name', '')
+                elif 'administrative_area_level_1' in types:
+                    state = component.get('short_name', '')
+                elif 'country' in types:
+                    country = component.get('long_name', '')
+
+            return {
+                "address": first_result.get('formatted_address', f"{lat}, {lng}"),
+                "city": city,
+                "state": state,
+                "country": country,
+                "formatted_address": first_result.get('formatted_address', f"{lat}, {lng}"),
+                "confidence": "high (Google Maps API)"
+            }
+
+        except Exception as e:
+            logger.error(f"Google Maps reverse geocoding error: {e}")
+            raise
+
+    def _reverse_geocode_mock(self, lat: float, lng: float) -> Dict:
+        """
+        Mock reverse geocoding
+        Tries to match coordinates to known cities
+        """
+        # Find closest city
+        min_distance = float('inf')
+        closest_city = "Unknown Location"
+
+        for city, coords in CITY_COORDINATES.items():
+            # Simple distance calculation
+            distance = ((lat - coords[0]) ** 2 + (lng - coords[1]) ** 2) ** 0.5
+            if distance < min_distance:
+                min_distance = distance
+                closest_city = city
+
+        # If very close to a known city (within ~0.1 degrees, roughly 11km)
+        if min_distance < 0.1:
+            logger.info(f"Mock reverse geocoding: Matched to {closest_city}")
+            return {
+                "address": f"Near {closest_city.title()}",
+                "city": closest_city.title(),
+                "state": "CA" if "san francisco" in closest_city or "la" in closest_city else "",
+                "country": "USA",
+                "formatted_address": f"Near {closest_city.title()}, USA",
+                "confidence": f"medium (mock - near {closest_city})"
+            }
+        else:
+            logger.info(f"Mock reverse geocoding: Unknown location at ({lat}, {lng})")
+            return {
+                "address": f"{lat}, {lng}",
+                "city": "",
+                "state": "",
+                "country": "",
+                "formatted_address": f"Coordinates: {lat}, {lng}",
+                "confidence": "low (mock - no match)"
+            }
+
     def get_status(self) -> str:
         """Get geocoding service status"""
         if self.use_mock:

chat/providers/gemini_provider.py

@@ -104,7 +104,7 @@ You: [geocode_address] → "OK geocoded, now creating..." ❌ WRONG!
 **Driver Querying (INTERACTIVE):**
 - count_drivers: Count drivers with optional filters
 - fetch_drivers: Fetch N drivers with pagination and filters
-- get_driver_details: Get complete info about specific driver by ID
+- get_driver_details: Get complete info about specific driver by ID (includes current location with latitude, longitude, and human-readable address)
 - search_drivers: Search by name/email/phone/plate/driver ID
 - get_available_drivers: Get all active/offline drivers ready for dispatch
 
@@ -501,7 +501,7 @@ You: [get_driver_details with driver_id=DRV-20251114163800] → [Display complet
                     ),
                     genai.protos.FunctionDeclaration(
                         name="get_driver_details",
-                        description="Get complete details of a specific driver by driver ID. Use when user asks 'tell me about driver X' or wants detailed information about a specific driver.",
+                        description="Get complete details of a specific driver by driver ID, including current location (latitude, longitude, and human-readable address), contact info, vehicle details, status, and skills. Use when user asks about a driver's location, coordinates, position, or any other driver information.",
                         parameters=genai.protos.Schema(
                             type=genai.protos.Type.OBJECT,
                             properties={

chat/tools.py

@@ -336,7 +336,7 @@ TOOLS_SCHEMA = [
     },
     {
         "name": "get_driver_details",
-        "description": "Get complete details of a specific driver by driver ID. Use when user asks 'tell me about driver X' or wants detailed information about a specific driver.",
+        "description": "Get complete details of a specific driver by driver ID, including current location (latitude, longitude, and human-readable address), contact info, vehicle details, status, and skills. Use when user asks about a driver's location, coordinates, position, or any other driver information.",
         "input_schema": {
             "type": "object",
             "properties": {
@@ -1866,6 +1866,22 @@ def handle_get_driver_details(tool_input: dict) -> dict:
             except:
                 skills = []
 
+        # Reverse geocode location to get address
+        location_address = None
+        if row['current_lat'] and row['current_lng']:
+            try:
+                from chat.geocoding import GeocodingService
+                geocoding_service = GeocodingService()
+                reverse_result = geocoding_service.reverse_geocode(
+                    float(row['current_lat']),
+                    float(row['current_lng'])
+                )
+                location_address = reverse_result.get('formatted_address', None)
+                logger.info(f"Reverse geocoded driver location: {location_address}")
+            except Exception as e:
+                logger.warning(f"Failed to reverse geocode driver location: {e}")
+                location_address = None
+
         driver = {
             "driver_id": row['driver_id'],
             "name": row['name'],
@@ -1876,6 +1892,7 @@ def handle_get_driver_details(tool_input: dict) -> dict:
             "location": {
                 "latitude": float(row['current_lat']) if row['current_lat'] else None,
                 "longitude": float(row['current_lng']) if row['current_lng'] else None,
+                "address": location_address,
                 "last_update": str(row['last_location_update']) if row['last_location_update'] else None
             },
             "status": row['status'],