from sqlalchemy.orm import Session

from app.core.exceptions import AppError
from app.models.training import SessionOrder
from app.repositories.case_repository import CaseRepository
from app.repositories.session_repository import SessionRepository
from app.schemas.session import CreateOrderResponse, OrderItemResponse, OrderItemsResponse
from app.services.runtime_memory import runtime_memory


class OrderService:
    """检查检验服务：提供可申请项目和数据库固定结果返回。"""

    def __init__(self, db: Session) -> None:
        self.db = db
        self.case_repo = CaseRepository(db)
        self.session_repo = SessionRepository(db)

    def list_order_items(self, session_id: int, user_id: str) -> OrderItemsResponse:
        """检查项目列表：按会话病例返回可申请项目，不返回结果。"""
        session = self._get_session(session_id, user_id)
        items = self.case_repo.get_exam_items(session.case_id)
        return OrderItemsResponse(
            items=[
                OrderItemResponse(item_code=item.item_code, item_name=item.item_name, item_type=item.item_type)
                for item in items
            ]
        )

    def create_order(self, session_id: int, user_id: str, item_code: str) -> CreateOrderResponse:
        """检查申请：从数据库读取检查结果并写入当前会话记录。"""
        session = self._get_session(session_id, user_id)
        if session.status not in {"inquiry", "diagnosis", "treatment"}:
            raise AppError("SESSION_STATUS_INVALID", "current session does not allow ordering", 400)

        item = self.case_repo.get_exam_item(session.case_id, item_code)
        if not item:
            raise AppError("ORDER_ITEM_NOT_FOUND", "order item not found for current case", 404)

        existing_order = self.session_repo.get_order_by_item(session.id, item.item_code)
        if existing_order:
            return self._to_response(existing_order, already_ordered=True)

        order = self.session_repo.create_order(
            SessionOrder(
                session_id=session.id,
                user_id=user_id,
                case_id=session.case_id,
                case_exam_item_id=item.id,
                item_code=item.item_code,
                item_name=item.item_name,
                item_type=item.item_type,
                result_text=item.result_text,
                result_structured=item.result_structured,
                is_key=item.is_key,
                is_abnormal=item.is_abnormal,
            )
        )
        runtime_memory.add_message(
            session.memory_key or "",
            "tool",
            f"申请检查/检验：{order.item_name}。结果：{order.result_text}",
            {"item_code": order.item_code, "result_structured": order.result_structured},
        )
        return self._to_response(order, already_ordered=False)

    def _to_response(self, order: SessionOrder, already_ordered: bool) -> CreateOrderResponse:
        """检查响应：统一把会话检查记录转换为接口返回结构。"""
        return CreateOrderResponse(
            item_code=order.item_code,
            item_name=order.item_name,
            item_type=order.item_type,
            result_text=order.result_text,
            result_structured=order.result_structured,
            is_key=order.is_key,
            is_abnormal=order.is_abnormal,
            context_written=True,
            already_ordered=already_ordered,
        )

    def _get_session(self, session_id: int, user_id: str):
        """会话校验：确认检查申请属于当前用户会话。"""
        session = self.session_repo.get_owned_session(session_id, user_id)
        if not session:
            raise AppError("SESSION_NOT_FOUND", "session not found or not owned by current user", 404)
        return session