leggen/leggen/api_client.py

import os
import requests
from typing import Dict, Any, Optional, List
from urllib.parse import urljoin

from leggen.utils.text import error


class LeggendAPIClient:
    """Client for communicating with the leggend FastAPI service"""
    
    def __init__(self, base_url: Optional[str] = None):
        self.base_url = base_url or os.environ.get("LEGGEND_API_URL", "http://localhost:8000")
        self.session = requests.Session()
        self.session.headers.update({
            "Content-Type": "application/json",
            "Accept": "application/json"
        })

    def _make_request(self, method: str, endpoint: str, **kwargs) -> Dict[str, Any]:
        """Make HTTP request to the API"""
        url = urljoin(self.base_url, endpoint)
        
        try:
            response = self.session.request(method, url, **kwargs)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.ConnectionError:
            error("Could not connect to leggend service. Is it running?")
            error(f"Trying to connect to: {self.base_url}")
            raise
        except requests.exceptions.HTTPError as e:
            error(f"API request failed: {e}")
            if response.text:
                try:
                    error_data = response.json()
                    error(f"Error details: {error_data.get('detail', 'Unknown error')}")
                except:
                    error(f"Response: {response.text}")
            raise
        except Exception as e:
            error(f"Unexpected error: {e}")
            raise

    def health_check(self) -> bool:
        """Check if the leggend service is healthy"""
        try:
            response = self._make_request("GET", "/health")
            return response.get("status") == "healthy"
        except:
            return False

    # Bank endpoints
    def get_institutions(self, country: str = "PT") -> List[Dict[str, Any]]:
        """Get bank institutions for a country"""
        response = self._make_request("GET", "/api/v1/banks/institutions", params={"country": country})
        return response.get("data", [])

    def connect_to_bank(self, institution_id: str, redirect_url: str = "http://localhost:8000/") -> Dict[str, Any]:
        """Connect to a bank"""
        response = self._make_request(
            "POST", 
            "/api/v1/banks/connect",
            json={"institution_id": institution_id, "redirect_url": redirect_url}
        )
        return response.get("data", {})

    def get_bank_status(self) -> List[Dict[str, Any]]:
        """Get bank connection status"""
        response = self._make_request("GET", "/api/v1/banks/status")
        return response.get("data", [])

    def get_supported_countries(self) -> List[Dict[str, Any]]:
        """Get supported countries"""
        response = self._make_request("GET", "/api/v1/banks/countries")
        return response.get("data", [])

    # Account endpoints
    def get_accounts(self) -> List[Dict[str, Any]]:
        """Get all accounts"""
        response = self._make_request("GET", "/api/v1/accounts")
        return response.get("data", [])

    def get_account_details(self, account_id: str) -> Dict[str, Any]:
        """Get account details"""
        response = self._make_request("GET", f"/api/v1/accounts/{account_id}")
        return response.get("data", {})

    def get_account_balances(self, account_id: str) -> List[Dict[str, Any]]:
        """Get account balances"""
        response = self._make_request("GET", f"/api/v1/accounts/{account_id}/balances")
        return response.get("data", [])

    def get_account_transactions(self, account_id: str, limit: int = 100, summary_only: bool = False) -> List[Dict[str, Any]]:
        """Get account transactions"""
        response = self._make_request(
            "GET", 
            f"/api/v1/accounts/{account_id}/transactions",
            params={"limit": limit, "summary_only": summary_only}
        )
        return response.get("data", [])

    # Transaction endpoints  
    def get_all_transactions(self, limit: int = 100, summary_only: bool = True, **filters) -> List[Dict[str, Any]]:
        """Get all transactions with optional filters"""
        params = {"limit": limit, "summary_only": summary_only}
        params.update(filters)
        
        response = self._make_request("GET", "/api/v1/transactions", params=params)
        return response.get("data", [])

    def get_transaction_stats(self, days: int = 30, account_id: Optional[str] = None) -> Dict[str, Any]:
        """Get transaction statistics"""
        params = {"days": days}
        if account_id:
            params["account_id"] = account_id
            
        response = self._make_request("GET", "/api/v1/transactions/stats", params=params)
        return response.get("data", {})

    # Sync endpoints
    def get_sync_status(self) -> Dict[str, Any]:
        """Get sync status"""
        response = self._make_request("GET", "/api/v1/sync/status")
        return response.get("data", {})

    def trigger_sync(self, account_ids: Optional[List[str]] = None, force: bool = False) -> Dict[str, Any]:
        """Trigger a sync"""
        data = {"force": force}
        if account_ids:
            data["account_ids"] = account_ids
            
        response = self._make_request("POST", "/api/v1/sync", json=data)
        return response.get("data", {})

    def sync_now(self, account_ids: Optional[List[str]] = None, force: bool = False) -> Dict[str, Any]:
        """Run sync synchronously"""
        data = {"force": force}
        if account_ids:
            data["account_ids"] = account_ids
            
        response = self._make_request("POST", "/api/v1/sync/now", json=data)
        return response.get("data", {})

    def get_scheduler_config(self) -> Dict[str, Any]:
        """Get scheduler configuration"""
        response = self._make_request("GET", "/api/v1/sync/scheduler")
        return response.get("data", {})

    def update_scheduler_config(self, enabled: bool = True, hour: int = 3, minute: int = 0, cron: Optional[str] = None) -> Dict[str, Any]:
        """Update scheduler configuration"""
        data = {"enabled": enabled, "hour": hour, "minute": minute}
        if cron:
            data["cron"] = cron
            
        response = self._make_request("PUT", "/api/v1/sync/scheduler", json=data)
        return response.get("data", {})