src/autoresttest/utils/utils.py

import base64
import hashlib
import itertools
import json
import math
import random
import time
from pathlib import Path
from typing import Any, Dict, Iterable, List, Optional, Set, Tuple, cast

import numpy as np
from dotenv import load_dotenv
from gensim.downloader import load
from gensim.models import KeyedVectors

from autoresttest.config import get_config
from autoresttest.models import ParameterKey, ParameterProperties, SchemaProperties
from autoresttest.prompts.generator_prompts import FIX_JSON_OBJ
from autoresttest.prompts.system_prompts import FIX_JSON_SYSTEM_MESSAGE
from autoresttest.specification import SpecificationParser

load_dotenv()
CONFIG = get_config()

CACHE_ROOT = Path(__file__).resolve().parent.parents[2] / "cache"
Q_TABLE_CACHE_DIR = CACHE_ROOT / "q_tables"
GRAPH_CACHE_DIR = CACHE_ROOT / "graphs"


def remove_nulls(item: Any) -> Any:
    if hasattr(item, "to_dict"):
        return item.to_dict()
    elif isinstance(item, dict):
        cleaned = {k: remove_nulls(v) for k, v in item.items() if v}
        return {k: v for k, v in cleaned.items() if v}
    elif isinstance(item, Iterable) and not isinstance(item, (str, bytes)):
        cleaned = [remove_nulls(i) for i in item]
        return [i for i in cleaned if i is not None]
    else:
        return item


def make_param_key(name: str | None, in_value: str | None) -> ParameterKey:
    """
    Build a canonical parameter key from name and in_value.
    """
    return (name or "", in_value or None)


def param_key_to_label(key: ParameterKey) -> str:
    """
    Create a stable string label for a parameter key (for JSON/LLM prompts).
    """
    name, in_value = key
    loc = in_value if in_value is not None else "unspecified"
    return f"{name}::{loc}"


def label_to_param_key(label: str) -> ParameterKey:
    """
    Convert a parameter label back into a key tuple.
    """
    if "::" in label:
        name, loc = label.split("::", 1)
        loc = None if loc == "unspecified" else loc
    else:
        name, loc = label, None
    return make_param_key(name, loc)


def get_param_combinations(
    operation_parameters: Dict[ParameterKey, ParameterProperties],
    required_params: Optional[Set[ParameterKey]] = None,
    seed: Optional[str] = None,
) -> List[Tuple[ParameterKey, ...]]:
    param_list = get_params(operation_parameters)
    return get_combinations(param_list, required=required_params, seed=seed)


def get_body_combinations(
    operation_body: Dict[str, SchemaProperties],
) -> Dict[str, List[Tuple[str]]]:
    return {
        k: get_combinations(v)
        for k, v in get_request_body_params(operation_body).items()
    }


def get_body_object_combinations(
    body_schema: SchemaProperties,
    required_body_params: Optional[Set[str]] = None,
    seed: Optional[str] = None,
) -> List[Tuple[str, ...]]:
    return get_combinations(
        get_body_params(body_schema), required=required_body_params, seed=seed
    )


def get_combinations(
    arr: Iterable[Any],
    required: Optional[Set[Any]] = None,
    seed: Optional[str] = None,
) -> List[Tuple[Any, ...]]:
    """
    Generate bounded parameter combinations with depth-weighted sampling.

    Uses stratified sampling that prioritizes smaller combinations while ensuring
    required parameters are always included. For large parameter sets, random
    sampling is used with seeded RNG for reproducibility.

    Args:
        arr: All parameters to combine.
        required: Parameters that must appear in every combination.
        seed: Seed string for reproducible randomness (e.g., operation ID).

    Returns:
        List of parameter combination tuples.
    """
    arr = list(arr) if arr is not None else []
    required = required or set()
    optional = [p for p in arr if p not in required]
    required_tuple = tuple(p for p in arr if p in required)  # Preserve order

    max_optional_size = CONFIG.max_combinations
    max_total = CONFIG.max_total_combinations
    base_samples = CONFIG.base_samples_per_size

    # Seeded RNG for reproducibility
    if seed:
        seed_int = int(hashlib.md5(seed.encode()).hexdigest(), 16) % (2**32)
        rng = random.Random(seed_int)
    else:
        rng = random.Random(CONFIG.combination_seed)

    combinations: Set[Tuple[Any, ...]] = set()
    n_optional = len(optional)

    # Always include: required-only and all-params
    combinations.add(required_tuple)
    if optional:
        combinations.add(required_tuple + tuple(optional))

    if n_optional <= max_optional_size:
        # Small enough: exhaustive enumeration of optional params
        for size in range(1, n_optional + 1):
            for combo in itertools.combinations(optional, size):
                combinations.add(required_tuple + combo)
    else:
        # Large: depth-weighted sampling (smaller sizes get more samples)
        for size in range(1, min(max_optional_size, n_optional) + 1):
            # Exponential decay: size=1 gets base_samples, larger sizes get fewer
            samples_for_size = max(10, int(base_samples / (size**0.7)))
            total_possible = math.comb(n_optional, size)

            if total_possible <= samples_for_size:
                # Small enough to enumerate all
                for combo in itertools.combinations(optional, size):
                    combinations.add(required_tuple + combo)
            else:
                # Random sample with seeded RNG
                sampled: Set[Tuple[Any, ...]] = set()
                attempts = 0
                max_attempts = samples_for_size * 20
                while len(sampled) < samples_for_size and attempts < max_attempts:
                    indices = rng.sample(range(n_optional), size)
                    combo = tuple(optional[i] for i in sorted(indices))
                    sampled.add(combo)
                    attempts += 1
                for combo in sampled:
                    combinations.add(required_tuple + combo)

    # Enforce hard cap (deterministic order: sort by size, then content)
    result = sorted(combinations, key=lambda x: (len(x), x))
    if len(result) > max_total:
        # Keep smallest combinations (most valuable for issue isolation)
        result = result[:max_total]

    return result


def get_params(
    operation_parameters: Dict[ParameterKey, ParameterProperties],
) -> List[ParameterKey]:
    return list(operation_parameters.keys()) if operation_parameters is not None else []


def get_required_params(
    operation_parameters: Dict[ParameterKey, ParameterProperties],
) -> Set[ParameterKey]:
    required_parameters = set()
    for parameter, parameter_properties in operation_parameters.items():
        if parameter_properties.required:
            required_parameters.add(parameter)
    return required_parameters


def get_required_body_params(operation_body: SchemaProperties) -> Optional[Set]:
    if operation_body is None:
        return None
    required_body = set()

    if operation_body.properties and operation_body.type == "object":
        for key, value in operation_body.properties.items():
            # Check if key is in the PARENT's required list (not child's required field)
            if operation_body.required and key in operation_body.required:
                required_body.add(key)

    elif operation_body.items and operation_body.type == "array":
        required_body = get_required_body_params(operation_body.items)

    else:
        return None
    return required_body


def encode_dict_as_key(dictionary: Dict) -> str:
    json_str = json.dumps(dictionary, sort_keys=True)
    return hashlib.sha256(json_str.encode()).hexdigest()


def get_body_params(body: SchemaProperties) -> List[str]:
    if body is None:
        return []

    elif body.properties and body.type == "object":
        body_params = []
        for key, value in body.properties.items():
            body_params.append(key)
        return body_params

    elif body.items and body.type == "array":
        return get_body_params(body.items)

    return []


def get_response_params(response: SchemaProperties, response_params: list[str]) -> None:
    if response is None:
        return

    if response.properties:
        for key, value in response.properties.items():
            if key not in response_params:
                response_params.append(key)
            get_response_params(value, response_params)

    elif response.items:
        get_response_params(response.items, response_params)


def get_response_param_mappings(
    response: SchemaProperties, response_mappings: dict[str, SchemaProperties]
) -> None:
    if response is None:
        return

    if response.properties:
        for key, value in response.properties.items():
            response_mappings[key] = value
            get_response_param_mappings(value, response_mappings)

    elif response.items:
        get_response_param_mappings(response.items, response_mappings)


def get_request_body_params(
    operation_body: Dict[str, SchemaProperties],
) -> Dict[str, List[str]]:
    return (
        {k: get_body_params(v) for k, v in operation_body.items()}
        if operation_body is not None
        else {}
    )


def split_parameter_values(
    operation_parameters: Dict[ParameterKey, ParameterProperties],
    provided_values: Optional[Dict[ParameterKey, Any]],
):
    """
    Split provided parameter values into path, query, header, and cookie buckets based on their 'in' value.
    Ignores parameters that are not defined on the operation.
    """
    path_params: Dict[str, Any] = {}
    query_params: Dict[str, Any] = {}
    header_params: Dict[str, Any] = {}
    cookie_params: Dict[str, Any] = {}

    if not provided_values:
        return path_params, query_params, header_params, cookie_params

    for key, value in provided_values.items():
        normalized_key = key
        if normalized_key not in operation_parameters and not isinstance(
            normalized_key, tuple
        ):
            # Fallback: match by name when provided without location
            for candidate_key in operation_parameters.keys():
                if (
                    isinstance(candidate_key, tuple)
                    and candidate_key[0] == normalized_key
                ):
                    normalized_key = candidate_key
                    break

        if normalized_key not in operation_parameters:
            continue
        if value is None:
            continue
        name, in_value = normalized_key
        in_value = in_value or operation_parameters[normalized_key].in_value

        if in_value == "path":
            path_params[name] = value
        elif in_value == "header":
            header_params[name] = value
        elif in_value == "cookie":
            cookie_params[name] = value
        else:
            query_params[name] = value

    return path_params, query_params, header_params, cookie_params


def get_object_shallow_mappings(thing: Any) -> Optional[Dict[str, Any]]:
    """
    Determine the mappings of a given item that contains some nested objects
    :param thing: The thing to get the mappings for
    :return:
    """
    if not thing:
        return None
    mappings = {}
    if type(thing) == dict:
        for key, value in thing.items():
            mappings[key] = value
    elif type(thing) == list and len(thing) > 0:
        mappings = get_object_shallow_mappings(thing[0])
    return mappings


def compose_json_fix_prompt(invalid_json_str: str):
    prompt = FIX_JSON_OBJ
    prompt += invalid_json_str
    return prompt


def attempt_fix_json(invalid_json_str: str):
    from autoresttest.llm import LanguageModel

    language_model = LanguageModel(temperature=CONFIG.strict_temperature)
    json_prompt = compose_json_fix_prompt(invalid_json_str)
    fixed_json = language_model.query(
        user_message=json_prompt, system_message=FIX_JSON_SYSTEM_MESSAGE, json_mode=True
    )
    try:
        fixed_json = json.loads(fixed_json)
        return fixed_json
    except json.JSONDecodeError:
        print("Attempt to fix JSON string failed.")
        print(f"Original JSON string: {invalid_json_str}")
        print(f"Fixed JSON string: {fixed_json}")
        return {}


def _is_json_mime(mime_type: str) -> bool:
    """
    Returns True for any JSON-like MIME type.
    """
    if not mime_type:
        return False
    mime_lower = mime_type.lower()
    return (
        "json" in mime_lower
        or mime_lower.endswith("+json")
        or mime_lower.endswith("/json")
    )


def get_accept_header(responses: dict | None) -> str | None:
    """Extract Accept header from operation responses.

    Returns comma-separated MIME types from 2xx responses, or None.
    """
    if not responses:
        return None
    mime_types = set()
    for status_code, response_props in responses.items():
        if status_code and status_code.startswith("2") and response_props.content:
            mime_types.update(response_props.content.keys())
    return ", ".join(sorted(mime_types)) if mime_types else None


def _dispatch_request_inner(
    select_method,
    full_url: str,
    params: Dict,
    body: Dict[str, Any] | None,
    headers: Dict,
    cookies: Optional[Dict],
):
    """
    Internal helper that performs a single HTTP request.
    """
    if not body:
        return select_method(
            full_url, params=params, headers=headers or None, cookies=cookies
        )

    if not isinstance(body, dict):
        return select_method(
            full_url, params=params, data=body, headers=headers or None, cookies=cookies
        )

    # Use the first provided MIME type; bodies are expected to be singular.
    mime_type, payload = next(iter(body.items()))
    mime_lower = mime_type.lower() if mime_type else ""

    if _is_json_mime(mime_type):
        headers.setdefault("Content-Type", mime_type)
        if payload is not None:
            return select_method(
                full_url,
                params=params,
                json=payload,
                headers=headers or None,
                cookies=cookies,
            )
        return select_method(
            full_url, params=params, headers=headers or None, cookies=cookies
        )

    if "x-www-form-urlencoded" in mime_lower:
        headers.setdefault("Content-Type", mime_type)
        body_data = get_object_shallow_mappings(payload)
        if not body_data or not isinstance(body_data, dict):
            body_data = {"data": payload}
        return select_method(
            full_url,
            params=params,
            data=body_data,
            headers=headers or None,
            cookies=cookies,
        )

    if mime_lower.startswith("multipart/"):
        # Convert payload to proper files format for requests.
        # Each field must be a tuple: (filename, data) or (filename, data, content_type)
        # Using None as filename indicates a form field (not a file upload).
        files_data = {}
        if isinstance(payload, dict):
            for field_name, field_value in payload.items():
                if field_value is None:
                    continue
                # Serialize non-string/bytes values to JSON
                if isinstance(field_value, (str, bytes)):
                    serialized = field_value
                else:
                    serialized = json.dumps(field_value)
                files_data[field_name] = (None, serialized)
        else:
            # Non-dict payload: serialize entire thing
            files_data = {"data": (None, json.dumps(payload) if payload else "")}

        return select_method(
            full_url,
            params=params,
            files=files_data,
            headers=headers or None,
            cookies=cookies,
        )

    if mime_lower.startswith("text/"):
        headers.setdefault("Content-Type", mime_type)
        if not isinstance(payload, str):
            payload = str(payload)
        return select_method(
            full_url,
            params=params,
            data=payload,
            headers=headers or None,
            cookies=cookies,
        )

    # Fallback: send whatever the MIME type is with a best-effort serializer.
    headers.setdefault("Content-Type", mime_type)
    if isinstance(payload, (dict, list)):
        return select_method(
            full_url,
            params=params,
            json=payload,
            headers=headers or None,
            cookies=cookies,
        )
    return select_method(
        full_url, params=params, data=payload, headers=headers or None, cookies=cookies
    )


def dispatch_request(*args, **kwargs):
    time.sleep(0.015) # Prevents WinError 10048
    return _real_dispatch_request(*args, **kwargs)

def _real_dispatch_request(
    select_method,
    full_url: str,
    params: Dict,
    body: Dict[str, Any] | None,
    header: Optional[Dict] = None,
    cookies: Optional[Dict] = None,
    max_retries: int = 3,
    base_delay: float = 1.0,
    accept: str | None = None,
):
    """
    Send a request with sensible handling for the provided body and MIME type key (if any).
    Includes automatic retry with exponential backoff for rate-limited (429) responses.
    """
    params = params or {}
    headers = header.copy() if header is not None else {}
    cookies = cookies or None
    if accept:
        headers.setdefault("Accept", accept)

    response = None
    for attempt in range(max_retries + 1):
        response = _dispatch_request_inner(
            select_method, full_url, params, body, headers.copy(), cookies
        )

        if response is None:
            return None

        # Handle rate limiting (429) with exponential backoff + jitter
        if response.status_code == 429:
            if attempt < max_retries:
                # Exponential backoff: 1s, 2s, 4s + random jitter (0-1s)
                delay = base_delay * (2**attempt) + random.uniform(0, 1)
                retry_after = response.headers.get("Retry-After")
                if retry_after and retry_after.isdigit():
                    delay = max(delay, int(retry_after))
                print(
                    f"Rate limited (429). Retrying in {delay:.1f}s (attempt {attempt + 1}/{max_retries})"
                )
                time.sleep(delay)
                continue

        return response

    return response  # Return last response even if still 429


def encode_dictionary(dictionary) -> str:
    json_str = json.dumps(dictionary, sort_keys=True)
    return hashlib.sha256(json_str.encode()).hexdigest()


def is_json_seriable(data):
    try:
        json.dumps(data)
        return True
    except (TypeError, ValueError):
        return False


class EmbeddingModel:
    def __init__(self):
        self.model: KeyedVectors = cast(KeyedVectors, load("glove-wiki-gigaword-50"))
        self.threshold = 0.8
        self._embedding_cache: Dict[str, Optional[np.ndarray]] = {}

    def encode_sentence_or_word(self, thing: str) -> Optional[np.ndarray]:
        if thing in self._embedding_cache:
            return self._embedding_cache[thing]

        words = thing.split(" ")
        word_vectors: list[np.ndarray] = [
            self.model[word] for word in words if word in self.model
        ]
        result = np.mean(word_vectors, axis=0) if word_vectors else None
        self._embedding_cache[thing] = result
        return result

    def clear_cache(self):
        """Clear embedding cache to free memory after graph generation."""
        self._embedding_cache.clear()

    @staticmethod
    def handle_word_cases(parameter):
        reconstructed_parameter = []
        for index, char in enumerate(parameter):
            if char == "_" or char == "-":
                reconstructed_parameter.append(" ")
            elif char.isalpha():
                if char.isupper() and index != 0:
                    reconstructed_parameter.append(" " + char.lower())
                else:
                    reconstructed_parameter.append(char)
        return "".join(reconstructed_parameter)


def construct_db_dir():
    for path in (Q_TABLE_CACHE_DIR, GRAPH_CACHE_DIR):
        path.mkdir(parents=True, exist_ok=True)


def get_q_table_cache_path(spec_name: str) -> Path:
    construct_db_dir()
    return Q_TABLE_CACHE_DIR / spec_name


def get_graph_cache_path(spec_name: str) -> Path:
    construct_db_dir()
    return GRAPH_CACHE_DIR / spec_name


def construct_basic_token(token):
    username = token.get("username")
    password = token.get("password")
    token_str = f"{username}:{password}"
    encoded_bytes = base64.b64encode(token_str.encode("utf-8"))
    encoded_str = encoded_bytes.decode("utf-8")
    return f"Basic {encoded_str}"


def get_api_url(spec_parser: SpecificationParser):
    return spec_parser.get_api_url()