from typing import Any, Dict, cast
from langchain.prompts import PromptTemplate
from _utils.langchain_utils.LLM_class import LLM
from _utils.gerar_relatorio_modelo_usuario.utils import (
    get_full_text_and_all_PDFs_chunks,
)
from _utils.langchain_utils.Prompt_class import Prompt
from _utils.utils import print_sentry, sentry_add_breadcrumb
from setup.easy_imports import (
    Response,
    AsyncAPIView,
    APIView,
    MultiPartParser,
    extend_schema,
)
from datetime import datetime
from _utils.handle_files import handle_pdf_files_from_serializer, remove_pdf_temp_files
from _utils.gerar_documento import (
    gerar_documento,
)
from _utils.gerar_relatorio_modelo_usuario.prompts import prompt_auxiliar_inicio
from setup.logging import Axiom, send_axiom
from .serializer import (
    GerarDocumentoComPDFProprioSerializer,
    GerarDocumentoSerializer,
    GerarEmentaSerializer,
)
import asyncio
from _utils.langchain_utils.Splitter_class import Splitter


class GerarDocumentoView(AsyncAPIView):
    # parser_classes = [MultiPartParser]
    serializer = {}
    axiom_instance = Axiom()

    @extend_schema(
        request=GerarDocumentoSerializer,
    )
    async def post(self, request):
        self.axiom_instance.generate_new_uuid()
        print(f"\n\nDATA E HORA DA REQUISIÇÃO: {datetime.now()}")
        self.axiom_instance.send_axiom("COMEÇOU NOVA REQUISIÇÃO")
        self.axiom_instance.send_axiom(f"request.data: {request.data}")
        serializer = GerarDocumentoSerializer(data=request.data)
        if serializer.is_valid(raise_exception=True):
            obj = serializer.get_obj()  # type: ignore
            if not serializer.validated_data:
                raise ValueError("Erro no validated_data")

            async def proccess_data_after_response():
                # await asyncio.sleep(0)
                data = cast(Dict[str, Any], serializer.validated_data)
                self.serializer = data

                listaPDFs = [l["link_arquivo"] for l in data["files"]]

                self.axiom_instance.send_axiom(f"listaPDFs: {listaPDFs}")

                resposta_llm = await gerar_documento(
                    obj, listaPDFs, self.axiom_instance, isBubble=True
                )
                self.axiom_instance.send_axiom(f"resposta_llm: {resposta_llm}")

                # remove_pdf_temp_files(listaPDFs)

            # asyncio.create_task(proccess_data_after_response())
            loop = asyncio.get_running_loop()
            loop.run_in_executor(
                None, lambda: asyncio.run(proccess_data_after_response())
            )

            return Response(
                {"resposta": "Requisição está sendo processada em segundo plano"}
            )


class GerarDocumentoComPDFProprioView(AsyncAPIView):
    parser_classes = [MultiPartParser]
    serializer = {}
    axiom_instance = Axiom()

    @extend_schema(
        request=GerarDocumentoComPDFProprioSerializer,
    )
    async def post(self, request):
        self.axiom_instance.generate_new_uuid()
        print(f"\n\nDATA E HORA DA REQUISIÇÃO: {datetime.now()}")
        self.axiom_instance.send_axiom("COMEÇOU NOVA REQUISIÇÃO")
        self.axiom_instance.send_axiom(f"request.data: {request.data}")
        serializer = GerarDocumentoComPDFProprioSerializer(data=request.data)

        if serializer.is_valid(raise_exception=True):
            data = cast(Dict[str, Any], serializer.validated_data)
            obj = serializer.get_obj()  # type: ignore
            self.serializer = data

            listaPDFs = handle_pdf_files_from_serializer(
                data["files"], self.axiom_instance
            )

            resposta_llm = await gerar_documento(obj, listaPDFs, self.axiom_instance)
            self.axiom_instance.send_axiom(f"resposta_llm: {resposta_llm}")

            remove_pdf_temp_files(listaPDFs)
            self.axiom_instance.send_axiom(
                "PRÓXIMA LINHA ENVIA A RESPOSTA A QUEM FEZ A REQUISIÇÃO"
            )
            return Response({"resposta": resposta_llm})


class GerarEmentaView(AsyncAPIView):
    serializer = {}

    @extend_schema(
        request=GerarDocumentoSerializer,
    )
    async def post(self, request):
        print(f"\n\nDATA E HORA DA REQUISIÇÃO: {datetime.now()}")
        print("request.data: ", request.data)
        serializer = GerarEmentaSerializer(data=request.data)
        if serializer.is_valid(raise_exception=True):
            if not serializer.validated_data:
                raise ValueError("Erro no validated_data")

            async def proccess_data_after_response():
                data = cast(Dict[str, Any], serializer.validated_data)
                self.serializer = data

                listaPDFs = [l["link_arquivo"] for l in data["files"]]
                print("\n\nlistaPDFs: ", listaPDFs)

                all_PDFs_chunks, full_text_as_array = (
                    await get_full_text_and_all_PDFs_chunks(
                        listaPDFs,
                        Splitter(data["chunk_size"], data["chunk_overlap"]),
                        False,
                        True,
                    )
                )
                full_text = "".join(full_text_as_array)

                llm = LLM()
                prompt_template = PromptTemplate(
                    input_variables=["context"], template=full_text
                )
                response = await llm.google_gemini().ainvoke(
                    prompt_template.format(context=full_text)
                )

                print("\n\nresposta_llm: ", response.content)

            # asyncio.create_task(proccess_data_after_response())
            loop = asyncio.get_running_loop()
            loop.run_in_executor(
                None, lambda: asyncio.run(proccess_data_after_response())
            )

            return Response(
                {"resposta": "Requisição está sendo processada em segundo plano"}
            )


class GerarEmentaComPDFProprioView(AsyncAPIView):
    parser_classes = [MultiPartParser]
    serializer = {}

    @extend_schema(
        request=GerarDocumentoComPDFProprioSerializer,
    )
    async def post(self, request):
        print(f"\n\nDATA E HORA DA REQUISIÇÃO: {datetime.now()}")
        serializer = GerarDocumentoComPDFProprioSerializer(data=request.data)
        if serializer.is_valid(raise_exception=True):
            data = cast(Dict[str, Any], serializer.validated_data)
            print("\n\ndata: ", data)
            self.serializer = data

            data = cast(Dict[str, Any], serializer.validated_data)
            self.serializer = data

            listaPDFs = [l["link_arquivo"] for l in data["files"]]
            print("\n\nlistaPDFs: ", listaPDFs)

            all_PDFs_chunks, full_text_as_array = (
                await get_full_text_and_all_PDFs_chunks(
                    listaPDFs,
                    Splitter(data["chunk_size"], data["chunk_overlap"]),
                    False,
                    True,
                )
            )
            full_text = "".join(full_text_as_array)

            llm = LLM()
            prompt_template = PromptTemplate(
                input_variables=["context"], template=full_text
            )
            response = await llm.google_gemini().ainvoke(
                prompt_template.format(context=full_text)
            )

            print("\n\nresposta_llm: ", response.content)

            remove_pdf_temp_files(listaPDFs)
            print("PRÓXIMA LINHA ENVIA A RESPOSTA A QUEM FEZ A REQUISIÇÃO")
            return Response({"resposta": response.content})