from sqlalchemy.orm import joinedload

from models import Deal, CardStatusHistory, Board
from repositories.base import BaseRepository
from repositories.mixins import *
from schemas.base import SortDir
from schemas.deal import UpdateDealSchema, CreateDealSchema
from utils.sorting import apply_sorting


class DealRepository(
    BaseRepository,
    RepDeleteMixin[Deal],
    RepCreateMixin[Deal, CreateDealSchema],
    RepUpdateMixin[Deal, UpdateDealSchema],
    RepGetByIdMixin[Deal],
):
    entity_class = Deal

    async def get_all(
        self,
        page: Optional[int],
        items_per_page: Optional[int],
        field: Optional[str],
        direction: Optional[SortDir],
        project_id: Optional[int],
        board_id: Optional[int],
        status_id: Optional[int],
        id: Optional[int],
        name: Optional[str],
    ) -> tuple[list[Deal], int]:
        stmt = (
            select(Deal)
            .options(joinedload(Deal.status), joinedload(Deal.board))
            .where(Deal.is_deleted.is_(False))
        )

        if id:
            stmt = stmt.where(Deal.id == id)
        if project_id:
            stmt = stmt.join(Board).where(Board.project_id == project_id)
        if board_id:
            stmt = stmt.where(Deal.board_id == board_id)
        if status_id:
            stmt = stmt.where(Deal.status_id == status_id)
        if name:
            stmt = stmt.where(Deal.name.ilike(f"%{name}%"))

        total_items = len((await self.session.execute(stmt)).all())

        if field and direction is not None:
            stmt = apply_sorting(stmt, Deal, field, direction)
        else:
            stmt = stmt.order_by(Deal.lexorank)

        if page and items_per_page:
            stmt = self._apply_pagination(stmt, page, items_per_page)

        result = await self.session.execute(stmt)
        return list(result.scalars().all()), total_items

    def _process_get_by_id_stmt(self, stmt: Select) -> Select:
        return stmt.options(joinedload(Deal.status), joinedload(Deal.board))

    async def update(self, deal: Deal, data: UpdateDealSchema) -> Deal:
        fields = ["lexorank", "name", "board_id"]
        deal = await self._apply_update_data_to_model(deal, data, False, fields)

        if data.status_id and deal.status_id != data.status_id:
            deal.status_history.append(
                CardStatusHistory(
                    from_status_id=deal.status_id,
                    to_status_id=data.status_id,
                )
            )
            deal.status_id = data.status_id

        self.session.add(deal)
        await self.session.commit()
        await self.session.refresh(deal)
        return deal