"""Structured audit logging for the Publishing Integrity system."""

import json
import logging
from datetime import datetime, timezone
from typing import Dict, Any, Optional, List

from .enums import AuditAction, ValidationState

log = logging.getLogger("pub-integrity")


class IntegrityAuditLogger:
    """Structured logger for publishing integrity decisions."""

    def __init__(self, run_id: str, run_type: str):
        self.run_id = run_id
        self.run_type = run_type
        self.entries: List[Dict[str, Any]] = []
        self.started_at = datetime.now(timezone.utc)

    def log_decision(
        self,
        action: AuditAction,
        player_name: str,
        game_id: str,
        league: str,
        validation_state: ValidationState,
        suppress_reason: Optional[str] = None,
        detail: Optional[str] = None,
        conflict: Optional[Dict[str, Any]] = None,
    ):
        entry = {
            "timestamp": datetime.now(timezone.utc).isoformat(),
            "run_id": self.run_id,
            "run_type": self.run_type,
            "action": action.value,
            "player_name": player_name,
            "game_id": game_id,
            "league": league,
            "validation_state": validation_state.value,
            "suppress_reason": suppress_reason,
            "detail": detail,
            "conflict": conflict,
        }
        self.entries.append(entry)

        # Also log to file logger
        if action == AuditAction.SUPPRESSED:
            log.warning(
                f"[SUPPRESS] {player_name} | {game_id} | {league} | "
                f"{validation_state.value} | {suppress_reason or 'N/A'}"
            )
        elif action == AuditAction.PUBLISHED:
            log.info(
                f"[PUBLISH] {player_name} | {game_id} | {league} | VERIFIED"
            )
        elif action == AuditAction.UNPUBLISHED:
            log.warning(
                f"[UNPUBLISH] {player_name} | {game_id} | {league} | "
                f"{validation_state.value} | {detail or 'N/A'}"
            )

    def log_alert(self, severity: str, message: str, data: Optional[Dict] = None):
        log.warning(f"[ALERT-{severity.upper()}] {message}")
        self.entries.append({
            "timestamp": datetime.now(timezone.utc).isoformat(),
            "run_id": self.run_id,
            "type": "alert",
            "severity": severity,
            "message": message,
            "data": data,
        })

    def summary(self) -> Dict[str, Any]:
        elapsed = (datetime.now(timezone.utc) - self.started_at).total_seconds()
        actions = {}
        for e in self.entries:
            a = e.get("action", "other")
            actions[a] = actions.get(a, 0) + 1

        return {
            "run_id": self.run_id,
            "run_type": self.run_type,
            "started_at": self.started_at.isoformat(),
            "elapsed_seconds": round(elapsed, 1),
            "total_decisions": len(self.entries),
            "action_counts": actions,
        }