class SBBClient:
    def __init__(self):
        self.base_url = "https://transport.opendata.ch/v1"
        self.cache = RedisCache(ttl=300)  # 5-minute cache
        self.rate_limiter = RateLimiter(max_calls=100, period=60)
    
    async def get_connections(self, from_city: str, to_city: str, time: datetime):
        """
        Get real-time train connections with smart caching
        """
        cache_key = f"sbb:{from_city}:{to_city}:{time.hour}"
        
        # Check cache first
        cached = await self.cache.get(cache_key)
        if cached:
            return json.loads(cached)
        
        # Rate limit API calls
        await self.rate_limiter.wait()
        
        try:
            params = {
                'from': from_city,
                'to': to_city,
                'time': time.isoformat(),
                'limit': 6
            }
            
            async with httpx.AsyncClient() as client:
                response = await client.get(f"{self.base_url}/connections", params=params)
                response.raise_for_status()
                data = response.json()
            
            # Cache successful responses
            await self.cache.set(cache_key, json.dumps(data))
            
            return self._parse_connections(data)
            
        except Exception as e:
            logger.error(f"SBB API error: {e}")
            raise SBBServiceError("Failed to fetch train schedules")

class WhatsAppHandler:
    def __init__(self, trip_planner: SwissTripsterPlanner):
        self.planner = trip_planner
        self.sessions = SessionManager()
    
    async def handle_message(self, message: dict):
        """
        Handle incoming WhatsApp messages
        """
        user_id = message['from']
        user_message = message['text']['body']
        
        # Get or create user session
        session = await self.sessions.get_session(user_id)
        
        if user_message.lower() in ['/start', 'hello', 'hi']:
            return self._get_welcome_message()
        
        elif user_message.lower() == 'new trip':
            session.state = 'awaiting_request'
            await self.sessions.save_session(user_id, session)
            return self._get_trip_prompt()
        
        elif session.state == 'awaiting_request':
            # Process trip planning request
            try:
                itinerary = await self.planner.plan_trip(
                    user_message, 
                    use_real_schedules=True
                )
                
                # Format for WhatsApp (character limits, quick replies)
                response = self._format_whatsapp_response(itinerary)
                session.state = 'idle'
                await self.sessions.save_session(user_id, session)
                
                return response
                
            except Exception as e:
                return self._get_error_message()
        
        else:
            return self._get_help_message()