from datetime import datetime, timezone
from typing import List

from sqlalchemy.orm import Session

from src.domain.entities.kw_capping import KWCappingRecord
from src.domain.interfaces.kw_capping_repository import KWCappingRepositoryInterface
from src.infrastructure.models.kw_capping_model import KWCappingModel


def _to_entity(model: KWCappingModel) -> KWCappingRecord:
    return KWCappingRecord(
        id=model.id,
        kw=model.KW,
        max_approved_value=model.max_approved_value,
    )


class SqlKWCappingRepository(KWCappingRepositoryInterface):
    """SQLAlchemy implementation of KWCappingRepositoryInterface."""

    def __init__(self, db: Session) -> None:
        self.db = db

    def list_all(self) -> List[KWCappingRecord]:
        rows = (
            self.db.query(KWCappingModel)
            .filter(KWCappingModel.deleted_at.is_(None))
            .order_by(KWCappingModel.KW.asc())
            .all()
        )
        return [_to_entity(r) for r in rows]

    def bulk_update(
        self,
        updates: List[KWCappingRecord],
        user_id: int,
    ) -> List[KWCappingRecord]:
        now = datetime.now(timezone.utc)
        result: List[KWCappingRecord] = []

        for record in updates:
            row = (
                self.db.query(KWCappingModel)
                .filter(
                    KWCappingModel.KW == record.kw,
                    KWCappingModel.deleted_at.is_(None),
                )
                .first()
            )
            if row is None:
                continue  # skip unknown KW tiers — no new tiers are created here
            row.max_approved_value = record.max_approved_value
            row.updated_by = user_id
            row.updated_at = now
            result.append(_to_entity(row))

        self.db.commit()
        return result