from server.apps.core.api.views import GetAPIView, PostAPIView
from server.apps.core.api.operation_ids import OperationIds
from server.apps.core.dataclasses.api_data import URLParams
from server.apps.core.dataclasses.request_ctx import RequestCtx
from server.apps.core.decorators.api import api_get, api_post

from server.apps.my_app.public.dataclasses import RequestData, ResponseData
from server.apps.my_app.public.services import MyAppService


class MyEntityAPI(GetAPIView[ParamType, ResponseType], PostAPIView[RequestType, ParamType, ResponseType]):
    """
    API dedicated to my entity operations.
    Each API class should have a clear responsibility and documentation.
    """

    @api_get(
        operation_id=OperationIds.MY_APP.value.GET_MY_ENTITY,
        response=ResponseData,
        description="Gets my entity data.",
        parameters=ParamType,
    )
    def get(
        self,
        *,
        url_params: URLParams,
        ctx: RequestCtx,
        param_data: ParamType,
    ) -> ResponseData:
        """
        GET request implementation with clear documentation.
        """
        return MyAppService.get_entity(
            ctx=ctx,
            entity_id=url_params["entity_id"],
            include_details=param_data.include_details,
        )

    @api_post(
        operation_id=OperationIds.MY_APP.value.CREATE_MY_ENTITY,
        request=RequestData,
        response=ResponseData,
        description="Creates a new entity.",
    )
    def post(
        self,
        *,
        url_params: URLParams,
        ctx: RequestCtx,
        request_data: RequestData,
        param_data: ParamType,
    ) -> ResponseData:
        """
        POST request to create an entity.
        """
        return MyAppService.create_entity(
            ctx=ctx,
            parent_id=url_params["parent_id"],
            entity_data=request_data,
        )

@api_get(
    operation_id=OperationIds.MY_APP.value.GET_ENTITY,  # Unique operation ID
    response=ResponseData,                               # Response dataclass
    description="Gets entity details.",                  # OpenAPI description
    parameters=ParamType,                                # Query parameter dataclass
)

# server/apps/core/api/operation_ids.py
class MyAppOperationIds(StrEnum):
    GET_MY_ENTITY = "getMyEntity"
    CREATE_MY_ENTITY = "createMyEntity"
    UPDATE_MY_ENTITY = "updateMyEntity"
    DELETE_MY_ENTITY = "deleteMyEntity"

@dataclass
class RequestCtx:
    customer_id: MUUID        # Current customer/tenant
    user_id: MUUID            # Authenticated user
    request_source: RequestSource  # Frontend, API, etc.
    feature_flags: list[str]  # Active feature flags
    # ... other context

def get(self, *, url_params: URLParams, ctx: RequestCtx, ...):
    entity_id = url_params["entity_id"]  # From URL path

# api/helpers/build_response.py
def build_entity_response(
    *,
    ctx: RequestCtx,
    entity_data: EntityData,
    include_details: bool,
) -> EntityResponse:
    """
    Builds a standardized entity response.
    Helper functions should have clear purpose and documentation.
    """
    response = EntityResponse(
        id=entity_data.id,
        name=entity_data.name,
        # ... base fields
    )
    
    if include_details:
        response.details = get_entity_details(ctx=ctx, entity_id=entity_data.id)
    
    return response

# api/dataclasses.py
from dataclasses import dataclass
from typing import Optional
from server.apps.core.types.muuid import MUUID

@dataclass
class GetEntityParams:
    """Query parameters for getting an entity."""
    include_details: bool = False
    include_history: bool = False

@dataclass
class CreateEntityRequest:
    """Request body for creating an entity."""
    name: str
    description: str = ""
    parent_id: Optional[MUUID] = None

@dataclass
class EntityResponse:
    """Response for entity endpoints."""
    id: MUUID
    name: str
    description: str
    created_at: datetime

@pytest.mark.django_db
class TestMyEntityAPI:
    @pytest.fixture
    def view(self):
        return MyEntityAPI.as_view()

    @pytest.fixture
    def mock_service(self, mocker):
        return mocker.patch("server.apps.my_app.api.my_entity.MyAppService")

    def test_get(
        self,
        mock_service,
        ctx_no_db,
        view,
        request_factory,
    ):
        # Arrange
        entity_id = MUUID("ENTY_00000000000000000000001")
        mock_service.get_entity.return_value = EntityResponse(
            id=entity_id, 
            name="Test"
        )
        request = request_factory.get(f"/api/entities/{entity_id}/")
        
        # Act
        response = view(request, entity_id=str(entity_id))
        
        # Assert
        assert response.status_code == 200
        response_data = json.loads(response.content)
        assert response_data["id"] == str(entity_id)
        mock_service.get_entity.assert_called_once()