from __future__ import annotations

import hashlib
import json

from sqlalchemy import select, update

from gnexus_gauth.dto import WebhookEvent

from ..storage.db import Database
from ..storage.models import AuditLog, User, UserSession, WebhookEvent as StoredWebhookEvent, utcnow

BLOCKED_EVENTS = {"user.blocked", "user.archived", "user.deleted"}
UNBLOCKED_EVENTS = {"user.unblocked", "user.restored"}
SESSION_EVENTS = {"auth.global_logout", "global_logout", "session.revoked"}
PROFILE_EVENTS = {"user.profile_updated", "profile.update"}


def handle_webhook_event(database: Database, event: WebhookEvent) -> bool:
    """Store and apply one verified gnexus-auth event. Returns False on duplicate."""
    event_id = event.event_id or _fallback_event_id(event)
    now = utcnow()

    with database.session() as session:
        with session.begin():
            if session.get(StoredWebhookEvent, event_id) is not None:
                return False

            session.add(
                StoredWebhookEvent(
                    id=event_id,
                    event_type=event.event_type,
                    received_at=now,
                    payload=event.raw_payload,
                )
            )

            target = event.target_identifiers or {}
            raw_user_id = target.get("user_id")
            user_id = str(raw_user_id) if raw_user_id is not None else None
            user = None
            if user_id:
                user = session.scalars(select(User).where(User.sub == user_id)).first()

            if event.event_type in BLOCKED_EVENTS:
                if user is not None:
                    user.blocked_at = now
                    _revoke_sessions(session, user.id, now)
            elif event.event_type in UNBLOCKED_EVENTS:
                if user is not None:
                    user.blocked_at = None
            elif event.event_type in SESSION_EVENTS:
                if user is not None:
                    _revoke_sessions(session, user.id, now)
            elif event.event_type in PROFILE_EVENTS:
                profile = (event.metadata or {}).get("profile")
                if user is not None and isinstance(profile, dict):
                    user.profile = dict(profile)
                    user.display_name = (
                        profile.get("display_name")
                        or profile.get("username")
                        or user.display_name
                    )
            elif event.event_type == "user.system_role_updated":
                system_role = (event.metadata or {}).get("system_role")
                if user is not None and isinstance(system_role, str):
                    user.system_role = system_role

            session.add(
                AuditLog(
                    actor_kind="system",
                    actor_name="gnexus-auth",
                    via="webhook",
                    action=event.event_type,
                    entity_type="user",
                    entity_id=user_id or "",
                    after={"event_id": event_id},
                )
            )

    return True


def _revoke_sessions(session, user_id, now) -> None:
    session.execute(
        update(UserSession)
        .where(
            UserSession.user_id == user_id,
            UserSession.revoked_at.is_(None),
        )
        .values(revoked_at=now)
    )


def _fallback_event_id(event: WebhookEvent) -> str:
    payload = json.dumps(event.raw_payload, sort_keys=True, ensure_ascii=False)
    digest = hashlib.sha256(f"{event.event_type}.{payload}".encode("utf-8")).hexdigest()
    return f"local_{digest}"
