import httpx
import logging
from typing import Optional
from schemas import NormalizedVitals
from config import settings

logger = logging.getLogger(__name__)

_http_client: Optional[httpx.AsyncClient] = None

def get_http_client() -> httpx.AsyncClient:
    global _http_client
    if _http_client is None or _http_client.is_closed:
        _http_client = httpx.AsyncClient(
            timeout=httpx.Timeout(connect=3.0, read=5.0, write=3.0, pool=3.0),
            limits=httpx.Limits(max_keepalive_connections=5, max_connections=10)
        )
    return _http_client

async def forward_vitals_to_api(vitals: NormalizedVitals) -> bool:
    """
    Attempts to POST the normalized vitals to the configured target API
    and to the Render cloud database.
    Returns True if at least one forward succeeds.
    """
    import os
    headers = {"Content-Type": "application/json"}
    
    # Strip heavy wave sample arrays before REST transmission (cloud APIs only ingest vital signs)
    payload = vitals.model_dump(mode="json")
    payload.pop("ecg_wave", None)
    payload.pop("pleth_wave", None)
    
    client = get_http_client()
    
    # 1. Forward to primary target API (e.g. Injomo Dev Workflow)
    primary_url = settings.target_api_url
    primary_success = False
    if primary_url:
        try:
            primary_headers = headers.copy()
            if settings.api_token:
                primary_headers["Authorization"] = f"Bearer {settings.api_token}"
            response = await client.post(
                primary_url,
                json=payload,
                headers=primary_headers
            )
            response.raise_for_status()
            logger.info(f"Successfully forwarded vitals to primary API for device {vitals.device_id}")
            primary_success = True
        except Exception as e:
            err_msg = str(e).strip() or "timeout / connection reset"
            logger.warning(f"Error forwarding to primary API: {type(e).__name__} ({err_msg})")

    # 2. Forward to Render Cloud Server
    render_url = "https://contectfiveparamonitor.onrender.com/api/push-vitals"
    render_success = False
    
    # Detect if we are already running on Render to prevent an infinite loop
    is_on_render = os.getenv("RENDER") is not None or os.getenv("PORT") == "10000" or "render.local" in os.getenv("HOSTNAME", "")
    
    if not is_on_render:
        try:
            url_with_key = render_url
            if settings.api_token:
                url_with_key = f"{render_url}?api_key={settings.api_token}"
                
            response = await client.post(
                url_with_key,
                json=payload,
                headers=headers
            )
            response.raise_for_status()
            logger.info(f"Successfully forwarded vitals to Render Cloud for device {vitals.device_id}")
            render_success = True
        except Exception as e:
            err_msg = str(e).strip() or "timeout / connection reset"
            logger.warning(f"Error forwarding to Render Cloud: {type(e).__name__} ({err_msg})")
            
    return primary_success or render_success


async def sync_patient_assignment_to_cloud(patient_data: dict, device_id: str) -> bool:
    """
    Synchronizes patient demographics assignment to Render Cloud Server.
    Ensures local and remote dashboards always show the exact same patient.
    """
    import os
    is_on_render = os.getenv("RENDER") is not None or os.getenv("PORT") == "10000" or "render.local" in os.getenv("HOSTNAME", "")
    if is_on_render:
        return True

    client = get_http_client()
    render_assign_url = "https://contectfiveparamonitor.onrender.com/api/patient/assign"
    payload = {
        "device_id": device_id,
        "mrn": patient_data.get("mrn") or patient_data.get("patient_id") or "",
        "name": patient_data.get("name") or patient_data.get("patient_name") or "Unknown",
        "dob": patient_data.get("dob") or patient_data.get("patient_dob"),
        "gender": patient_data.get("gender") or patient_data.get("patient_gender"),
        "bed_id": patient_data.get("bed_id"),
    }
    try:
        url_with_key = render_assign_url
        if settings.api_token:
            url_with_key = f"{render_assign_url}?api_key={settings.api_token}"
        resp = await client.post(url_with_key, json=payload, headers={"Content-Type": "application/json"})
        resp.raise_for_status()
        logger.info(f"Successfully synced patient {payload['mrn']} ({payload['name']}) to Render Cloud for {device_id}")
        return True
    except Exception as e:
        logger.warning(f"Could not sync patient assignment to Render Cloud: {type(e).__name__} ({e})")
        return False