from __future__ import annotations

import hmac
from typing import Optional
from uuid import UUID

from fastapi import APIRouter, Depends, Header, HTTPException
from sqlalchemy.orm import Session

from app.core.config import settings
from app.models.database import get_db
from app.schemas.integrations import (
    JoomlaCustomerRequest,
    JoomlaCustomerResponse,
    JoomlaLicenceDetailResponse,
    JoomlaLicenceListResponse,
    JoomlaProvisionLicenceRequest,
    JoomlaProvisionLicenceResponse,
    JoomlaRemoteDeactivateRequest,
    JoomlaRemoteDeactivateResponse,
)
from app.services.integrations import JoomlaIntegrationService

router = APIRouter(prefix="/v1/integrations/joomla", tags=["joomla-integration"])


def require_joomla_service_token(authorization: Optional[str] = Header(default=None)) -> None:
    configured_token = settings.joomla_integration_token
    if not configured_token:
        raise HTTPException(status_code=403, detail="Integration is not configured.")
    prefix = "Bearer "
    if authorization is None or not authorization.startswith(prefix):
        raise HTTPException(status_code=401, detail="Missing integration credential.")
    supplied = authorization[len(prefix):]
    if not hmac.compare_digest(supplied, configured_token):
        raise HTTPException(status_code=403, detail="Invalid integration credential.")


@router.post(
    "/customers",
    response_model=JoomlaCustomerResponse,
    response_model_by_alias=True,
    dependencies=[Depends(require_joomla_service_token)],
)
def find_or_create_customer(
    request: JoomlaCustomerRequest,
    session: Session = Depends(get_db),
) -> JoomlaCustomerResponse:
    return JoomlaIntegrationService(session).find_or_create_customer(request)


@router.get(
    "/customers/{joomla_user_id}/licences",
    response_model=JoomlaLicenceListResponse,
    response_model_by_alias=True,
    dependencies=[Depends(require_joomla_service_token)],
)
def list_customer_licences(
    joomla_user_id: str,
    session: Session = Depends(get_db),
) -> JoomlaLicenceListResponse:
    return JoomlaIntegrationService(session).list_licences(joomla_user_id)


@router.get(
    "/customers/{joomla_user_id}/licences/{licence_id}",
    response_model=JoomlaLicenceDetailResponse,
    response_model_by_alias=True,
    dependencies=[Depends(require_joomla_service_token)],
)
def licence_detail(
    joomla_user_id: str,
    licence_id: UUID,
    session: Session = Depends(get_db),
) -> JoomlaLicenceDetailResponse:
    return JoomlaIntegrationService(session).licence_detail(joomla_user_id, licence_id)


@router.post(
    "/licences/provision",
    response_model=JoomlaProvisionLicenceResponse,
    response_model_by_alias=True,
    dependencies=[Depends(require_joomla_service_token)],
)
def provision_licence(
    request: JoomlaProvisionLicenceRequest,
    session: Session = Depends(get_db),
) -> JoomlaProvisionLicenceResponse:
    return JoomlaIntegrationService(session).provision_licence(request)


@router.post(
    "/activations/deactivate",
    response_model=JoomlaRemoteDeactivateResponse,
    response_model_by_alias=True,
    dependencies=[Depends(require_joomla_service_token)],
)
def remotely_deactivate_activation(
    request: JoomlaRemoteDeactivateRequest,
    session: Session = Depends(get_db),
) -> JoomlaRemoteDeactivateResponse:
    return JoomlaIntegrationService(session).remotely_deactivate(
        request.joomla_user_id,
        request.activation_id,
    )