#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from typing import Sequence

from sqlalchemy import select, or_, and_
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy_crud_plus import CRUDPlus

from app.call_center.schema.mismatch_records import GetMismatchRecordsByIdParam, CreateMismatchRecordsParam, \
    UpdateMismatchRecordsParam
from model.mismatch_records import MismatchRecords


class CRUDMismatchRecords(CRUDPlus[MismatchRecords]):
    async def get(self, db: AsyncSession, obj_in: GetMismatchRecordsByIdParam) -> MismatchRecords | None:
        """
        获取call record

        :param db:
        :param obj_in:
        :return:
        """
        mismatch_records = None
        if obj_in.internal_id:
            mismatch_records = await self.select_model_by_column(db, id=obj_in.internal_id, org_id=obj_in.org_id)
        elif obj_in.external_id:
            mismatch_records = await self.select_model_by_column(db, external_id=obj_in.external_id, org_id=obj_in.org_id)
        return mismatch_records

    async def get_earliest_record(self, db: AsyncSession, limit: int = 1) -> Sequence[MismatchRecords] | None:
        """
        获取最早的 llm_intent 不为空的记录

        :param db:
        :return:
        """
        stmt = select(self.model).where(or_(and_(MismatchRecords.ignore == 0, MismatchRecords.llm_ignore == 0), and_(MismatchRecords.ignore == 2, MismatchRecords.user_intent == None))).order_by(MismatchRecords.created_at.asc()).limit(limit)
        query = await db.execute(stmt)
        return query.scalars().fetchall()

    async def create(self, db: AsyncSession, obj_in: CreateMismatchRecordsParam) -> None:
        """
        创建call record

        :param db:
        :param obj_in:
        :return:
        """
        await self.create_model(db, obj_in)

    async def update_ignore(self, db: AsyncSession, obj_in: UpdateMismatchRecordsParam) -> int:
        """
        更新call record

        :param db:
        :param obj_in:
        :return:
        """
        if obj_in.internal_id:
            return await self.update_model_by_column(db, {'ignore': obj_in.ignore}, id=obj_in.internal_id)
        else:
            return await self.update_model_by_column(db, {'ignore': obj_in.ignore}, external_id=obj_in.external_id)

    async def update_llm_ignore(self, db: AsyncSession, internal_id: str, llm_ignore: int, response_data: dict, status: int) -> int:
        """
        更新call record

        :param db:
        :param internal_id:
        :param llm_ignore:
        :param response_data:
        :param status:
        :return:
        """

        return await self.update_model_by_column(db, {'llm_ignore': llm_ignore, 'ignore_response_data': response_data, 'status': status}, id=internal_id)

    async def update(self, db: AsyncSession, internal_id: str, llm_ignore: int, user_intent: str, similar_reply: list[str], keywords: list[str], regular: list[str], request_data: dict, response_data: dict, status: int, ignore_response_data: dict | None) -> int:
        """
        更新call record

        :param db:
        :param internal_id:
        :param llm_ignore:
        :param user_intent:
        :param similar_reply:
        :param keywords:
        :param regular:
        :param request_data:
        :param response_data:
        :param status:
        :param ignore_response_data:
        :return:
        """
        if ignore_response_data:
            return await self.update_model_by_column(db, {'llm_ignore': llm_ignore, 'user_intent': user_intent, 'similar_reply': similar_reply, 'keywords': keywords, 'regular': regular, 'request_data': request_data, 'response_data': response_data, 'status': status, 'ignore_response_data': ignore_response_data}, id=internal_id)
        else:
            return await self.update_model_by_column(db, {'llm_ignore': llm_ignore, 'user_intent': user_intent, 'similar_reply': similar_reply, 'keywords': keywords, 'regular': regular, 'request_data': request_data, 'response_data': response_data, 'status': status}, id=internal_id)


mismatch_records_dao: CRUDMismatchRecords = CRUDMismatchRecords(MismatchRecords)