import intent
import requests
import traceback
from log import log

def auth_token_handler(api_name, auth_config, session):
    try:
        token_info = session.auth_tokens.get(api_name)
        if token_info and "token" in token_info:
            return token_info["token"], session

        auth_endpoint = auth_config.get("auth_endpoint")
        auth_body = auth_config.get("auth_body", {})
        token_path = auth_config.get("auth_token_path")

        if not auth_endpoint or not token_path:
            raise Exception("auth_endpoint veya token_path tanımsız")

        resolved_body = {
            k: intent.resolve_placeholders(str(v), session.__dict__, session.variables) for k, v in auth_body.items()
        }

        response = requests.post(auth_endpoint, json=resolved_body, timeout=5)
        response.raise_for_status()
        json_resp = response.json()

        token_parts = token_path.split(".")
        token = json_resp
        for part in token_parts:
            token = token.get(part)
            if token is None:
                raise Exception(f"Token path çözülemedi: {token_path}")

        refresh_token = json_resp.get("refresh_token")
        session.auth_tokens[api_name] = {
            "token": token,
            "refresh_token": refresh_token
        }

        return token, session

    except Exception as e:
        log(f"❌ Auth token alınamadı: {e}")
        raise e

def refresh_auth_token(api_name, auth_config, session):
    try:
        refresh_endpoint = auth_config.get("auth_refresh_endpoint")
        refresh_body = auth_config.get("refresh_body", {})
        token_path = auth_config.get("auth_token_path")

        if not refresh_endpoint or not token_path:
            raise Exception("Refresh yapılandırması eksik")

        refresh_token = session.auth_tokens.get(api_name, {}).get("refresh_token")
        if not refresh_token:
            raise Exception("Mevcut refresh token bulunamadı")

        resolved_body = {
            k: intent.resolve_placeholders(str(v), session.__dict__, session.variables) for k, v in refresh_body.items()
        }

        response = requests.post(refresh_endpoint, json=resolved_body, timeout=5)
        response.raise_for_status()
        json_resp = response.json()

        token_parts = token_path.split(".")
        token = json_resp
        for part in token_parts:
            token = token.get(part)
            if token is None:
                raise Exception(f"Token path çözülemedi: {token_path}")

        new_refresh_token = json_resp.get("refresh_token", refresh_token)

        session.auth_tokens[api_name] = {
            "token": token,
            "refresh_token": new_refresh_token
        }

        log(f"🔁 Token başarıyla yenilendi: {api_name}")
        return token, session

    except Exception as e:
        log(f"❌ Token yenileme başarısız: {e}")
        raise e

def execute_intent(intent_name, user_input, session_dict, intent_definitions, data_formats):
    try:
        session = session_dict
        intent_def = intent_definitions[intent_name]
        action_api_name = intent_def.get("action")

        if not action_api_name:
            raise Exception(f"Intent '{intent_name}' için action tanımı eksik.")

        api_def = session["service_config"].get_api_config(action_api_name)
        if not api_def:
            raise Exception(f"API '{action_api_name}' tanımı bulunamadı.")

        variables_raw = intent.extract_parameters(intent_def.get("variables", []), user_input)
        variables = {item["key"]: item["value"] for item in variables_raw}

        log(f"🚀 execute_intent('{intent_name}')")
        log(f"🔍 Çıkarılan parametreler: {variables}")

        variable_format_map = intent_def.get("variable_formats", {})
        is_valid, validation_errors = intent.validate_variable_formats(variables, variable_format_map, data_formats)
        if not is_valid:
            log(f"⚠️ Validasyon hatası: {validation_errors}")
            return {
                "errors": validation_errors,
                "awaiting_variable": list(validation_errors.keys())[0],
                "session": session
            }

        headers = api_def.get("headers", [])
        body = api_def.get("body", {})
        method = api_def.get("method", "POST")
        url = api_def["url"]
        timeout = api_def.get("timeout", 5)
        retry_count = api_def.get("retry_count", 0)
        auth_config = api_def.get("auth")
        tls = api_def.get("tls", {})
        verify = tls.get("verify", True)
        verify_path = tls.get("ca_bundle") if verify and tls.get("ca_bundle") else verify

        if auth_config:
            token, session = auth_token_handler(action_api_name, auth_config, session)

        resolved_headers = {
            h["key"]: intent.resolve_placeholders(h["value"], session, variables)
            for h in headers
        }
        resolved_body = {
            k: intent.resolve_placeholders(str(v), session, variables)
            for k, v in body.items()
        }

        for attempt in range(retry_count + 1):
            try:
                response = requests.request(
                    method=method,
                    url=url,
                    headers=resolved_headers,
                    json=resolved_body,
                    timeout=timeout,
                    verify=verify_path
                )
                if response.status_code == 401 and auth_config and attempt < retry_count:
                    log("🔁 Token expired. Yenileniyor...")
                    token, session = refresh_auth_token(action_api_name, auth_config, session)
                    continue
                response.raise_for_status()
                break
            except requests.HTTPError as e:
                if response.status_code != 401 or attempt == retry_count:
                    raise e

        log("✅ API çağrısı başarılı")
        json_resp = response.json()

        field = api_def.get("response_parser", {}).get("field")
        value = json_resp.get(field) if field else json_resp
        template = api_def.get("reply_template", str(value))
        reply = intent.resolve_placeholders(template, session, {**variables, field: str(value)})

        session.setdefault("variables", {}).update(variables)
        session["last_intent"] = intent_name
        return {
            "reply": reply,
            "session": session
        }

    except Exception as e:
        log(f"❌ execute_intent() hatası: {e}")
        traceback.print_exc()
        return {
            "error": str(e),
            "session": session
        }