import intent, requests, traceback
from log import log

def auth_token_handler(intent_name, auth_config, session):
    try:
        token_info = session.get("auth_tokens", {}).get(intent_name)
        if token_info and "token" in token_info:
            return token_info["token"], session  # Token zaten mevcut

        # Auth token alınmamışsa:
        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")

        # Placeholder çözümü (auth_body içinde {session.xxx} varsa çözülür)
        resolved_body = {
            k: intent.resolve_placeholders(str(v), session, {}) 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 path (örnek: "token" → json_resp["token"], "data.access_token" → json_resp["data"]["access_token"])
        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 varsa
        refresh_token = json_resp.get("refresh_token")

        # Session’a kaydet
        session.setdefault("auth_tokens", {})[intent_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(intent_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 mevcut mu?
        refresh_token = session.get("auth_tokens", {}).get(intent_name, {}).get("refresh_token")
        if not refresh_token:
            raise Exception("Mevcut refresh token bulunamadı")

        # Refresh body içinde placeholder varsa çöz
        resolved_body = {
            k: intent.resolve_placeholders(str(v), session, {}) 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()

        # Yeni token çıkar
        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}")

        # Yeni refresh_token varsa onu da al
        new_refresh_token = json_resp.get("refresh_token", refresh_token)

        # Güncelle
        session["auth_tokens"][intent_name] = {
            "token": token,
            "refresh_token": new_refresh_token
        }

        log(f"🔁 Token başarıyla yenilendi: {intent_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, intent_definitions, data_formats):
    try:
        definition = intent_definitions[intent_name]
        variables_raw = intent.extract_parameters(definition.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}")

        # Validasyon
        variable_format_map = definition.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
            }

        # Auth
        headers = definition["action"].get("headers", [])
        body = definition["action"].get("body", {})
        method = definition["action"].get("method", "POST")
        url = definition["action"]["url"]
        timeout = definition["action"].get("timeout", 5)
        retry_count = definition["action"].get("retry_count", 0)
        auth_config = definition["action"].get("auth", None)
        tls = definition["action"].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(intent_name, auth_config, session)

        # Header ve Body placeholder çöz
        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()
        }

        # API çağrısı
        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(intent_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()

        # Yanıtı parse et
        field = definition["action"].get("response_parser", {}).get("field")
        rate = json_resp.get(field) if field else json_resp
        template = definition["action"].get("reply_template", str(rate))
        reply = intent.resolve_placeholders(template, session, {**variables, field: str(rate)})

        # Session güncelle
        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
        }