from typing import Annotated, Sequence
from uuid import UUID
from fastapi import APIRouter, Depends, status
from sqlalchemy.ext.asyncio import AsyncSession
from apps.api.dependencies import get_current_user
from core.exceptions import ForbiddenError, TenantAccessError
from infrastructure.database.session import get_db
from modules.identity.models import User
from modules.tenants.schemas import (
    TenantCreateRequest,
    TenantUpdateRequest,
    TenantResponse,
    TenantMemberResponse,
)
from modules.tenants.service import TenantService
from shared.schemas import ApiResponse

router = APIRouter(prefix="/tenants", tags=["Tenants & Workspaces"])


@router.post("", response_model=ApiResponse[TenantResponse], status_code=status.HTTP_201_CREATED)
async def create_tenant(
    req: TenantCreateRequest,
    current_user: Annotated[User, Depends(get_current_user)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    service = TenantService(db)
    tenant = await service.create_tenant(current_user.id, req)
    return ApiResponse(
        message="Workspace created successfully",
        data=TenantResponse.model_validate(tenant),
    )


@router.get("", response_model=ApiResponse[list[TenantResponse]], status_code=status.HTTP_200_OK)
async def list_user_tenants(
    current_user: Annotated[User, Depends(get_current_user)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    service = TenantService(db)
    tenants = await service.get_user_tenants(current_user.id)
    return ApiResponse(
        message="User workspaces retrieved",
        data=[TenantResponse.model_validate(t) for t in tenants],
    )


@router.get("/{tenant_id}", response_model=ApiResponse[TenantResponse], status_code=status.HTTP_200_OK)
async def get_tenant_details(
    tenant_id: UUID,
    current_user: Annotated[User, Depends(get_current_user)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    service = TenantService(db)
    if not current_user.is_superuser:
        await service.verify_member_access(tenant_id, current_user.id)
    tenant = await service.get_tenant_by_id(tenant_id)
    return ApiResponse(
        message="Workspace details",
        data=TenantResponse.model_validate(tenant),
    )


@router.patch("/{tenant_id}", response_model=ApiResponse[TenantResponse], status_code=status.HTTP_200_OK)
async def update_tenant(
    tenant_id: UUID,
    req: TenantUpdateRequest,
    current_user: Annotated[User, Depends(get_current_user)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    service = TenantService(db)
    if not current_user.is_superuser:
        member = await service.verify_member_access(tenant_id, current_user.id)
        if member.role not in ("owner", "admin"):
            raise ForbiddenError("Only workspace owners or admins can update settings")
    tenant = await service.update_tenant(tenant_id, req)
    return ApiResponse(
        message="Workspace updated successfully",
        data=TenantResponse.model_validate(tenant),
    )


@router.get("/{tenant_id}/members", response_model=ApiResponse[list[TenantMemberResponse]], status_code=status.HTTP_200_OK)
async def get_members(
    tenant_id: UUID,
    current_user: Annotated[User, Depends(get_current_user)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    service = TenantService(db)
    if not current_user.is_superuser:
        await service.verify_member_access(tenant_id, current_user.id)
    members = await service.get_tenant_members(tenant_id)
    return ApiResponse(
        message="Workspace members list",
        data=[TenantMemberResponse.model_validate(m) for m in members],
    )


@router.delete("/{tenant_id}/members/{user_id}", response_model=ApiResponse[None], status_code=status.HTTP_200_OK)
async def remove_member(
    tenant_id: UUID,
    user_id: UUID,
    current_user: Annotated[User, Depends(get_current_user)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    service = TenantService(db)
    requester_role = "owner"
    if not current_user.is_superuser:
        member = await service.verify_member_access(tenant_id, current_user.id)
        requester_role = member.role
    await service.remove_member(tenant_id, user_id, requester_role)
    return ApiResponse(
        message="Member removed from workspace",
        data=None,
    )
