Update main.py

main.py

@@ -98,7 +98,174 @@ class ApprovalAction(BaseModel):
     action: str
     admin_id: str
 
-# ============ NEW: MAP DIRECTION PARSING ============
+# ============ MAP DIRECTION PARSING ============
+
+def follow_google_maps_redirect(url):
+    """Follow Google Maps shortened URL to get the full URL and extract destination"""
+    try:
+        import requests
+        
+        logger.info(f"Following Google Maps redirect: {url}")
+        
+        # Follow the redirect
+        response = requests.get(url, timeout=15, allow_redirects=True)
+        full_url = response.url
+        logger.info(f"Redirected to: {full_url}")
+        
+        # Try to extract destination from the full URL
+        result = {
+            "to": None,
+            "from": None,
+            "to_lat": None,
+            "to_lon": None,
+            "from_lat": None,
+            "from_lon": None
+        }
+        
+        # ============ Extract from /dir/ pattern ============
+        # Pattern: /dir/from/to or /dir/from+place/to+place
+        dir_match = re.search(r'/dir/([^/]+)/([^/]+)', full_url)
+        if dir_match:
+            from_place_raw = dir_match.group(1)
+            to_place_raw = dir_match.group(2)
+            logger.info(f"From raw: {from_place_raw}, To raw: {to_place_raw}")
+            
+            # Check if from is a coordinate
+            coord_pattern = r'^(-?\d+\.\d+),(-?\d+\.\d+)$'
+            from_coord_match = re.match(coord_pattern, from_place_raw)
+            to_coord_match = re.match(coord_pattern, to_place_raw)
+            
+            if from_coord_match:
+                result["from_lat"] = float(from_coord_match.group(1))
+                result["from_lon"] = float(from_coord_match.group(2))
+                logger.info(f"From coordinates: {result['from_lat']}, {result['from_lon']}")
+                # Reverse geocode to get place name
+                from_info = reverse_geocode_enhanced(result["from_lat"], result["from_lon"])
+                if from_info:
+                    result["from"] = from_info["place_name"]
+                    logger.info(f"From location: {result['from']} (from coordinates)")
+                else:
+                    result["from"] = f"{result['from_lat']}, {result['from_lon']}"
+            else:
+                result["from"] = urllib.parse.unquote(from_place_raw).replace('+', ' ')
+                logger.info(f"From location: {result['from']}")
+            
+            if to_coord_match:
+                result["to_lat"] = float(to_coord_match.group(1))
+                result["to_lon"] = float(to_coord_match.group(2))
+                logger.info(f"To coordinates: {result['to_lat']}, {result['to_lon']}")
+                to_info = reverse_geocode_enhanced(result["to_lat"], result["to_lon"])
+                if to_info:
+                    result["to"] = to_info["place_name"]
+                    logger.info(f"To location: {result['to']} (from coordinates)")
+                else:
+                    result["to"] = f"{result['to_lat']}, {result['to_lon']}"
+            else:
+                result["to"] = urllib.parse.unquote(to_place_raw).replace('+', ' ')
+                logger.info(f"To location: {result['to']}")
+            
+            if result["from"] and result["to"]:
+                logger.info(f"✅ Extracted both from and to: {result['from']} -> {result['to']}")
+                return result
+        
+        # ============ Extract coordinates from the URL ============
+        # Pattern: @lat,lon or /@lat,lon
+        coord_pattern = r'[@/](-?\d+\.\d+),(-?\d+\.\d+)'
+        coord_matches = re.findall(coord_pattern, full_url)
+        
+        if coord_matches:
+            logger.info(f"Found coordinates in URL: {coord_matches}")
+            if len(coord_matches) >= 2:
+                # First set is start, second is destination
+                result["from_lat"] = float(coord_matches[0][0])
+                result["from_lon"] = float(coord_matches[0][1])
+                result["to_lat"] = float(coord_matches[1][0])
+                result["to_lon"] = float(coord_matches[1][1])
+                
+                # Reverse geocode to get place names
+                if result["from_lat"] and result["from_lon"]:
+                    from_info = reverse_geocode_enhanced(result["from_lat"], result["from_lon"])
+                    if from_info:
+                        result["from"] = from_info["place_name"]
+                        logger.info(f"From location: {result['from']}")
+                    else:
+                        result["from"] = f"{result['from_lat']}, {result['from_lon']}"
+                
+                if result["to_lat"] and result["to_lon"]:
+                    to_info = reverse_geocode_enhanced(result["to_lat"], result["to_lon"])
+                    if to_info:
+                        result["to"] = to_info["place_name"]
+                        logger.info(f"To location: {result['to']}")
+                    else:
+                        result["to"] = f"{result['to_lat']}, {result['to_lon']}"
+                
+                if result["from"] and result["to"]:
+                    return result
+            elif len(coord_matches) == 1:
+                # Only one coordinate set - this is a single location
+                result["to_lat"] = float(coord_matches[0][0])
+                result["to_lon"] = float(coord_matches[0][1])
+                
+                to_info = reverse_geocode_enhanced(result["to_lat"], result["to_lon"])
+                if to_info:
+                    result["to"] = to_info["place_name"]
+                    logger.info(f"Destination location: {result['to']}")
+        
+        # ============ Try other methods if we still don't have both locations ============
+        if not result["to"]:
+            # Try to get from 'q' parameter (search query)
+            q_match = re.search(r'[?&]q=([^&]+)', full_url)
+            if q_match:
+                result["to"] = urllib.parse.unquote(q_match.group(1)).replace('+', ' ')
+                logger.info(f"Extracted from 'q' parameter: {result['to']}")
+            
+            # Try to get from 'daddr' parameter (destination address)
+            daddr_match = re.search(r'[?&]daddr=([^&]+)', full_url)
+            if daddr_match:
+                result["to"] = urllib.parse.unquote(daddr_match.group(1)).replace('+', ' ')
+                logger.info(f"Extracted from 'daddr' parameter: {result['to']}")
+            
+            # Try to get from '/place/' pattern
+            place_match = re.search(r'/place/([^/]+)/', full_url)
+            if place_match:
+                result["to"] = urllib.parse.unquote(place_match.group(1)).replace('+', ' ')
+                logger.info(f"Extracted from '/place/': {result['to']}")
+        
+        # If we still don't have a "from" location, try to get from the URL
+        if not result["from"] and not result["from_lat"]:
+            # Try to extract "saddr" (source address) parameter
+            saddr_match = re.search(r'[?&]saddr=([^&]+)', full_url)
+            if saddr_match:
+                result["from"] = urllib.parse.unquote(saddr_match.group(1)).replace('+', ' ')
+                logger.info(f"Extracted from 'saddr' parameter: {result['from']}")
+        
+        # If we have coordinates for from but no name, try to reverse geocode
+        if not result["from"] and result["from_lat"] and result["from_lon"]:
+            from_info = reverse_geocode_enhanced(result["from_lat"], result["from_lon"])
+            if from_info:
+                result["from"] = from_info["place_name"]
+                logger.info(f"From location from coordinates: {result['from']}")
+            else:
+                result["from"] = f"{result['from_lat']}, {result['from_lon']}"
+        
+        # If we have coordinates for to but no name, try to reverse geocode
+        if not result["to"] and result["to_lat"] and result["to_lon"]:
+            to_info = reverse_geocode_enhanced(result["to_lat"], result["to_lon"])
+            if to_info:
+                result["to"] = to_info["place_name"]
+                logger.info(f"To location from coordinates: {result['to']}")
+            else:
+                result["to"] = f"{result['to_lat']}, {result['to_lon']}"
+        
+        logger.info(f"Final result: from={result['from']}, to={result['to']}")
+        return result
+        
+    except Exception as e:
+        logger.error(f"Error following redirect: {e}")
+        import traceback
+        traceback.print_exc()
+        return None
+
 
 def parse_map_directions(text):
     """Parse Google Maps/Apple Maps/Waze directions link"""
@@ -161,6 +328,8 @@ def parse_map_directions(text):
             if from_info:
                 result["from"] = from_info["place_name"]
                 logger.info(f"From location: {result['from']} (from coordinates)")
+            else:
+                result["from"] = f"{result['from_lat']}, {result['from_lon']}"
         else:
             result["from"] = urllib.parse.unquote(from_place_raw).replace('+', ' ')
         
@@ -171,6 +340,8 @@ def parse_map_directions(text):
             if to_info:
                 result["to"] = to_info["place_name"]
                 logger.info(f"To location: {result['to']} (from coordinates)")
+            else:
+                result["to"] = f"{result['to_lat']}, {result['to_lon']}"
         else:
             result["to"] = urllib.parse.unquote(to_place_raw).replace('+', ' ')
         
@@ -255,151 +426,19 @@ def parse_map_directions(text):
     
     return None
 
-# Add this new function near your other parsing functions (around line 150)
-
-def follow_google_maps_redirect(url):
-    """Follow Google Maps shortened URL to get the full URL and extract destination"""
-    try:
-        import requests
-        
-        logger.info(f"Following Google Maps redirect: {url}")
-        
-        # Follow the redirect
-        response = requests.get(url, timeout=10, allow_redirects=True)
-        full_url = response.url
-        logger.info(f"Redirected to: {full_url}")
-        
-        # Try to extract destination from the full URL
-        result = {
-            "to": None,
-            "from": None,
-            "to_lat": None,
-            "to_lon": None,
-            "from_lat": None,
-            "from_lon": None
+def extract_coordinates_from_text(text):
+    """Extract GPS coordinates from text"""
+    coord_pattern = r'(-?\d+\.\d+)\s*[,，]\s*(-?\d+\.\d+)'
+    match = re.search(coord_pattern, text)
+    
+    if match:
+        return {
+            "lat": float(match.group(1)),
+            "lon": float(match.group(2))
         }
-        
-        # ============ NEW: Extract from /dir/ pattern ============
-        # Pattern: /dir/from/to or /dir/from+place/to+place
-        dir_match = re.search(r'/dir/([^/]+)/([^/]+)', full_url)
-        if dir_match:
-            from_place_raw = dir_match.group(1)
-            to_place_raw = dir_match.group(2)
-            
-            # Check if from is a coordinate
-            coord_pattern = r'^(-?\d+\.\d+),(-?\d+\.\d+)$'
-            from_coord_match = re.match(coord_pattern, from_place_raw)
-            to_coord_match = re.match(coord_pattern, to_place_raw)
-            
-            if from_coord_match:
-                result["from_lat"] = float(from_coord_match.group(1))
-                result["from_lon"] = float(from_coord_match.group(2))
-                # Reverse geocode to get place name
-                from_info = reverse_geocode_enhanced(result["from_lat"], result["from_lon"])
-                if from_info:
-                    result["from"] = from_info["place_name"]
-                    logger.info(f"From location: {result['from']} (from coordinates)")
-            else:
-                result["from"] = urllib.parse.unquote(from_place_raw).replace('+', ' ')
-                logger.info(f"From location: {result['from']}")
-            
-            if to_coord_match:
-                result["to_lat"] = float(to_coord_match.group(1))
-                result["to_lon"] = float(to_coord_match.group(2))
-                to_info = reverse_geocode_enhanced(result["to_lat"], result["to_lon"])
-                if to_info:
-                    result["to"] = to_info["place_name"]
-                    logger.info(f"To location: {result['to']} (from coordinates)")
-            else:
-                result["to"] = urllib.parse.unquote(to_place_raw).replace('+', ' ')
-                logger.info(f"To location: {result['to']}")
-            
-            return result
-        
-        # ============ Extract coordinates from the URL ============
-        # Pattern: @lat,lon or /@lat,lon
-        coord_pattern = r'[@/](-?\d+\.\d+),(-?\d+\.\d+)'
-        coord_matches = re.findall(coord_pattern, full_url)
-        
-        if coord_matches:
-            logger.info(f"Found coordinates in URL: {coord_matches}")
-            if len(coord_matches) >= 2:
-                # First set is start, second is destination
-                result["from_lat"] = float(coord_matches[0][0])
-                result["from_lon"] = float(coord_matches[0][1])
-                result["to_lat"] = float(coord_matches[1][0])
-                result["to_lon"] = float(coord_matches[1][1])
-                
-                # Reverse geocode to get place names
-                if result["from_lat"] and result["from_lon"]:
-                    from_info = reverse_geocode_enhanced(result["from_lat"], result["from_lon"])
-                    if from_info:
-                        result["from"] = from_info["place_name"]
-                        logger.info(f"From location: {result['from']}")
-                
-                if result["to_lat"] and result["to_lon"]:
-                    to_info = reverse_geocode_enhanced(result["to_lat"], result["to_lon"])
-                    if to_info:
-                        result["to"] = to_info["place_name"]
-                        logger.info(f"To location: {result['to']}")
-                
-                if result["from"] and result["to"]:
-                    return result
-            elif len(coord_matches) == 1:
-                # Only one coordinate set - this is a single location
-                result["to_lat"] = float(coord_matches[0][0])
-                result["to_lon"] = float(coord_matches[0][1])
-                
-                to_info = reverse_geocode_enhanced(result["to_lat"], result["to_lon"])
-                if to_info:
-                    result["to"] = to_info["place_name"]
-                    logger.info(f"Destination location: {result['to']}")
-        
-        # ============ Try other methods if we still don't have both locations ============
-        if not result["to"]:
-            # Try to get from 'q' parameter (search query)
-            q_match = re.search(r'[?&]q=([^&]+)', full_url)
-            if q_match:
-                result["to"] = urllib.parse.unquote(q_match.group(1)).replace('+', ' ')
-                logger.info(f"Extracted from 'q' parameter: {result['to']}")
-            
-            # Try to get from 'daddr' parameter (destination address)
-            daddr_match = re.search(r'[?&]daddr=([^&]+)', full_url)
-            if daddr_match:
-                result["to"] = urllib.parse.unquote(daddr_match.group(1)).replace('+', ' ')
-                logger.info(f"Extracted from 'daddr' parameter: {result['to']}")
-            
-            # Try to get from '/place/' pattern
-            place_match = re.search(r'/place/([^/]+)/', full_url)
-            if place_match:
-                result["to"] = urllib.parse.unquote(place_match.group(1)).replace('+', ' ')
-                logger.info(f"Extracted from '/place/': {result['to']}")
-        
-        # If we still don't have a "from" location, try to get from the URL
-        if not result["from"] and not result["from_lat"]:
-            # Try to extract "saddr" (source address) parameter
-            saddr_match = re.search(r'[?&]saddr=([^&]+)', full_url)
-            if saddr_match:
-                result["from"] = urllib.parse.unquote(saddr_match.group(1)).replace('+', ' ')
-                logger.info(f"Extracted from 'saddr' parameter: {result['from']}")
-        
-        # If we have coordinates for from but no name, try to reverse geocode
-        if not result["from"] and result["from_lat"] and result["from_lon"]:
-            from_info = reverse_geocode_enhanced(result["from_lat"], result["from_lon"])
-            if from_info:
-                result["from"] = from_info["place_name"]
-                logger.info(f"From location from coordinates: {result['from']}")
-        
-        logger.info(f"Final result: from={result['from']}, to={result['to']}")
-        return result
-        
-    except Exception as e:
-        logger.error(f"Error following redirect: {e}")
-        import traceback
-        traceback.print_exc()
-        return None
+    return None
 
-# ============ NEW: REVERSE GEOCODING ============
+# ============ REVERSE GEOCODING ============
 
 def reverse_geocode_enhanced(lat, lon):
     """Enhanced reverse geocoding with better Malaysian address parsing"""
@@ -465,7 +504,7 @@ def reverse_geocode_enhanced(lat, lon):
         logger.error(f"Reverse geocoding error: {e}")
         return None
 
-# ============ NEW: AUTO TRIP FUNCTIONS ============
+# ============ AUTO TRIP FUNCTIONS ============
 
 async def auto_start_trip_with_direction(user_id, direction_info, chat_id, username, purpose=None):
     """Auto-start trip from shared direction with optional purpose"""
@@ -482,9 +521,11 @@ async def auto_start_trip_with_direction(user_id, direction_info, chat_id, usern
     # Set the purpose
     trip_purpose = purpose or "Service"
     
+    logger.info(f"Auto trip: from={from_place} ({from_lat}, {from_lon}), to={to_place} ({to_lat}, {to_lon})")
+    
     # If we have both from and to coordinates, we can complete the trip directly
     if from_lat and to_lat:
-        # We have both locations - complete the trip directly
+        logger.info(f"✅ Both from and to coordinates found, completing trip automatically")
         pending_actions[user_id] = "waiting_for_start_location"
         
         user_sessions[user_id] = {
@@ -505,6 +546,7 @@ async def auto_start_trip_with_direction(user_id, direction_info, chat_id, usern
     
     # If we have a destination but no from location, ask user to share location
     elif to_lat and not from_lat:
+        logger.info(f"✅ Only destination found, asking for current location")
         user_sessions[user_id] = {
             "direction_info": direction_info,
             "to_place": to_place,
@@ -585,7 +627,7 @@ async def complete_trip_automatically(user_id, chat_id, username):
     end_lat = session.get("end_gps_lat")
     end_lon = session.get("end_gps_lon")
     place_name = session.get("place_name", end_place)
-    trip_purpose = session.get("trip_purpose", "Service")  # Get purpose from session
+    trip_purpose = session.get("trip_purpose", "Service")
     
     # Calculate distance
     distance = 0
@@ -664,7 +706,7 @@ async def complete_trip_automatically(user_id, chat_id, username):
         "chat_id": chat_id
     }
 
-# ============ NEW: QUICK TRIP COMMANDS ============
+# ============ QUICK TRIP COMMANDS ============
 
 async def quick_trip_with_purpose(user_id, purpose, chat_id, username):
     """Quick trip with a specific purpose"""
@@ -2501,9 +2543,7 @@ async def admin_test_sync(admin_key: str = None):
         import traceback
         result["traceback"] = traceback.format_exc()
     
-    return result
-
-@app.get("/admin/debug-user/{telegram_id}")
+    return result@app.get("/admin/debug-user/{telegram_id}")
 async def admin_debug_user(telegram_id: str, admin_key: str = None):
     """Debug endpoint to check user registration status"""
     if admin_key != ADMIN_KEY:
@@ -2987,7 +3027,32 @@ async def start_trip(data: dict):
             
             # If we have a destination name, use it
             to_place = direction_info.get("to")
-            if to_place and to_place != "Destination (Google Maps link detected)":
+            from_place = direction_info.get("from")
+            from_lat = direction_info.get("from_lat")
+            from_lon = direction_info.get("from_lon")
+            to_lat = direction_info.get("to_lat")
+            to_lon = direction_info.get("to_lon")
+            
+            # If we have both from and to, complete the trip automatically
+            if from_lat and to_lat:
+                logger.info(f"✅ Both from and to coordinates found, completing trip automatically")
+                pending_actions[user_id] = "waiting_for_start_location"
+                
+                user_sessions[user_id] = {
+                    "start_place": from_place or "Current Location",
+                    "start_gps_lat": from_lat,
+                    "start_gps_lon": from_lon,
+                    "end_place": to_place,
+                    "place_name": to_place,
+                    "trip_purpose": purpose,
+                    "status": "start_location_received",
+                    "auto_trip": True,
+                    "direction_shared": True
+                }
+                
+                return await complete_trip_automatically(user_id, chat_id, username)
+            
+            elif to_place and to_place != "Destination (Google Maps link detected)":
                 # We have a valid destination
                 logger.info(f"Destination detected: {to_place}")
                 
@@ -3081,8 +3146,6 @@ async def start_trip(data: dict):
                         purpose
                     )
     
-    # ... rest of your existing start_trip function ...
-    
     # Check if user is registered
     if not is_registered(user_id):
         return {