"""GameGrip Safety API — Review Queue (Phase 3)

In-memory review queue for manual admin review.
Replace with PostgreSQL + background worker in production.
"""

from typing import Dict, List, Optional
from datetime import datetime
from uuid import uuid4
from models import ReviewItem, CategoryScore, Decision, AgeBand, Platform
from config import settings


class ReviewQueue:
    def __init__(self):
        self._items: Dict[str, ReviewItem] = {}
        self._pending: List[str] = []
        self._reviewed: List[str] = []

    def add(self, content_preview: str, original_decision: Decision, risk_score: int,
            policy_pack: str, age_band: AgeBand, platform: Platform,
            category_scores: List[CategoryScore]) -> str:
        if not settings.enable_review_queue:
            return ""

        review_id = f"rev_{uuid4().hex[:12]}"
        item = ReviewItem(
            review_id=review_id,
            content_preview=content_preview[:200],
            original_decision=original_decision,
            risk_score=risk_score,
            policy_pack=policy_pack,
            age_band=age_band,
            platform=platform,
            timestamp=datetime.utcnow(),
            status="pending",
            category_scores=category_scores,
        )
        self._items[review_id] = item
        self._pending.append(review_id)
        return review_id

    def get(self, review_id: str) -> Optional[ReviewItem]:
        return self._items.get(review_id)

    def list_pending(self) -> List[ReviewItem]:
        return [self._items[rid] for rid in self._pending if rid in self._items]

    def list_all(self) -> List[ReviewItem]:
        return list(self._items.values())

    def resolve(self, review_id: str, new_decision: Decision, admin_id: str) -> Optional[ReviewItem]:
        item = self._items.get(review_id)
        if not item:
            return None
        if review_id in self._pending:
            self._pending.remove(review_id)
        self._reviewed.append(review_id)
        item.status = "reviewed"
        item.assigned_admin = admin_id
        # We don't mutate original_decision to keep audit trail
        return item

    def stats(self) -> dict:
        return {
            "total": len(self._items),
            "pending": len(self._pending),
            "reviewed": len(self._reviewed),
        }


# Global singleton
review_queue = ReviewQueue()