"""Structured logging with token and secret redaction.

No raw prompt, image, token, signed URL, or HF credential is ever written to a
log. A :class:`RedactingFilter` scrubs known secret patterns and any value of
sensitive environment variables from every record before it is emitted.
"""

from __future__ import annotations

import logging
import os
import re
from typing import Any

# Environment variables whose values must never appear in logs.
SENSITIVE_ENV_VARS = (
    "HF_TOKEN",
    "HUGGING_FACE_HUB_TOKEN",
    "WANDB_API_KEY",
    "GH_TOKEN",
    "GITHUB_TOKEN",
)

_REDACTION_TOKEN = "[REDACTED]"

# Patterns that match common bearer/credential shapes regardless of env name.
_SECRET_PATTERNS: tuple[re.Pattern[str], ...] = (
    re.compile(r"(?i)bearer\s+[A-Za-z0-9._\-]+"),
    re.compile(r"(?i)token\s*[:=]\s*[A-Za-z0-9._\-]+"),
    re.compile(r"hf_[A-Za-z0-9]{20,}"),
    re.compile(r"sk-[A-Za-z0-9]{20,}"),
    re.compile(r"https?://[^\s/@]+@[^\s/]+"),  # userinfo in URLs
)


def _sensitive_values() -> list[str]:
    values: list[str] = []
    for name in SENSITIVE_ENV_VARS:
        value = os.environ.get(name)
        if value:
            values.append(value)
    return values


def redact(text: str) -> str:
    """Return ``text`` with known secrets and sensitive env values removed."""
    if not text:
        return text
    redacted = text
    for value in _sensitive_values():
        if value and value in redacted:
            redacted = redacted.replace(value, _REDACTION_TOKEN)
    for pattern in _SECRET_PATTERNS:
        redacted = pattern.sub(_REDACTION_TOKEN, redacted)
    return redacted


class RedactingFilter(logging.Filter):
    """A logging filter that redacts secrets from message and args."""

    def filter(self, record: logging.LogRecord) -> bool:
        record.msg = redact(str(record.msg))
        if record.args:
            if isinstance(record.args, dict):
                record.args = {k: redact(str(v)) for k, v in record.args.items()}
            elif isinstance(record.args, tuple):
                record.args = tuple(redact(str(a)) for a in record.args)
        return True


def configure_logging(
    *,
    level: int = logging.INFO,
    name: str = "explicit_learning",
    stream: Any = None,
) -> logging.Logger:
    """Configure and return a logger with redaction applied to all records."""
    logger = logging.getLogger(name)
    logger.setLevel(level)
    logger.propagate = False
    if not logger.handlers:
        handler = logging.StreamHandler(stream) if stream else logging.StreamHandler()
        handler.setFormatter(
            logging.Formatter(
                "%(asctime)s %(levelname)s %(name)s %(message)s",
                datefmt="%Y-%m-%dT%H:%M:%SZ",
            )
        )
        handler.addFilter(RedactingFilter())
        logger.addHandler(handler)
    else:
        for existing in logger.handlers:
            existing.addFilter(RedactingFilter())
    return logger


def get_logger(name: str | None = None) -> logging.Logger:
    """Return a child logger under the package logger (redaction inherited)."""
    base = logging.getLogger("explicit_learning")
    if not base.handlers:
        configure_logging()
    return base.getChild(name) if name else base