"""
Router endpoints for the services module

Endpoints:
 - [GET](/): [root user]: Get a list of all services(id, name)
 - [POST](/): [super admin]: Register a new service(name) on the hub, returns the API key for the service to access the hub.
 - [PATCH](/key): [super_admin]: Refreshes the API key for a service(id), returning a new one.
 - [DELETE](/): [super_admin]: Removes a service(id) from the hub.
"""

from fastapi import APIRouter, status
from psycopg.errors import UniqueViolation
from sqlalchemy.exc import IntegrityError

from src.exceptions import ConflictException
from src.database import db_dependency
from src.auth.dependencies import (
	super_admin_dependency,
	org_model_root_claim_query_dependency,
)

from src.service.models import Service
from src.service.utils import generate_api_key
from src.service.dependencies import service_model_body_dependency
from src.service.schemas import (
	ServiceGetServiceResponse,
	ServicePostServiceRequest,
	ServicePostServiceResponse,
	ServiceWithKeySchema,
	ServicePatchKeyResponse,
	ServicePatchKeyRequest,
	ServiceDeleteServiceRequest,
)

router = APIRouter(
	tags=["Service"],
	prefix="/service",
)


@router.get(
	"/",
	summary="Get all services",
	status_code=status.HTTP_200_OK,
	response_model=ServiceGetServiceResponse,
	responses={
		status.HTTP_200_OK: {"description": "Successful retrieval from database"},
		status.HTTP_401_UNAUTHORIZED: {"description": "Unauthorized"},
	},
)
async def get_all_services(
	db: db_dependency, org_model: org_model_root_claim_query_dependency
):
	"""
	Returns the ID and name of all services registered to the hub.
	"""
	permission_models = db.query(Service).all()

	return {"services": permission_models}


@router.post(
	"/",
	summary="Register a new service.",
	status_code=status.HTTP_200_OK,
	response_model=ServicePostServiceResponse,
	responses={
		status.HTTP_200_OK: {"description": "Successfully registered a new service"},
		status.HTTP_401_UNAUTHORIZED: {"description": "Unauthorized"},
		status.HTTP_409_CONFLICT: {
			"description": "Service with this name already exists"
		},
	},
)
async def register_service(
	db: db_dependency,
	su: super_admin_dependency,
	request_model: ServicePostServiceRequest,
):
	"""
	Registers a new service to the hub, generating and returning an API key for it.
	"""
	key = generate_api_key()
	service_model = Service(name=request_model.name, api_key=key)

	db.add(service_model)
	try:
		db.flush()
	except IntegrityError as e:
		if isinstance(e.orig, UniqueViolation):
			raise ConflictException(message="Service with this name already exists")
	response = ServiceWithKeySchema(**service_model.__dict__)
	db.commit()
	return {"service": response}


@router.patch(
	"/key",
	summary="Regenerate service API key.",
	status_code=status.HTTP_200_OK,
	response_model=ServicePatchKeyResponse,
	responses={
		status.HTTP_200_OK: {"description": "Successful update of API key"},
		status.HTTP_401_UNAUTHORIZED: {"description": "Unauthorized"},
	},
)
async def regenerate_api_key(
	db: db_dependency,
	su: super_admin_dependency,
	service_model: service_model_body_dependency,
	request_model: ServicePatchKeyRequest,
):
	"""
	Generates and returns a new API key for the service to access the hub.
	"""
	key = generate_api_key()
	service_model.api_key = key

	db.flush()
	response = ServiceWithKeySchema(**service_model.__dict__)
	db.commit()
	return {"service": response}


@router.delete(
	"/",
	summary="Remove a service.",
	status_code=status.HTTP_204_NO_CONTENT,
	responses={
		status.HTTP_204_NO_CONTENT: {
			"description": "Successfully removed service from db"
		},
		status.HTTP_401_UNAUTHORIZED: {"description": "Unauthorized"},
	},
)
async def remove_service(
	db: db_dependency,
	service_model: service_model_body_dependency,
	su: super_admin_dependency,
	request_model: ServiceDeleteServiceRequest,
):
	"""
	Removes a service from the hub.
	"""
	db.delete(service_model)
	db.commit()