"""Business logic for break periods (family home-together windows)."""

from datetime import datetime
from uuid import UUID, uuid4

from app.entities.break_period import BreakPeriod
from app.repositories.break_period_repository import BreakPeriodRepository
from app.utils.errors import NotFoundError, ValidationError


class BreakPeriodService:
    def __init__(self, repo: BreakPeriodRepository) -> None:
        self._repo = repo

    async def create(
        self,
        workspace_id: UUID,
        name: str,
        start_date: object,
        end_date: object,
        target_weeks: int,
    ) -> BreakPeriod:
        if end_date < start_date:
            raise ValidationError("end_date must be on or after start_date")
        now = datetime.now()
        entity = BreakPeriod(
            id=uuid4(),
            workspace_id=workspace_id,
            name=name,
            start_date=start_date,
            end_date=end_date,
            target_weeks=target_weeks,
            created_at=now,
            updated_at=now,
        )
        return await self._repo.create(entity)

    async def get(self, break_period_id: UUID) -> BreakPeriod:
        entity = await self._repo.get_by_id(break_period_id)
        if entity is None:
            raise NotFoundError(f"BreakPeriod {break_period_id} not found")
        return entity

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

    async def update(
        self,
        break_period_id: UUID,
        name: str,
        start_date: object,
        end_date: object,
        target_weeks: int,
    ) -> BreakPeriod:
        entity = await self.get(break_period_id)
        if end_date < start_date:
            raise ValidationError("end_date must be on or after start_date")
        entity.name = name
        entity.start_date = start_date
        entity.end_date = end_date
        entity.target_weeks = target_weeks
        entity.updated_at = datetime.now()
        return await self._repo.update(break_period_id, entity)

    async def delete(self, break_period_id: UUID) -> None:
        await self.get(break_period_id)  # raises NotFoundError if missing
        await self._repo.delete(break_period_id)