Banana Image MCP

"""Additional validation utilities beyond core validation."""

import os
import re
from typing import Any
from urllib.parse import urlparse

from ..core.exceptions import ValidationError


def validate_display_name(display_name: str) -> None:
    """Validate file display name."""
    if not display_name or not display_name.strip():
        raise ValidationError("Display name cannot be empty")

    if len(display_name) > 256:
        raise ValidationError("Display name too long (max 256 characters)")

    # Check for invalid characters
    invalid_chars = ["<", ">", ":", '"', "|", "?", "*", "\\", "/"]
    for char in invalid_chars:
        if char in display_name:
            raise ValidationError(f"Display name contains invalid character: {char}")


def validate_positive_integer(
    value: Any, name: str, min_value: int = 1, max_value: int | None = None
) -> None:
    """Validate that a value is a positive integer within bounds."""
    if not isinstance(value, int):
        raise ValidationError(f"{name} must be an integer")

    if value < min_value:
        raise ValidationError(f"{name} must be at least {min_value}")

    if max_value and value > max_value:
        raise ValidationError(f"{name} must be at most {max_value}")


def validate_string_length(
    value: str, name: str, min_length: int = 0, max_length: int | None = None
) -> None:
    """Validate string length."""
    if not isinstance(value, str):
        raise ValidationError(f"{name} must be a string")

    if len(value) < min_length:
        raise ValidationError(f"{name} must be at least {min_length} characters")

    if max_length and len(value) > max_length:
        raise ValidationError(f"{name} must be at most {max_length} characters")


def validate_email(email: str) -> None:
    """Validate email address format."""
    email_pattern = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
    if not re.match(email_pattern, email):
        raise ValidationError("Invalid email address format")


def validate_url(url: str, allowed_schemes: list[str] | None = None) -> None:
    """Validate URL format and scheme."""
    try:
        parsed = urlparse(url)
        if not parsed.scheme or not parsed.netloc:
            raise ValidationError("Invalid URL format")

        if allowed_schemes and parsed.scheme not in allowed_schemes:
            raise ValidationError(f"URL scheme must be one of: {', '.join(allowed_schemes)}")

    except Exception as e:
        raise ValidationError(f"Invalid URL: {e}")


def validate_file_extension(filename: str, allowed_extensions: list[str]) -> None:
    """Validate file extension."""
    if not filename:
        raise ValidationError("Filename cannot be empty")

    file_ext = os.path.splitext(filename)[1].lower()
    if file_ext not in [ext.lower() for ext in allowed_extensions]:
        raise ValidationError(f"File extension must be one of: {', '.join(allowed_extensions)}")


def validate_json_structure(
    data: Any, required_fields: list[str], optional_fields: list[str] | None = None
) -> None:
    """Validate JSON structure has required fields."""
    if not isinstance(data, dict):
        raise ValidationError("Data must be a JSON object")

    # Check required fields
    missing_fields = []
    for field in required_fields:
        if field not in data:
            missing_fields.append(field)

    if missing_fields:
        raise ValidationError(f"Missing required fields: {', '.join(missing_fields)}")

    # Check for unexpected fields
    if optional_fields is not None:
        allowed_fields = set(required_fields + optional_fields)
        unexpected_fields = set(data.keys()) - allowed_fields
        if unexpected_fields:
            raise ValidationError(f"Unexpected fields: {', '.join(unexpected_fields)}")


def validate_color_hex(color: str) -> None:
    """Validate hex color format."""
    hex_pattern = r"^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$"
    if not re.match(hex_pattern, color):
        raise ValidationError("Invalid hex color format (expected #RRGGBB or #RGB)")


def validate_aspect_ratio(
    width: int, height: int, min_ratio: float = 0.1, max_ratio: float = 10.0
) -> None:
    """Validate aspect ratio is within reasonable bounds."""
    if width <= 0 or height <= 0:
        raise ValidationError("Width and height must be positive")

    ratio = width / height
    if ratio < min_ratio or ratio > max_ratio:
        raise ValidationError(
            f"Aspect ratio {ratio:.2f} is outside valid range ({min_ratio}-{max_ratio})"
        )


def sanitize_filename(filename: str) -> str:
    """Sanitize filename by removing/replacing invalid characters."""
    # Remove path separators
    filename = os.path.basename(filename)

    # Replace invalid characters with underscores
    invalid_chars = '<>:"|?*\\'
    for char in invalid_chars:
        filename = filename.replace(char, "_")

    # Remove leading/trailing dots and spaces
    filename = filename.strip(". ")

    # Ensure it's not empty
    if not filename:
        filename = "untitled"

    return filename


def validate_content_type(content_type: str, allowed_types: list[str]) -> None:
    """Validate content type against allowed types."""
    if not content_type:
        raise ValidationError("Content type cannot be empty")

    # Normalize content type (remove charset, etc.)
    main_type = content_type.split(";")[0].strip().lower()

    if main_type not in [t.lower() for t in allowed_types]:
        raise ValidationError(
            f"Content type '{main_type}' not allowed. Allowed types: {', '.join(allowed_types)}"
        )


def validate_rate_limit_params(requests: int, period_seconds: int) -> None:
    """Validate rate limiting parameters."""
    validate_positive_integer(requests, "requests", min_value=1, max_value=10000)
    validate_positive_integer(period_seconds, "period_seconds", min_value=1, max_value=86400)


def validate_pagination_params(page: int, limit: int, max_limit: int = 100) -> None:
    """Validate pagination parameters."""
    validate_positive_integer(page, "page", min_value=1)
    validate_positive_integer(limit, "limit", min_value=1, max_value=max_limit)


def validate_search_query(query: str, min_length: int = 1, max_length: int = 1000) -> None:
    """Validate search query."""
    validate_string_length(query.strip(), "search query", min_length, max_length)

    # Check for SQL injection patterns
    dangerous_patterns = [
        r"\b(union|select|insert|update|delete|drop|create|alter)\b",
        r'[\'";]',
        r"--",
        r"/\*",
    ]

    query_lower = query.lower()
    for pattern in dangerous_patterns:
        if re.search(pattern, query_lower):
            raise ValidationError("Search query contains potentially dangerous characters")


def validate_timeout_seconds(
    timeout: int | float, min_timeout: float = 0.1, max_timeout: float = 300.0
) -> None:
    """Validate timeout value in seconds."""
    if not isinstance(timeout, int | float):
        raise ValidationError("Timeout must be a number")

    if timeout < min_timeout:
        raise ValidationError(f"Timeout must be at least {min_timeout} seconds")

    if timeout > max_timeout:
        raise ValidationError(f"Timeout must be at most {max_timeout} seconds")


def validate_aspect_ratio_string(aspect_ratio: str) -> None:
    """
    Validate aspect ratio string format and supported values.

    Validates that the aspect ratio string matches one of the values
    supported by the Gemini API.

    Args:
        aspect_ratio: Aspect ratio string (e.g., "16:9", "4:3")

    Raises:
        ValidationError: If aspect ratio is invalid or unsupported

    Supported aspect ratios:
        1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9
    """
    if not isinstance(aspect_ratio, str):
        raise ValidationError("Aspect ratio must be a string")

    # Supported aspect ratios according to Gemini API documentation
    # https://ai.google.dev/gemini-api/docs/image-generation#optional_configurations
    SUPPORTED_ASPECT_RATIOS = [
        "1:1",
        "2:3",
        "3:2",
        "3:4",
        "4:3",
        "4:5",
        "5:4",
        "9:16",
        "16:9",
        "21:9",
    ]

    if aspect_ratio not in SUPPORTED_ASPECT_RATIOS:
        raise ValidationError(
            f"Unsupported aspect_ratio: '{aspect_ratio}'. "
            f"Supported values: {', '.join(SUPPORTED_ASPECT_RATIOS)}"
        )