"""SQLite implementation of ChildRepository."""

from datetime import date, datetime
from uuid import UUID

import aiosqlite

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


class SQLiteChildRepository(ChildRepository):
    def __init__(self, connection: aiosqlite.Connection) -> None:
        self._conn = connection

    @staticmethod
    def _row_to_entity(row: aiosqlite.Row) -> Child:
        return Child(
            id=UUID(row["id"]),
            workspace_id=UUID(row["workspace_id"]),
            name=row["name"],
            birth_date=date.fromisoformat(row["birth_date"]),
            preschool_start_date=(
                date.fromisoformat(row["preschool_start_date"])
                if row["preschool_start_date"]
                else None
            ),
            created_at=datetime.fromisoformat(row["created_at"]),
        )

    async def create(self, item: Child) -> Child:
        item.created_at = item.created_at or datetime.now()
        await self._conn.execute(
            """
            INSERT INTO child (id, workspace_id, name, birth_date, preschool_start_date, created_at)
            VALUES (?, ?, ?, ?, ?, ?)
            """,
            (
                str(item.id),
                str(item.workspace_id),
                item.name,
                item.birth_date.isoformat(),
                item.preschool_start_date.isoformat() if item.preschool_start_date else None,
                item.created_at.isoformat(),
            ),
        )
        await self._conn.commit()
        return item

    async def get_by_id(self, id: UUID) -> Child | None:
        cursor = await self._conn.execute("SELECT * FROM child WHERE id = ?", (str(id),))
        row = await cursor.fetchone()
        return self._row_to_entity(row) if row else None

    async def update(self, id: UUID, item: Child) -> Child:
        cursor = await self._conn.execute(
            """
            UPDATE child
               SET name = ?, birth_date = ?, preschool_start_date = ?
             WHERE id = ?
            """,
            (
                item.name,
                item.birth_date.isoformat(),
                item.preschool_start_date.isoformat() if item.preschool_start_date else None,
                str(id),
            ),
        )
        await self._conn.commit()
        if cursor.rowcount == 0:
            raise NotFoundError(f"Child {id} not found")
        refreshed = await self.get_by_id(id)
        assert refreshed is not None
        return refreshed

    async def delete(self, id: UUID) -> None:
        cursor = await self._conn.execute("DELETE FROM child WHERE id = ?", (str(id),))
        await self._conn.commit()
        if cursor.rowcount == 0:
            raise NotFoundError(f"Child {id} not found")

    async def list(self, **filters: object) -> list[Child]:
        clauses: list[str] = []
        params: list[object] = []
        if "workspace_id" in filters and filters["workspace_id"] is not None:
            clauses.append("workspace_id = ?")
            params.append(str(filters["workspace_id"]))
        where = f" WHERE {' AND '.join(clauses)}" if clauses else ""
        cursor = await self._conn.execute(
            f"SELECT * FROM child{where} ORDER BY birth_date ASC", params
        )
        rows = await cursor.fetchall()
        return [self._row_to_entity(r) for r in rows]

    async def list_by_workspace(self, workspace_id: UUID) -> list[Child]:
        return await self.list(workspace_id=workspace_id)