from fastapi import FastAPI, HTTPException,UploadFile,File,Request
from pydantic import BaseModel
from deep_translator import GoogleTranslator
from fastapi.responses import JSONResponse
from fastapi.middleware.cors import CORSMiddleware
import os
from text import fitness_role
# from main import process,audio_process
from dotenv import load_dotenv
import base64
from pathlib import Path
from process import Response
import uuid
from utils.summary import Summary
load_dotenv()
# Create the FastAPI app instance
os.makedirs("/tmp/huggingface_cache", exist_ok=True)
os.environ["HF_HOME"] = "/tmp/huggingface_cache"

app = FastAPI()

# Allow all CORS (for local testing)
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)
uploaded_docs = {}

class UploadRequest(BaseModel):
    filename: str
    filedata: str

class ChatRequest(BaseModel):
    session_id: str
    message: str

class ChatBot(BaseModel):
    text :str
    token:str

# Root endpoint
@app.get("/")
async def home():
    return {"message": "Test ok"}

# Token verification function
def verify_token(token: str):
    print("token: ",token)
    if token != os.getenv("TOKEN"):
        raise HTTPException(status_code=401, detail="Token not matched") 

# Translate endpoint that accepts a query parameter 'text'
# @app.get("/translate")
# async def translate(text: str = "", token: str = ""):
#     if not text or not token:
#         raise HTTPException(status_code=400, detail="No text or token provided")
#     verify_token(token)
#     translator = GoogleTranslator(source="auto", target="mr")
#     result = translator.translate(text)

#     return {"result": result}


@app.post("/chatbot")
async def chatbot(req:ChatBot):
    try:
        query = req.text
        token = req.token
        # print("query : ",query)
        if not query or not token:
            raise HTTPException(status_code=400, detail="No text provided")
        verify_token(token=token)
        res = Response().chatbot(query=query)
        # print("Chatbot resp :- ", res)
        return {"result":res}
    except Exception as e:
        print(e)

@app.post("/fitnessbot")
async def fitnessbot(req:ChatBot):
    try:
        query = req.text
        token = req.token
        # print("query : ",query)
        if not query or not token:
            raise HTTPException(status_code=400, detail="No text provided")
        verify_token(token=token)
        res = Response().other_chatbot(query=query,role = fitness_role)
        # print("Chatbot resp :- ", res)
        return {"result":res}
    except Exception as e:
        print(e)


# @app.get("/chatbot")
# async def chatbot(text: str = "", token: str = ""):
#     if not text or not token:
#         raise HTTPException(status_code=400, detail="No text provided")
#     verify_token(token)
#     print("User_input :- ",text)
#     result = process(user_query=text)
#     return {"result": result}



@app.post("/audio_chat")
async def audio_chat(audio: UploadFile = File(...), token: str = ""):
    if not audio or not token:
        raise HTTPException(status_code=400, detail="No audio file provided")
    verify_token(token)
    try:
        result = audio_process(audio.file)  # Replace with actual audio processing logic
        return {"result": result}
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")


# Request model
UPLOAD_DIR = "uploads"
Path(UPLOAD_DIR).mkdir(parents=True, exist_ok=True)

class FileUploadRequest(BaseModel):
    token: str
    filename: str
    content_type: str
    base64_file: str

@app.post("/summarizer")
async def upload_base64(file_data: FileUploadRequest):
    try:
        file_path = os.path.join(os.getcwd(),UPLOAD_DIR, file_data.filename)

        with open(file_path, "wb") as f:
            f.write(base64.b64decode(file_data.base64_file))
        if file_data.content_type == "application/pdf":
            doc = Summary().load_doc(doc_path=file_path)
            chunks,size = Summary().doc_chunk(docs_path=doc)
            summary = Summary().get_summary(document=chunks,len_document=size)
            print(summary)
            return {"text":summary}
        else:
            return {"text":f"{file_data.content_type} not supported"}
    except Exception as e:
        import traceback
        traceback.print_exc()  # 🔥 Show full error in terminal
        raise HTTPException(status_code=500, detail=str(e))
    finally :
        if file_path:
            os.remove(file_path)

    
## RAG Chatbot
@app.post("/upload")
async def upload_file(req: UploadRequest):
    session_id = str(uuid.uuid4())
    decoded_data = base64.b64decode(req.filedata)
    # Save to disk or memory (or pass to RAG pipeline)
    uploaded_docs[session_id] = decoded_data
    print(session_id)
    return {"success": True, "session_id": session_id}

@app.post("/chat")
async def chat(req: ChatRequest):
    pdf_data = uploaded_docs.get(req.session_id)
    if not pdf_data:
        return {"reply": "Session not found."}

    # TODO: RAG logic here (e.g., extract text, run through embedding + LLM)
    dummy_answer = f" Nice Mocked answer for: '{req.message}'"
    return {"reply": dummy_answer}