"""Business logic for child management."""

from datetime import datetime
from uuid import UUID, uuid4

from app.entities.child import Child
from app.repositories.child_repository import ChildRepository
from app.utils.errors import NotFoundError, ValidationError


class ChildService:
    def __init__(self, repo: ChildRepository) -> None:
        self._repo = repo

    async def create(
        self,
        workspace_id: UUID,
        name: str,
        birth_date,
        preschool_start_date=None,
        preschool_planning_days_per_year: int = 6,
    ) -> Child:
        """Create a new child."""
        if preschool_start_date is not None and preschool_start_date <= birth_date:
            raise ValidationError("preschool_start_date must be after birth_date")
        _validate_preschool_planning_days(preschool_planning_days_per_year)

        now = datetime.now()
        entity = Child(
            id=uuid4(),
            workspace_id=workspace_id,
            name=name,
            birth_date=birth_date,
            preschool_start_date=preschool_start_date,
            preschool_planning_days_per_year=preschool_planning_days_per_year,
            created_at=now,
        )
        return await self._repo.create(entity)

    async def get(self, child_id: UUID) -> Child:
        """Get a child by ID."""
        entity = await self._repo.get_by_id(child_id)
        if entity is None:
            raise NotFoundError(f"Child {child_id} not found")
        return entity

    async def list_by_workspace(self, workspace_id: UUID) -> list[Child]:
        """Get all children in a workspace."""
        return await self._repo.list_by_workspace(workspace_id)

    async def update(
        self,
        child_id: UUID,
        name: str | None = None,
        birth_date=None,
        preschool_start_date=None,
        preschool_planning_days_per_year: int | None = None,
    ) -> Child:
        """Update a child (partial update)."""
        entity = await self.get(child_id)

        if name is not None:
            entity.name = name
        if birth_date is not None:
            entity.birth_date = birth_date
        if preschool_start_date is not None:
            entity.preschool_start_date = preschool_start_date
        if preschool_planning_days_per_year is not None:
            _validate_preschool_planning_days(preschool_planning_days_per_year)
            entity.preschool_planning_days_per_year = preschool_planning_days_per_year

        # Validate after all updates
        if (
            entity.preschool_start_date is not None
            and entity.preschool_start_date <= entity.birth_date
        ):
            raise ValidationError("preschool_start_date must be after birth_date")

        return await self._repo.update(child_id, entity)

    async def delete(self, child_id: UUID) -> None:
        """Delete a child."""
        await self.get(child_id)  # raises NotFoundError if missing
        await self._repo.delete(child_id)


def _validate_preschool_planning_days(value: int) -> None:
    if not 0 <= value <= 30:
        raise ValidationError("preschool_planning_days_per_year must be between 0 and 30")