import uuid

from fastapi import Depends

from common.database.db_session_manager import DB_SESSION_MNG
from common.database.model.models import nego_cards, wild_cards
from common.enums import CardStatus, DBWRType, ErrorType
from common.models.gmodel import PageParams
from crud.card_crud import ICardCRUD, CardCRUD
from router.v1.card.protocol import CardData, Res_Card, Res_CardList, Res_DeleteCard


class CardService:
    """협상카드 비즈니스 로직. nego_cards/wild_cards 두 테이블을 user_id 로 스코프하고
    프론트용 단일 모델(CardData, is_wildcard 플래그)로 합친다."""

    def __init__(self, card_crud: ICardCRUD = Depends(CardCRUD)):
        self.card_crud = card_crud

    # ---- 행 → 통합 CardData --------------------------------------------------
    @staticmethod
    def _nego_to_data(row) -> CardData:
        # 일반 협상카드는 상태 개념이 없다(상시 적용) → ACTIVE 고정.
        return CardData(
            nego_card_id=row.nego_card_id,
            user_id=row.user_id,
            is_wildcard=False,
            name=row.name,
            number=row.number,
            script=row.script,
            edit_script=row.edit_script,
            status=CardStatus.ACTIVE.value,
            created_at=row.created_at,
            updated_at=row.updated_at,
        )

    @staticmethod
    def _wild_to_data(row) -> CardData:
        # 와일드카드 적용 여부(available) → status(ACTIVE/INACTIVE) 매핑.
        return CardData(
            nego_card_id=row.wild_card_id,
            user_id=row.user_id,
            is_wildcard=True,
            name=row.name,
            number=row.number,
            script=row.script,
            edit_script=row.edit_script,
            status=CardStatus.ACTIVE.value if row.available else CardStatus.INACTIVE.value,
            condition=row.condition,
            memo=row.memo,
            created_at=row.created_at,
            updated_at=row.updated_at,
        )

    # ---- 소유 카드 탐색(어느 테이블인지 모를 때) ------------------------------
    async def _find_owned(self, user_uuid: uuid.UUID, card_id: uuid.UUID):
        """card_id 를 nego_cards → wild_cards 순으로 찾고 소유권 확인.
        (ErrorType, model, pk_col, row, is_wildcard) 반환."""
        err, row = await DB_SESSION_MNG.execute_lambda(
            nego_cards.DBType(),
            DBWRType.DB_READ.value,
            lambda s: self.card_crud.get_by_id(s, nego_cards, nego_cards.nego_card_id, card_id),
        )
        if err == ErrorType.SUCCESS and row is not None:
            if row.user_id != user_uuid:
                return ErrorType.CARD_NOT_FOUND, None, None, None, False
            return ErrorType.SUCCESS, nego_cards, nego_cards.nego_card_id, row, False

        err, row = await DB_SESSION_MNG.execute_lambda(
            wild_cards.DBType(),
            DBWRType.DB_READ.value,
            lambda s: self.card_crud.get_by_id(s, wild_cards, wild_cards.wild_card_id, card_id),
        )
        if err == ErrorType.SUCCESS and row is not None:
            if row.user_id != user_uuid:
                return ErrorType.CARD_NOT_FOUND, None, None, None, True
            return ErrorType.SUCCESS, wild_cards, wild_cards.wild_card_id, row, True

        return ErrorType.CARD_NOT_FOUND, None, None, None, False

    # ---- 목록 ----------------------------------------------------------------
    async def list_cards(self, user_id: str, search, pg: PageParams) -> Res_CardList:
        res = Res_CardList(page=pg.page, size=pg.size)
        if not user_id:
            return res
        user_uuid = uuid.UUID(user_id)
        # 합쳐서 정렬/페이징하므로 각 테이블에서 skip+limit 까지 받아온다(카드 수가 적어 충분).
        fetch = pg.skip + pg.size

        err_n, nego_rows, total_n = await DB_SESSION_MNG.execute_lambda(
            nego_cards.DBType(),
            DBWRType.DB_READ.value,
            lambda s: self.card_crud.search(s, nego_cards, user_uuid, search, 0, fetch),
        )
        if err_n != ErrorType.SUCCESS:
            res.result.SetResult(err_n)
            return res

        err_w, wild_rows, total_w = await DB_SESSION_MNG.execute_lambda(
            wild_cards.DBType(),
            DBWRType.DB_READ.value,
            lambda s: self.card_crud.search(s, wild_cards, user_uuid, search, 0, fetch),
        )
        if err_w != ErrorType.SUCCESS:
            res.result.SetResult(err_w)
            return res

        merged = [self._nego_to_data(r) for r in nego_rows] + [self._wild_to_data(r) for r in wild_rows]
        merged.sort(key=lambda c: c.created_at or "", reverse=True)
        res.cards = merged[pg.skip : pg.skip + pg.size]
        res.total = total_n + total_w
        return res

    # ---- 단건 조회 -----------------------------------------------------------
    async def get_card(self, user_id: str, card_id: str) -> Res_Card:
        res = Res_Card()
        err, _model, _pk, row, is_wild = await self._find_owned(uuid.UUID(user_id), uuid.UUID(card_id))
        if err != ErrorType.SUCCESS:
            res.result.SetResult(err)
            return res
        res.card = self._wild_to_data(row) if is_wild else self._nego_to_data(row)
        return res

    # ---- 등록 ----------------------------------------------------------------
    async def create_card(self, user_id: str, data: dict) -> Res_Card:
        res = Res_Card()
        user_uuid = uuid.UUID(user_id)
        is_wildcard = bool(data.get("is_wildcard", False))

        common = dict(
            user_id=user_uuid,
            name=data.get("name"),
            number=data.get("number"),
            script=data.get("script"),
            edit_script=data.get("edit_script"),
        )
        if is_wildcard:
            card = wild_cards(
                **common,
                condition=data.get("condition"),
                available=(data.get("status", CardStatus.ACTIVE.value) == CardStatus.ACTIVE.value),
                memo=data.get("memo"),
            )
            model, pk_attr = wild_cards, "wild_card_id"
        else:
            card = nego_cards(**common)
            model, pk_attr = nego_cards, "nego_card_id"

        err = await DB_SESSION_MNG.execute_lambda_run(
            [model.DBType()],
            [lambda s: self.card_crud.add(s, card)],
        )
        if err != ErrorType.SUCCESS:
            res.result.SetResult(err)
            return res
        # 서버 기본값(created_at 등)은 insert 후 객체에 실리지 않으므로 재조회.
        return await self.get_card(user_id, str(getattr(card, pk_attr)))

    # ---- 수정 ----------------------------------------------------------------
    async def update_card(self, user_id: str, card_id: str, data: dict) -> Res_Card:
        res = Res_Card()
        user_uuid = uuid.UUID(user_id)
        card_uuid = uuid.UUID(card_id)

        err, model, pk_col, _row, is_wild = await self._find_owned(user_uuid, card_uuid)
        if err != ErrorType.SUCCESS:
            res.result.SetResult(err)
            return res

        # 해당 테이블에 있는 컬럼만 추린다(없는 필드는 무시). status → available(와일드 전용).
        allowed = {"name", "number", "script", "edit_script"}
        if is_wild:
            allowed |= {"condition", "memo"}
        payload = {k: v for k, v in data.items() if k in allowed}
        if is_wild and "status" in data and data["status"] is not None:
            payload["available"] = data["status"] == CardStatus.ACTIVE.value

        err = await DB_SESSION_MNG.execute_lambda_run(
            [model.DBType()],
            [lambda s: self.card_crud.update(s, model, pk_col, card_uuid, payload)],
        )
        if err != ErrorType.SUCCESS:
            res.result.SetResult(err)
            return res
        return await self.get_card(user_id, card_id)

    # ---- 삭제(soft) ----------------------------------------------------------
    async def delete_card(self, user_id: str, card_id: str) -> Res_DeleteCard:
        res = Res_DeleteCard()
        user_uuid = uuid.UUID(user_id)
        card_uuid = uuid.UUID(card_id)

        err, model, pk_col, _row, _is_wild = await self._find_owned(user_uuid, card_uuid)
        if err != ErrorType.SUCCESS:
            res.result.SetResult(err)
            return res

        err = await DB_SESSION_MNG.execute_lambda_run(
            [model.DBType()],
            [lambda s: self.card_crud.soft_delete(s, model, pk_col, card_uuid)],
        )
        if err != ErrorType.SUCCESS:
            res.result.SetResult(err)
        return res