"""FAQ 조회 + 승인(검증 상태 전이)."""
import uuid

from fastapi import Depends

from common.database.db_session_manager import DB_SESSION_MNG
from common.database.model.models import place_faqs, places
from common.enums import (
    CANDIDATE_FACT_STATUSES,
    FACT_STATUS_TRANSITIONS,
    PUBLISHABLE_FACT_STATUSES,
    DBWRType,
    ErrorType,
    FactStatus,
    SourceType,
)
from common.logger import LOG
from common.models.gmodel import UserInfo
from common.utils.gtime import GTime
from crud.faq_crud import FaqCRUD, IFaqCRUD
from crud.place_crud import PlaceCRUD
from router.v1.faq.protocol import FaqData, Req_CreateFaq, Req_TransitionFaq, Res_Faq, Res_FaqList


class FaqService:
    def __init__(self, crud: IFaqCRUD = Depends(FaqCRUD), place_crud: PlaceCRUD = Depends(PlaceCRUD)):
        self.crud = crud
        self.place_crud = place_crud

    # 사업장 로드(사장님 스코프)
    async def _load_place(self, user_info: UserInfo, place_id: str):
        """owner_user_id 를 WHERE 에 걸어 조회한다 — 남의 place_id 를 넣으면 PLACE_NOT_FOUND."""
        err_type, place = await DB_SESSION_MNG.execute_lambda(
            places.DBType(),
            DBWRType.DB_READ.value,
            lambda s: self.place_crud.get_place(s, uuid.UUID(user_info.user_id), uuid.UUID(place_id)),
        )
        if err_type != ErrorType.SUCCESS:
            return ErrorType.PLACE_NOT_FOUND, None
        return ErrorType.SUCCESS, place

    async def _mark_content_updated(self, place_id: str, ts):
        err = await DB_SESSION_MNG.execute_lambda_run([places.DBType()], [lambda s: self._touch(s, place_id, ts)])
        if err != ErrorType.SUCCESS:
            LOG.e_no_callstack(f"[faq] content_updated_at 갱신 실패 place={place_id}")

    async def _touch(self, s, place_id: str, ts):
        from sqlalchemy import update

        query = update(places).where(places.place_id == uuid.UUID(place_id)).values(content_updated_at=ts, updated_at=ts)
        return await DB_SESSION_MNG.add(s, query)

    async def _reload(self, res: Res_Faq, pid, faq_id) -> Res_Faq:
        _e, row = await DB_SESSION_MNG.execute_lambda(
            place_faqs.DBType(),
            DBWRType.DB_READ.value,
            lambda s: self.crud.get_faq(s, pid, faq_id),
        )
        res.faq = FaqData.model_validate(row) if row is not None else None
        return res

    # 조회
    async def list_faqs(self, user_info: UserInfo, place_id: str, publishable_only: bool = False) -> Res_FaqList:
        """publishable_only=True → ★ 사이트에 나갈 수 있는 것만(빌드가 보는 것과 같은 집합)."""
        res = Res_FaqList()
        err_type, _place = await self._load_place(user_info, place_id)
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
            return res

        pid = uuid.UUID(place_id)
        list_err, rows = await DB_SESSION_MNG.execute_lambda(
            place_faqs.DBType(),
            DBWRType.DB_READ.value,
            lambda s: self.crud.list_faqs(s, pid, publishable_only),
        )
        if list_err != ErrorType.SUCCESS:
            res.result.SetResult(list_err)
            return res

        res.faqs = [FaqData.model_validate(r) for r in rows]
        res.publishable = sum(1 for r in rows if FactStatus(r.status) in PUBLISHABLE_FACT_STATUSES)
        res.pending_review = sum(1 for r in rows if FactStatus(r.status) in CANDIDATE_FACT_STATUSES)
        return res

    # 직접 추가
    async def create_faq(self, user_info: UserInfo, place_id: str, req: Req_CreateFaq) -> Res_Faq:
        """사장님이 직접 쓴 FAQ 를 넣는다 — fact 의 owner 입력과 같은 철학으로 바로 노출값(VERIFIED)이 된다."""
        res = Res_Faq()
        err_type, _place = await self._load_place(user_info, place_id)
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
            return res

        question = (req.question or "").strip()
        answer = (req.answer or "").strip()
        if not question or not answer:
            # 빈 문답은 사이트에 렌더도 안 되고 고유 콘텐츠로도 안 세진다 — 애초에 받지 않는다.
            res.result.SetResult(ErrorType.INVALID_REQUEST_DATA)
            return res

        pid = uuid.UUID(place_id)
        sort_order = req.sort_order
        if sort_order is None:
            # 순서를 안 주면 맨 뒤에 붙인다 — 기존 FAQ 사이에 끼어들어 순서를 흔들지 않게.
            _e, rows = await DB_SESSION_MNG.execute_lambda(
                place_faqs.DBType(),
                DBWRType.DB_READ.value,
                lambda s: self.crud.list_faqs(s, pid, False),
            )
            sort_order = max((r.sort_order for r in rows), default=-1) + 1

        row = place_faqs(
            place_id=pid,
            question=question,
            answer=answer,
            generated_by=SourceType.OWNER.value,
            status=FactStatus.VERIFIED.value,
            sort_order=sort_order,
        )
        run_err = await DB_SESSION_MNG.execute_lambda_run([place_faqs.DBType()], [lambda s: self.crud.add_faq(s, row)])
        if run_err != ErrorType.SUCCESS:
            res.result.SetResult(run_err)
            return res

        await self._mark_content_updated(place_id, GTime.UTC())
        return await self._reload(res, pid, row.faq_id)

    # 검증 상태 전이(승인 · 정정 · 반려)
    async def transition(self, user_info: UserInfo, place_id: str, faq_id: str, req: Req_TransitionFaq) -> Res_Faq:
        """생성된 FAQ 를 승인하거나, 문구를 고쳐 승인하거나, 반려한다."""
        res = Res_Faq()
        err_type, _place = await self._load_place(user_info, place_id)
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
            return res

        pid = uuid.UUID(place_id)
        fid = uuid.UUID(faq_id)
        get_err, faq = await DB_SESSION_MNG.execute_lambda(
            place_faqs.DBType(),
            DBWRType.DB_READ.value,
            lambda s: self.crud.get_faq(s, pid, fid),
        )
        if get_err != ErrorType.SUCCESS:
            res.result.SetResult(ErrorType.FAQ_NOT_FOUND)
            return res

        current = FactStatus(faq.status)
        target = req.status
        if target not in FACT_STATUS_TRANSITIONS.get(current, set()):
            res.result.SetResult(ErrorType.FACT_INVALID_TRANSITION)
            return res

        data: dict = {}
        if target == FactStatus.CORRECTED:
            question = (req.question or "").strip()
            answer = (req.answer or "").strip()
            if not question and not answer:
                # '정정'인데 고친 문구가 없으면 그냥 승인(VERIFIED)이어야 한다 — 잠금만 얻는 길을 막는다.
                res.result.SetResult(ErrorType.INVALID_REQUEST_DATA)
                return res
            if question:
                data["question"] = question
            if answer:
                data["answer"] = answer
            data["generated_by"] = SourceType.OWNER.value

        now = GTime.UTC()
        run_err = await DB_SESSION_MNG.execute_lambda_run(
            [place_faqs.DBType()],
            [lambda s: self._transition_ok(s, fid, current, target, data)],
        )
        if run_err != ErrorType.SUCCESS:
            res.result.SetResult(ErrorType.FACT_INVALID_TRANSITION if run_err == ErrorType.DB_EMPTY_DATA else run_err)
            return res

        # 노출 집합이 바뀌는 전이(승격 / 정정 / 노출값 내림)면 재빌드 대상으로 표시한다.
        if target in PUBLISHABLE_FACT_STATUSES or current in PUBLISHABLE_FACT_STATUSES:
            await self._mark_content_updated(place_id, now)
        return await self._reload(res, pid, fid)

    async def _transition_ok(self, s, fid, current: FactStatus, target: FactStatus, data: dict):
        """출발 상태를 WHERE 에 걸어 조건부로만 바꾼다(동시 처리 가드)."""
        err_type, rowcount = await self.crud.transition(s, fid, (current.value,), target.value, data)
        if err_type != ErrorType.SUCCESS:
            return err_type
        return ErrorType.SUCCESS if rowcount else ErrorType.DB_EMPTY_DATA