from __future__ import annotations

from datetime import timedelta
from typing import Any

from gnexus_gauth.config import GAuthConfig
from gnexus_gauth.dto import AuthenticatedUser, WebhookEvent
from gnexus_gauth.oauth import AuthorizationUrlBuilder, HttpTokenEndpoint, PkceGenerator
from gnexus_gauth.runtime import HttpRuntimeUserProvider
from gnexus_gauth.webhook import HmacWebhookVerifier, JsonWebhookParser

from ..config import Settings
from ..storage.db import Database
from ..storage.models import OAuthState, utcnow
from .sessions import CurrentUser, create_session, token_hash
from .users import upsert_user_from_auth


class AuthError(ValueError):
    pass


class AuthService:
    def __init__(self, settings: Settings, database: Database) -> None:
        if not settings.auth_enabled:
            raise AuthError("Authentication is not configured")
        self.settings = settings
        self.database = database
        self.config = GAuthConfig(
            base_url=settings.auth_base_url or "",
            client_id=settings.auth_client_id or "",
            client_secret=settings.auth_client_secret or "",
            redirect_uri=settings.auth_redirect_uri or "",
            state_ttl_seconds=settings.auth_state_ttl_seconds,
            webhook_tolerance_seconds=settings.auth_webhook_tolerance_seconds,
            user_agent="gnexus-book",
        )
        self._tokens = HttpTokenEndpoint(self.config)
        self._users = HttpRuntimeUserProvider(self.config)
        self._urls = AuthorizationUrlBuilder(self.config)
        self._webhook_verifier = HmacWebhookVerifier(self.config)
        self._webhook_parser = JsonWebhookParser()

    def build_login_url(self, return_to: str | None = None) -> str:
        state = PkceGenerator.generate_state()
        verifier = PkceGenerator.generate_verifier()
        challenge = PkceGenerator.generate_challenge(verifier)
        now = utcnow()
        expires_at = now + timedelta(seconds=self.settings.auth_state_ttl_seconds)

        with self.database.session() as session:
            with session.begin():
                session.add(
                    OAuthState(
                        state_hash=token_hash(state),
                        code_verifier=verifier,
                        return_to=return_to,
                        created_at=now,
                        expires_at=expires_at,
                    )
                )

        return self._urls.build(
            state=state,
            pkce_challenge=challenge,
            return_to=return_to,
            scopes=list(self.settings.auth_scopes),
        )

    def exchange_code(
        self,
        code: str,
        state: str,
        user_agent: str | None = None,
        ip_address: str | None = None,
    ) -> tuple[CurrentUser, str, Any]:
        now = utcnow()
        state_hash = token_hash(state)
        with self.database.session() as session:
            record = session.get(OAuthState, state_hash)
            if record is None or record.expires_at <= now:
                raise AuthError("Unknown or expired authorization state")
            verifier = record.code_verifier
            if not verifier:
                raise AuthError("Missing PKCE verifier")

        token_set = self._tokens.exchange_authorization_code(code, verifier)
        auth_user: AuthenticatedUser = self._users.fetch_user(token_set.access_token)
        user = upsert_user_from_auth(
            self.database, auth_user, self.settings.auth_client_id or ""
        )

        with self.database.session() as session:
            with session.begin():
                record = session.get(OAuthState, state_hash)
                if record is not None:
                    session.delete(record)

        token, expires_at = create_session(
            self.database,
            user.id,
            self.settings.auth_session_ttl_seconds,
            user_agent=user_agent,
            ip_address=ip_address,
        )
        return user, token, expires_at

    def verify_and_parse_webhook(
        self, raw_body: str, headers: dict[str, str]
    ) -> WebhookEvent:
        if not self.settings.auth_webhook_secret:
            raise AuthError("Webhook secret is not configured")
        self._webhook_verifier.verify(
            raw_body, headers, self.settings.auth_webhook_secret
        )
        return self._webhook_parser.parse(raw_body)
