OLLAMA_URL = "http://localhost:11434"
MODEL = "qwen2.5:3b"

# Connection timeouts
TIMEOUT_CONEXION = 8      # Connection establishment timeout
TIMEOUT_RESPUESTA = 180   # Total response timeout
TIMEOUT_HEALTH = 5        # Health check timeout

def llamar_ollama(mensajes: list, num_predict: int = 150, num_ctx: int = 2048) -> list:
    """
    Call Ollama API with streaming response.
    
    Args:
        mensajes: List of {role, content} message dicts
        num_predict: Maximum tokens to generate
        num_ctx: Context window size (adaptive: 1024-3072)
    
    Returns:
        List of SSE-formatted strings (OpenAI-compatible format)
    """
    # Acquire semaphore slot (max 2 concurrent requests)
    adquirido = ollama_semaforo.acquire(timeout=30)
    if not adquirido:
        return ["COLA_LLENA"]  # Queue full, user must wait
    
    try:
        resp = requests.post(
            f"{OLLAMA_URL}/api/chat",
            json={
                "model": MODEL,
                "messages": mensajes,
                "stream": True,
                "think": False,  # Disable chain-of-thought (not needed)
                "options": {
                    "temperature": 0.0,        # Deterministic (repeatability)
                    "num_predict": num_predict,
                    "num_ctx": num_ctx,
                    "num_thread": 6,           # Physical cores only
                    "num_batch": 512,          # Batch size for prefill
                    "repeat_penalty": 1.1,     # Reduce repetition
                    "stop": [
                        "\n\n\n",              # Stop on triple newline
                        "Espero que",          # Common filler phrase
                        "Es importante destacar",
                        "En conclusión,",
                        "Sin embargo,",
                        # ... more stop sequences
                    ]
                }
            },
            stream=True,
            timeout=(TIMEOUT_CONEXION, TIMEOUT_RESPUESTA)
        )
        
        if resp.status_code != 200:
            return [f"ERROR_HTTP_{resp.status_code}"]
        
        # Parse streaming response and convert to OpenAI SSE format
        chunks = []
        for line in resp.iter_lines():
            if not line:
                continue
            try:
                obj = json.loads(line.decode("utf-8"))
                content_tok = obj.get("message", {}).get("content", "")
                done = obj.get("done", False)
                
                if content_tok:
                    # Escape for JSON and wrap in OpenAI SSE format
                    safe = json.dumps(content_tok)[1:-1]
                    chunks.append(
                        f'data: {{"choices":[{{"delta":{{"content":"{safe}"}}}}]}}'
                    )
                
                if done:
                    chunks.append("data: [DONE]")
            except Exception as e:
                print(f"[PARSER] {e} | {str(line)[:80]}", flush=True)
        
        return chunks
    
    except requests.exceptions.ConnectTimeout:
        with ollama_lock:
            ollama_estado["disponible"] = False
        return ["TIMEOUT_CONEXION"]
    except requests.exceptions.ReadTimeout:
        return ["TIMEOUT_RESPUESTA"]
    except requests.exceptions.ConnectionError:
        with ollama_lock:
            ollama_estado["disponible"] = False
        return ["OLLAMA_CAIDO"]
    except Exception as e:
        return [f"ERROR:{e}"]
    finally:
        ollama_semaforo.release()  # Always release semaphore

# In /siaa/chat endpoint
_es_listado = not es_conv and es_pregunta_listado(ultima_pregunta)
_num_predict = 300 if _es_listado else 150

# Calculate context size dynamically
_ctx_chars = len(contexto) + sum(len(m.get("content","")) for m in ollama_msgs)
_ctx_tokens = _ctx_chars // 4  # Approximate: 1 token ≈ 4 chars

if _ctx_tokens < 400:
    _num_ctx = 1024   # Simple query or cache hit
elif _ctx_tokens < 900:
    _num_ctx = 2048   # Normal context
else:
    _num_ctx = 3072   # Large context (avoid 4096 - causes timeout)

print(f"  [CTX] chars={_ctx_chars} tok≈{_ctx_tokens} → num_ctx={_num_ctx}", flush=True)

SYSTEM_CONVERSACIONAL = """Eres SIAA (Sistema Inteligente de Apoyo Administrativo), 
el asistente oficial de la Seccional Bucaramanga de la Rama Judicial de Colombia.

SIAA significa exactamente: "Sistema Inteligente de Apoyo Administrativo". 
No significa nada más.

Responde con cordialidad en español formal.
Para saludos y preguntas generales sobre ti mismo, responde directamente.
Recuerda que puedes ayudar con consultas sobre procesos judiciales, 
administrativos y normativos."""

SYSTEM_DOCUMENTAL = """Eres SIAA, asistente judicial de la Seccional Bucaramanga.

TAREA: Responder usando ÚNICAMENTE el contenido de los bloques [DOC:...] que recibirás.

PROCESO OBLIGATORIO — sigue estos pasos en orden:
1. Lee cada bloque [DOC:...] completo.
2. Identifica qué partes del texto se relacionan con la pregunta, aunque sea parcialmente.
3. Construye la respuesta con esos fragmentos relevantes.
4. Si encontraste información aunque sea parcial → responde con ella.
5. Solo si el contexto es completamente ajeno al tema → responde: 
   "No encontré esa información en los documentos disponibles."

REGLAS ADICIONALES:
- Cita literalmente artículos, campos, fechas, roles y valores numéricos.
- Si el contexto habla del tema en términos generales, explica eso al usuario.
- Si la pregunta pregunta por un campo específico de un formulario y el contexto 
  lo lista, nómbralo.
- Nunca inventes información que no esté en el contexto.
- Español formal institucional. Sin preámbulos. Máximo 10 líneas."""

for line in resp.iter_lines():
    obj = json.loads(line.decode("utf-8"))
    content_tok = obj.get("message", {}).get("content", "")
    done = obj.get("done", False)
    
    if content_tok:
        safe = json.dumps(content_tok)[1:-1]  # Escape quotes, newlines
        chunks.append(
            f'data: {{"choices":[{{"delta":{{"content":"{safe}"}}}}]}}'
        )
    
    if done:
        chunks.append("data: [DONE]")

def verificar_ollama() -> bool:
    try:
        r = requests.get(f"{OLLAMA_URL}/api/tags", timeout=TIMEOUT_HEALTH)
        ok = (r.status_code == 200)
    except Exception:
        ok = False
    
    with ollama_lock:
        ollama_estado["disponible"] = ok
        ollama_estado["ultimo_check"] = time.time()
        ollama_estado["fallos"] = 0 if ok else ollama_estado["fallos"] + 1
        warmup_pendiente = ok and ollama_estado["warmup_done"] is None
    
    if warmup_pendiente:
        try:
            print(f"  [Ollama] Precargando {MODEL} en RAM...", flush=True)
            requests.post(
                f"{OLLAMA_URL}/api/chat",
                json={
                    "model": MODEL,
                    "messages": [{"role": "user", "content": "ok"}],
                    "stream": False,
                    "options": {"num_predict": 1, "num_ctx": 64}
                },
                timeout=(10, 35)
            )
            with ollama_lock:
                ollama_estado["warmup_done"] = True
            print(f"  [Ollama] {MODEL} listo en RAM ✓", flush=True)
        except Exception as e:
            print(f"  [Ollama] Warm-up falló: {e}", flush=True)
            with ollama_lock:
                ollama_estado["warmup_done"] = False
    
    return ok

ERRORES = {
    "COLA_LLENA":        "⏳ Sistema ocupado. Intente en 30 segundos.",
    "TIMEOUT_CONEXION":  "⚠ IA no responde. Intente de nuevo.",
    "TIMEOUT_RESPUESTA": "⏱ Consulta tomó demasiado tiempo.",
    "OLLAMA_CAIDO":      "⚠ Servidor IA reiniciándose. Espere 1 minuto.",
}

if result[0] in ERRORES:
    yield f'data: {{"choices":[{{"delta":{{"content":"{ERRORES[result[0]]}"}}}}]}}\n\n'
    return

def _monitor_loop():
    while True:
        verificar_ollama()
        time.sleep(15)

threading.Thread(target=_monitor_loop, daemon=True).start()