#import gradio as gr
from faiss import write_index, read_index
from langchain.vectorstores import FAISS
from typing import List
from pydantic import BaseModel
from typing import Optional
import re
from pathlib import Path
import time
from anthropic import Anthropic, HUMAN_PROMPT, AI_PROMPT
import json
import pandas as pd
import sqlite3
from sentence_transformers import SentenceTransformer
from fastapi import FastAPI
from unidecode import unidecode
from nltk.corpus import stopwords
from langchain.schema.embeddings import Embeddings
from langchain.document_loaders import DataFrameLoader
from general import FinderDbs,loadCopysAndData,loadmodelEmb,makeFaissdb,extractConfig,Response,remove_unwanted
#from langchain import PromptTemplate
# from langchain.document_loaders import TextLoader
# from langchain.text_splitter import CharacterTextSplitter
# from langchain.text_splitter import RecursiveCharacterTextSplitter
# from langchain.document_loaders import UnstructuredFileLoader
# from langchain.document_loaders.recursive_url_loader import RecursiveUrlLoader
# from langchain.document_loaders import UnstructuredURLLoader
# from langchain.document_loaders.csv_loader import CSVLoader
# #from langchain import  LLMChain
# from langchain.embeddings import HuggingFaceEmbeddings
#from cleantext import clean





class CustomEmbedding(Embeddings, BaseModel):
    """embedding model with preprocessing"""
    def _get_embedding(self,text) -> List[float]:
        #print(text,"text")
        text=remove_unwanted(text,punctuationOK=True,stopOK=True)
        Sal=emb.encode(text)
        return Sal
    def embed_documents(self, texts: List[str]) -> List[List[float]]:
        Sal=[]
        for text in texts:
            Sal.append(self._get_embedding(text))
        return Sal
    def embed_query(self, text: str) -> List[float]:
        return self._get_embedding(text)

nameModel="Modelo_embedding_CIDITEL"  
model=extractConfig(nameModel=nameModel,dataOut="path_model")+"/model"
print(model)
entrenamiento="V1.3"
pathsqlite=extractConfig(nameModel=nameModel,dataOut="pathsqlite")
keyanthropic=extractConfig(nameModel="SystemData",dataOut="keyantrophics")
documents,documents2=loadCopysAndData(pathsqlite)
emb=loadmodelEmb(model_name = model)
emb2=CustomEmbedding()
db=makeFaissdb(documents,"Copies3",emb2)
db2=makeFaissdb(documents2,"Intentionality3",emb2)

app = FastAPI()
@app.get("/")
def read_main():
    return {"message": "This is your main app"}
@app.post("/angela-api/")
def calculate_api(response: Response):
    query = response.query
    try:
        filtred = response.filtred
    except:
        filtred = -9.0
    AllData=FinderDbs(query,[db2,db],filtred)
    #print(AllData)
    versionL="_".join([model,entrenamiento])
    #tt=time.time()
    #if identifier.classify(query)[1]< 0.3:
        #print(identifier.classify(query))
        #print(time.time()-tt)
        #return {"ids": [],"DC":[],"modelo":versionL}
    #print(time.time()-tt)
    if AllData:
        AllData = list(AllData)
        dis=[]
        id=[]
        for k,i in enumerate(AllData[0].items()):
            dis.append(str(i[1]['d']))
            id.append(i[0])
    return {"ids": id,"DC":dis,"modelo":versionL}

@app.post("/angela-api-claude/")
def calculate_api_claude(response: Response):
    anthropic = Anthropic(api_key=keyanthropic)
    query = response.query
    try:
        filtred = response.filtred
    except:
        filtred = -9.0
    
    AllData=FinderDbs(query,[db2,db],filtred)
    versionL="_".join([model,entrenamiento])
    if AllData:
        AllData = list(AllData)
        dis=[]
        id=[]
        for k,i in enumerate(AllData[0].items()):
            dis.append(str(i[1]['d']))
            id.append(i[0])
    if len(id)<1:
        return {"text": {"completion": "No tengo información sobre este tema",
    "model": "claude-2.1",
    "stop_reason": "stop_sequence",
    "type": "completion",
    "id": "1",
    "stop": "\n\nHuman:",
    "log_id": "1"
  },"text2": {
    "completion":"No tengo información sobre este tema",
    "model": "claude-2.1",
    "stop_reason": "stop_sequence",
    "type": "completion",
    "id": "1",
    "stop": "\n\nHuman:",
    "log_id": "1"
    }
    }
    con = sqlite3.connect(pathsqlite)
    copies_df = pd.read_sql_query("SELECT * from copies WHERE intentionality IS NOT NULL", con)
    copie = copies_df[copies_df["id"]==id[0]]["copy_message"].values[0]
    promptF=f"""{HUMAN_PROMPT} Tengo un contexto  por favor generame un resumen, el resumen deben ser con lenguaje amable para un publico mexicano y como si fuera una conversacion con la persona.
    """
    promptF3=promptF+f"""
<contexto>%s</contexto>
{AI_PROMPT}<resumen>"""%(copie)
    completion = anthropic.completions.create(
                model="claude-2",
                max_tokens_to_sample=600,
                prompt=promptF3,
    )

    pregunta=query
    promptFv2=f"""Tu eres un asistente de IA en chatbot llamado Angela, como asistente tu labor es  ayudar a los usuarios de la pagina web de la alcaldia de puebla respondiendo sus preguntas.
Aqui te dare las reglas que debes seguir durante la conversacion:
<reglas>
- Siempre te mantendras en el personaje Angela.
- Si no estas seguro de la respuesta basada en el contexto responde el suigiente texto: "Lo siento, podrias formular la pregunta de nuevo es que no entendi tu pregunta por que soy un sistema que esta en mejora en este momento".
- No menciones el contexto si la pregunta no puede ser contestada con el.
- Siempres responderas de manera amable pero formal.
</reglas>
<contexto>
%s
</contexto>
{HUMAN_PROMPT} Tengo la siguiente pregunta entre la etiqueta <pregunta></pregunta> y basandote en el contexto que esta en la etiqueta <contexto></contexto> responde la pregunta entre la etiqueta <respuesta></respuesta>:
<pregunta>
%s
</pregunta>
"""%(copie,pregunta)

    promptF3v2=promptFv2+f"""
{AI_PROMPT}<respuesta>"""
    completionv2 = anthropic.completions.create(
                model="claude-2.1",
                max_tokens_to_sample=600,
                prompt=promptF3v2,
    )
    return {"text":completion,"text2":completionv2}