"""Provider adapter for verified delivery; guards stay independent of the model vendor."""

from __future__ import annotations

import json
import os
import urllib.parse
import urllib.request
import threading
import time
import hashlib
from datetime import datetime, timezone


class NoRedirect(urllib.request.HTTPRedirectHandler):
    def redirect_request(self, req, fp, code, msg, headers, newurl):
        return None


def model_configuration() -> dict:
    provider = os.getenv("ANSWER_PROVIDER", "openai_compatible").strip()
    model = os.getenv("ANSWER_MODEL", "").strip()
    if provider == "anthropic":
        key = (os.getenv("ANSWER_API_KEY") or os.getenv("ANTHROPIC_API_KEY", "")).strip()
        endpoint = os.getenv("ANSWER_LLM_URL", "https://api.anthropic.com/v1/messages").strip()
    elif provider == "openai_compatible":
        legacy = os.getenv("OPENWEBUI_API_KEY", "").strip()
        key = os.getenv("ANSWER_API_KEY", "").strip() or legacy
        endpoint = os.getenv("ANSWER_LLM_URL", "https://ui.tukekemt.xyz/api/chat/completions" if legacy else "").strip()
        model = model or ("model120-fast" if legacy else "")
    else:
        raise RuntimeError("Unsupported answer provider")
    parsed = urllib.parse.urlsplit(endpoint)
    if (not key or not model or any(c in key for c in "\r\n") or parsed.scheme != "https"
            or not parsed.hostname or parsed.username is not None or parsed.password is not None
            or parsed.fragment or parsed.query or any(c.isspace() for c in endpoint)):
        raise RuntimeError("Answer model is not configured")
    return {'provider':provider, 'model':model, 'endpoint':endpoint, 'key':key}


_status_lock = threading.Lock()
_status = {}
HEALTH_MAX_AGE_SECONDS = 900


def configuration_key(config: dict) -> str:
    return hashlib.sha256(json.dumps(config,sort_keys=True).encode()).hexdigest()


def generation_status() -> dict:
    try:
        config = model_configuration()
    except (RuntimeError,ValueError):
        return {'ready':False,'status':'unavailable','reason':'model_not_configured','configured':False}
    public={'configured':True,'provider':config['provider'],'model':config['model']}
    with _status_lock:
        status = dict(_status)
    if status.get('configuration') != configuration_key(config) or time.time()-status.get('checked_at',0)>HEALTH_MAX_AGE_SECONDS:
        return {**public,'ready':False,'status':'unknown','reason':'model_availability_not_verified'}
    return {**public,'ready':status['success'],'status':'ready' if status['success'] else 'unavailable',
            'reason':None if status['success'] else 'model_probe_failed',
            'checked_at_utc':datetime.fromtimestamp(status['checked_at'],timezone.utc).isoformat()}


def complete_with_configured_model(messages: list[dict], *, max_tokens: int | None = None, output_schema: dict | None = None) -> dict:
    config = model_configuration()
    try:
        options={'max_tokens':max_tokens}
        # Compatible endpoints do not necessarily implement constrained decoding.
        # Enable only for a provider/model whose capability was configured.
        if output_schema is not None and os.getenv('ANSWER_STRUCTURED_OUTPUT','prompt')=='json_schema':
            options['output_schema']=strict_output_schema(output_schema)
        result = _complete_request(messages,config,**options)
    except Exception:
        with _status_lock:
            _status.update(configuration=configuration_key(config), checked_at=time.time(),success=False)
        raise
    with _status_lock:
        _status.update(configuration=configuration_key(config),checked_at=time.time(),success=True)
    return result


def probe_generation() -> dict:
    try:
        complete_with_configured_model([{'role':'user','content':'Reply only with OK.'}],max_tokens=32)
    except Exception:
        pass # The caller gets only sanitized configuration/availability, never raw exceptions.
    return generation_status()


def _complete_request(messages: list[dict], config: dict, *, max_tokens: int | None = None, output_schema: dict | None = None) -> dict:
    if max_tokens is not None and (type(max_tokens) is not int or not 1 <= max_tokens <= 16384):
        raise ValueError("Invalid model output budget")
    provider,model,key,endpoint = (config[k] for k in ('provider','model','key','endpoint'))
    if provider == "anthropic":
        system = "\n\n".join(row["content"] for row in messages if row["role"] == "system")
        body = {
            "model": model,
            "messages": [row for row in messages if row["role"] != "system"],
            "max_tokens": max_tokens or int(os.getenv("ANSWER_MAX_TOKENS", "4096")),
            "temperature": 0,
        }
        if system:
            body["system"] = system
        if output_schema is not None:
            body['output_config']={'format':{'type':'json_schema','schema':output_schema}}
        headers = {"x-api-key": key, "anthropic-version": "2023-06-01"}
    elif provider == "openai_compatible":
        body = {"model": model, "messages": messages, "temperature": 0, "stream": False}
        if max_tokens is not None:
            body["max_tokens"] = max_tokens
        if output_schema is not None:
            body['response_format']={'type':'json_schema','json_schema':{'name':'question_plan','strict':True,'schema':output_schema}}
        headers = {"Authorization": "Bearer " + key}
    else:
        raise RuntimeError("Unsupported answer provider")
    request = urllib.request.Request(
        endpoint,
        data=json.dumps(body, ensure_ascii=False).encode(),
        headers={"Content-Type": "application/json", **headers},
    )
    with urllib.request.build_opener(NoRedirect()).open(request, timeout=120) as response:
        data = response.read(2 * 1024 * 1024 + 1)
    if len(data) > 2 * 1024 * 1024:
        raise RuntimeError("Answer model output is too large")
    value = json.loads(data)
    if provider == "anthropic":
        if value.get("stop_reason") != "end_turn":
            raise RuntimeError("Incomplete answer model output")
        text = "".join(
            block["text"] for block in value.get("content", []) if block.get("type") == "text"
        )
        if not text:
            raise RuntimeError("Missing answer model output")
        return {"choices": [{"message": {"content": text}}]}
    if not isinstance(value,dict) or not value.get('choices'):
        raise RuntimeError('Invalid answer model response')
    choice=value['choices'][0]
    if choice.get('finish_reason') not in (None,'stop') or not choice.get('message',{}).get('content'):
        raise RuntimeError('Incomplete answer model output')
    return value


def strict_output_schema(value):
    """Provider schema subset; validate the result against full Pydantic constraints."""
    if isinstance(value,list):return [strict_output_schema(v) for v in value]
    if not isinstance(value,dict):return value
    result={k:strict_output_schema(v) for k,v in value.items() if k not in {'default','minimum','maximum','minLength','maxLength','minItems','maxItems','format'}}
    if result.get('type')=='object':
        result['additionalProperties']=False
        result['required']=list(result.get('properties',{}))
    return result