"""Business logic for day overrides.

The service owns rules; the repository only persists. Routers call services,
not repositories directly. Mirrors VacationDaysService's upsert-by-natural-key
shape: a workspace has at most one override per date.
"""

from datetime import date, datetime
from uuid import UUID, uuid4

from app.entities.day_override import DayOverride
from app.repositories.day_override_repository import DayOverrideRepository
from app.utils.errors import NotFoundError, ValidationError


class DayOverrideService:
    def __init__(self, repo: DayOverrideRepository) -> None:
        self._repo = repo

    async def upsert(
        self,
        workspace_id: UUID,
        day: date,
        is_working_day: bool,
        note: str | None = None,
    ) -> DayOverride:
        """Create or update the (workspace, date) override.

        A service should not trust its caller even though the schema also
        guards the note length.
        """
        if note is not None and len(note) > 280:
            raise ValidationError("Day override note cannot exceed 280 characters")

        existing = await self._repo.get_by_workspace_date(workspace_id, day)
        if existing is not None:
            existing.is_working_day = is_working_day
            existing.note = note
            return await self._repo.update(existing.id, existing)

        entity = DayOverride(
            id=uuid4(),
            workspace_id=workspace_id,
            date=day,
            is_working_day=is_working_day,
            note=note,
            created_at=datetime.now(),
            updated_at=datetime.now(),
        )
        return await self._repo.create(entity)

    async def get(self, day_override_id: UUID, workspace_id: UUID | None = None) -> DayOverride:
        entity = await self._repo.get_by_id(day_override_id)
        if entity is None or (workspace_id is not None and entity.workspace_id != workspace_id):
            raise NotFoundError(f"DayOverride {day_override_id} not found")
        return entity

    async def list_for_workspace(self, workspace_id: UUID) -> list[DayOverride]:
        return await self._repo.list_by_workspace(workspace_id)

    async def delete(self, day_override_id: UUID, workspace_id: UUID | None = None) -> None:
        await self.get(day_override_id, workspace_id)  # raises NotFoundError if missing/foreign
        await self._repo.delete(day_override_id)

    async def get_effective_map(self, workspace_id: UUID) -> dict[date, bool]:
        """Return {date: is_working_day} for every override in a workspace.

        This is the shape `AllocationInputLoader` feeds into
        `AllocationInput.day_overrides` — see
        `app.services.allocation_service.is_free_day` for the single place
        it's merged with the calendar.
        """
        overrides = await self._repo.list_by_workspace(workspace_id)
        return {o.date: o.is_working_day for o in overrides}