Model/infrastructure/postgres/magic_plan_tables.py

from __future__ import annotations

from typing import ClassVar, Optional

from sqlmodel import Field, SQLModel

from domain.magicplan.models import (
    Door,
    DoorVentilation,
    Floor,
    Plan,
    Room,
    Window,
    WindowVentilation,
)


class MagicPlanPlanModel(SQLModel, table=True):
    __tablename__: ClassVar[str] = "magic_plan_plan"  # pyright: ignore[reportIncompatibleVariableOverride]

    id: Optional[int] = Field(default=None, primary_key=True)
    magic_plan_uid: Optional[str] = Field(default=None, unique=True, index=True)
    name: Optional[str] = None
    address: Optional[str] = None
    postcode: Optional[str] = None
    uploaded_file_id: Optional[int] = Field(default=None)

    @classmethod
    def from_domain(cls, plan: Plan, uploaded_file_id: int) -> "MagicPlanPlanModel":
        return cls(
            magic_plan_uid=plan.uid,
            name=plan.name,
            address=plan.address,
            postcode=plan.postcode,
            uploaded_file_id=uploaded_file_id,
        )


class MagicPlanFloorModel(SQLModel, table=True):
    __tablename__: ClassVar[str] = "magic_plan_floor"  # pyright: ignore[reportIncompatibleVariableOverride]

    id: Optional[int] = Field(default=None, primary_key=True)
    magic_plan_plan_id: int = Field(foreign_key="magic_plan_plan.id")
    level: Optional[int] = None

    @classmethod
    def from_domain(cls, floor: Floor, plan_id: int) -> "MagicPlanFloorModel":
        return cls(magic_plan_plan_id=plan_id, level=floor.level)


class MagicPlanRoomModel(SQLModel, table=True):
    __tablename__: ClassVar[str] = "magic_plan_room"  # pyright: ignore[reportIncompatibleVariableOverride]

    id: Optional[int] = Field(default=None, primary_key=True)
    magic_plan_floor_id: int = Field(foreign_key="magic_plan_floor.id")
    name: Optional[str] = None
    width_m: Optional[float] = None
    length_m: Optional[float] = None
    area_m2: Optional[float] = None

    @classmethod
    def from_domain(cls, room: Room, floor_id: int) -> "MagicPlanRoomModel":
        return cls(
            magic_plan_floor_id=floor_id,
            name=room.name,
            width_m=room.width_m,
            length_m=room.length_m,
            area_m2=room.area_m2,
        )


class MagicPlanWindowModel(SQLModel, table=True):
    __tablename__: ClassVar[str] = "magic_plan_window"  # pyright: ignore[reportIncompatibleVariableOverride]

    id: Optional[int] = Field(default=None, primary_key=True)
    magic_plan_room_id: int = Field(foreign_key="magic_plan_room.id")
    width_m: Optional[float] = None
    height_m: Optional[float] = None
    area_m2: Optional[float] = None
    opening_type: Optional[str] = None

    @classmethod
    def from_domain(cls, window: Window, room_id: int) -> "MagicPlanWindowModel":
        return cls(
            magic_plan_room_id=room_id,
            width_m=window.width_m,
            height_m=window.height_m,
            area_m2=window.area_m2,
            opening_type=window.opening_type,
        )


class MagicPlanDoorModel(SQLModel, table=True):
    __tablename__: ClassVar[str] = "magic_plan_door"  # pyright: ignore[reportIncompatibleVariableOverride]

    id: Optional[int] = Field(default=None, primary_key=True)
    magic_plan_room_id: int = Field(foreign_key="magic_plan_room.id")
    width_mm: Optional[float] = None
    height_mm: Optional[float] = None
    type: Optional[str] = None

    @classmethod
    def from_domain(cls, door: Door, room_id: int) -> "MagicPlanDoorModel":
        return cls(magic_plan_room_id=room_id, width_mm=door.width_mm, height_mm=door.height_mm)


class MagicPlanWindowVentilationModel(SQLModel, table=True):
    __tablename__: ClassVar[str] = "magic_plan_window_ventilation"  # pyright: ignore[reportIncompatibleVariableOverride]

    id: Optional[int] = Field(default=None, primary_key=True)
    magic_plan_window_id: int = Field(foreign_key="magic_plan_window.id")
    opening_type: Optional[str] = None
    num_openings: Optional[int] = None
    pct_openable: Optional[int] = None
    trickle_vent_area_mm2: Optional[int] = None
    num_trickle_vents: Optional[int] = None

    @classmethod
    def from_domain(
        cls, ventilation: WindowVentilation, window_id: int
    ) -> "MagicPlanWindowVentilationModel":
        return cls(
            magic_plan_window_id=window_id,
            opening_type=ventilation.opening_type,
            num_openings=ventilation.num_openings,
            pct_openable=ventilation.pct_openable,
            trickle_vent_area_mm2=ventilation.trickle_vent_area_mm2,
            num_trickle_vents=ventilation.num_trickle_vents,
        )


class MagicPlanDoorVentilationModel(SQLModel, table=True):
    __tablename__: ClassVar[str] = "magic_plan_door_ventilation"  # pyright: ignore[reportIncompatibleVariableOverride]

    id: Optional[int] = Field(default=None, primary_key=True)
    magic_plan_door_id: int = Field(foreign_key="magic_plan_door.id")
    undercut_mm: Optional[float] = None

    @classmethod
    def from_domain(
        cls, ventilation: DoorVentilation, door_id: int
    ) -> "MagicPlanDoorVentilationModel":
        return cls(
            magic_plan_door_id=door_id,
            undercut_mm=ventilation.undercut_mm,
        )