"""Participation role endpoints."""

from uuid import UUID

from fastapi import APIRouter, Depends, HTTPException
from neo4j import Driver

from contributor.api.auth import identity_uuid_from_scope, profiles_from_scope
from contributor.api.datasources import get_neo4j_driver
from contributor.api.schemas.participation_roles import (
    ParticipationRole,
    ParticipationRoleCategory,
    ParticipationRolesByCatagoryDataloaderRequest,
    ParticipationRolesByCategory,
)
from contributor.connectors.neo4j import neo4j_session
from contributor.logic import participation_roles as participation_role_logic

router = APIRouter(prefix="/participation-roles", tags=["participation-roles"])


@router.get(
    path="/categories",
    operation_id="get_role_categories",
    response_model=list[ParticipationRoleCategory],
    summary="Get participation role categories",
    description="Returns the available participation role categories.",
)
def get_role_categories(
    profiles: list[dict] = Depends(profiles_from_scope),
    driver: Driver = Depends(get_neo4j_driver),
    identity_uuid: UUID = Depends(identity_uuid_from_scope),
) -> list[ParticipationRoleCategory]:
    with neo4j_session(driver) as session:
        results = participation_role_logic.get_role_categories(
            neo4j_session=session, identity_id=identity_uuid
        )

    return [ParticipationRoleCategory.model_validate(category) for category in results]


@router.post(
    path="/categories/roles/dataloader",
    operation_id="get_bulk_roles_by_category_uuid",
    response_model=list[ParticipationRolesByCategory],
    summary="Get bulk participation roles by category uuid",
    description="Returns participation roles for multiple participation role category uuids.",
)
def get_bulk_roles_by_category_uuid(
    request: ParticipationRolesByCatagoryDataloaderRequest,
    driver: Driver = Depends(get_neo4j_driver),
    identity_uuid: UUID = Depends(identity_uuid_from_scope),
) -> list[ParticipationRolesByCategory]:
    category_uuids = [str(cat.uuid) for cat in request.categories]
    with neo4j_session(driver) as session:
        results = participation_role_logic.get_roles_by_category_uuids(
            neo4j_session=session, uuids=category_uuids, identity_id=identity_uuid
        )
        categories = participation_role_logic.get_role_categories(
            neo4j_session=session, identity_id=identity_uuid
        )

    # Build a mapping of category UUID to category details
    category_map = {str(cat["uuid"]): cat for cat in categories}

    return [
        ParticipationRolesByCategory.model_validate(
            {
                "category": category_map.get(
                    result["category_uuid"],
                    {"uuid": result["category_uuid"], "name": ""},
                ),
                "roles": [
                    ParticipationRole.model_validate(role) for role in result["roles"]
                ],
            }
        )
        for result in results
    ]


@router.get(
    path="/categories/{uuid}/roles",
    operation_id="get_roles_by_category_uuid",
    response_model=ParticipationRolesByCategory,
    summary="Get participation roles by category uuid",
    description="Returns participation roles for a given participation role category uuid.",
)
def get_roles_by_category_uuid(
    uuid: str,
    driver: Driver = Depends(get_neo4j_driver),
    identity_uuid: UUID = Depends(identity_uuid_from_scope),
) -> ParticipationRolesByCategory:
    category_uuid = UUID(uuid)
    with neo4j_session(driver) as session:
        results = participation_role_logic.get_roles_by_category_uuids(
            neo4j_session=session, uuids=[str(category_uuid)], identity_id=identity_uuid
        )
        categories = participation_role_logic.get_role_categories(
            neo4j_session=session, identity_id=identity_uuid
        )

    # Find the category name from the categories list
    category = {"uuid": str(category_uuid), "name": ""}
    for cat in categories:
        if str(cat["uuid"]) == str(category_uuid):
            category["name"] = cat["name"]
            break

    roles = results[0]["roles"] if results else []

    return ParticipationRolesByCategory.model_validate(
        {
            "category": category,
            "roles": [ParticipationRole.model_validate(role) for role in roles],
        }
    )


@router.get(
    path="/{uuid}",
    operation_id="get_role_by_uuid",
    response_model=ParticipationRole,
    summary="Get participation role by uuid",
    description="Returns a participation role for a given uuid.",
)
def get_role_by_uuid(
    uuid: str,
    driver: Driver = Depends(get_neo4j_driver),
    identity_uuid: UUID = Depends(identity_uuid_from_scope),
) -> ParticipationRole:
    with neo4j_session(driver) as session:
        result = participation_role_logic.get_role_by_uuid(
            neo4j_session=session, uuid=UUID(uuid), identity_id=identity_uuid
        )

    if not result:
        raise HTTPException(status_code=404, detail="Participation role not found")

    return ParticipationRole.model_validate(result)