from fastapi import FastAPI ,File, UploadFile,Form
from pydantic import BaseModel
from typing import List,Optional
from components.mongoconnection import provideClient
from components.checkaccountexists import checkAccount
from components.filechecker import checkFile
from components.getproblems import GetProblems
from components.getdeep import GetDeepDive
from components.getbreakdown import GetBreakdown



from components.legal_points_agent import LegalKeyPoints
from components.legal_deepdive_agent import LegalDeepDive
from components.legal_breakdown_agent import LegalBreakdown


from components.medical_points_agent import MedicalKeyPoints
from components.medical_deepdive_agent import MedicalDeepDive
from components.medical_breakdown_agent import MedicalBreakdown



from components.research_deepdive_agent import ResearchDeepDive
from components.research_points_agent import ResearchKeyPoints
from components.research_breakdown_agent import ResearchBreakdown


from fastapi.middleware.cors import CORSMiddleware
from PyPDF2 import PdfReader
import io
import time

origins=[
    "http://localhost:3000",
    "https://askmydocs-three.vercel.app"
]


app = FastAPI()
app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)



mclient=provideClient()

db=mclient["askmydoc_db"]
coll=db["askmydoc_col"]

class Item(BaseModel):
    owner:str

class Item2(BaseModel):
    owner: str
    filetype:str

class QAI(BaseModel):
    owner:str
    files:List[str]
    question:str
    msg_type:str

class QA2(BaseModel):
    owner:str
    files:List[str]

class QA3(BaseModel):
     owner:str
     msg_type:str


class QA4(BaseModel):
    owner:str
    msg_type:str
    files:List[str]
     

@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.post("/setupaccount")
def create_item(data: Item):
    print(data.owner)
    payload={

          "owner":data.owner,
          "app_id":"askmydoc_v1",
          "files":[],
          "keypoints":[],
          "deepdive":[],
          "breakdown":[]

    }
    inserted=coll.insert_one(payload)
    if inserted.inserted_id:
        return {"status":True}
    else:

        return {"status":False}

        

@app.post("/checkaccount")
def checkaccount(data:Item):
    status=checkAccount(data.owner)
    print(data)
    if status==True:
        return {'status':True}
    else:
        return {"status":False}




    
    

@app.post("/checkfile")
def checkfileexistence(data:Item2):
    filechecksresponse=checkFile(data.owner,data.filetype)
    return filechecksresponse


    



@app.post("/checkproblems")
def checkProblems(data:QA4):
     problems=GetProblems(data.owner,data.msg_type,data.files)
     return problems    



    


@app.post("/checkdive")
def checkProblems(data:QA4):
     DIVE=GetDeepDive(data.owner,data.msg_type,data.files)
     return DIVE





@app.post("/checkbreakdown")
def checkProblems(data:QA4):
     DIVE=GetBreakdown(data.owner,data.msg_type,files=data.files)
     return DIVE




@app.post("/upload-files")
async def upload_files(
    files: List[UploadFile] = File(...),
    owner: Optional[str] = Form(None),
    filetype:Optional[str]=Form(None)
    ):


    MAX_FILE_SIZE = 5 * 1024 * 1024 
    results = []
    if len(files) > 2:
        return {"error":"maximum 2 files allowed"}
    try:
        for file in files:
            contents = await file.read()
            if len(contents) > MAX_FILE_SIZE:
                return {
                    "error": f"File '{file.filename}' exceeds 5MB limit",
                    "max_size": "5MB"
            }
            file_info = {
                "filename": file.filename,
                "content_type": file.content_type,
                "size": len(contents),
                "filetype":filetype
            }
            if file.content_type == "text/plain":
                # Decode text files - now we can safely return full content
                text_content = contents.decode("utf-8")
                file_info["content"] = text_content  # Full content since we have size limit
            elif file.content_type == "application/pdf":
            # Extract text from PDF
                try:
                    pdf_file = io.BytesIO(contents)
                    pdf_reader = PdfReader(pdf_file)
                    text_content = ""
                    for page in pdf_reader.pages:
                        text_content += page.extract_text() + "\n"
                        file_info["content"] = text_content
                        file_info["pages"] = len(pdf_reader.pages)
                except Exception as e:
                        file_info["error"] = f"Failed to read PDF: {str(e)}"

    
        results.append(file_info)
        coll.update_one(
                {"owner": owner},
                {"$push": {"files": {"$each": results}}}
        )
       

        return {"status":True}
    except Exception as e:
        return {"status":False}




    
@app.post("/legalproblems")
def LegalProblems(data:QA2):
    documents=coll.find_one({"owner":data.owner})
    print(data)
    content=[]
    if documents:
         
        checkifalreadypresent=GetProblems(data.owner,"legal",data.files)

        
        if len(checkifalreadypresent["problems"]) !=0:
             return checkifalreadypresent["problems"]
        
        for file in documents["files"]:
            if file["filename"] in data.files:
                content_payload=f"""
                
                FILENAME :{file["filename"]}
                CONTENT : {file["content"]}
            """
                content.append(content_payload)
                problems=LegalKeyPoints(content=content)
                payload={"type":"legal","problems":problems,"files":data.files}
            
                coll.update_one(
                    {"owner": data.owner},
                    {"$push": {"keypoints": payload}}
                )

                return {"problems":problems}
    else:            

                return {"problems":None}
    


@app.post("/legaldeepdive")
def LegalDDive(data:QA2):
    documents=coll.find_one({"owner":data.owner})
    content=[]
    if documents:

        checkifalreadypresent=GetDeepDive(data.owner,"legal",data.files)

        
        if len(checkifalreadypresent["dive"]) !=0:
             return checkifalreadypresent["dive"]
        
        for file in documents["files"]:
            if file["filename"] in data.files:
                content_payload=f"""
                
                FILENAME :{file["filename"]}
                CONTENT : {file["content"]}
            """
                content.append(content_payload)
                dive=LegalDeepDive(content=content)
                payload={"type":"legal","dive":dive,"files":data.files}
            
                coll.update_one(
                    {"owner": data.owner},
                    {"$push": {"deepdive": payload}}
                )
                return {"deepdive":dive}
    else:            

                return {"deepdive":None}






@app.post("/legalbreakdown")
def LegalB(data:QA2):
    documents=coll.find_one({"owner":data.owner})
    print(data)
    content=[]
    if documents:

        checkifalreadypresent=GetBreakdown(data.owner,"legal",data.files)


        if len(checkifalreadypresent["breakdown"])!=0:
             return checkifalreadypresent["breakdown"]

        for file in documents["files"]:
            if file["filename"] in data.files:
                content_payload=f"""
                
                FILENAME :{file["filename"]}
                CONTENT : {file["content"]}
            """
                content.append(content_payload)
                breakdown=LegalBreakdown(content=content)
                payload={"type":"legal","breakdown":breakdown,"files":data.files}
            
                coll.update_one(
                    {"owner": data.owner},
                    {"$push": {"breakdown": payload}}
                )

                return {"problems":breakdown}
    else:            

                return {"problems":None}






@app.post("/medicalproblems")
def MedicalProblems(data:QA2):
    documents=coll.find_one({"owner":data.owner})
    content=[]
    if documents:

        checkifalreadypresent=GetProblems(data.owner,"medical",data.files)

        
        if len(checkifalreadypresent["problems"]) !=0:
             return checkifalreadypresent["problems"]
        
        for file in documents["files"]:
            if file["filename"] in data.files:
                content_payload=f"""
                
                FILENAME :{file["filename"]}
                CONTENT : {file["content"]}
            """
                content.append(content_payload)
                problems=MedicalKeyPoints(content=content)
                payload={"type":"medical","problems":problems,"files":data.files}
            
                coll.update_one(
                    {"owner": data.owner},
                    {"$push": {"keypoints": payload}}
                )

                return {"problems":problems}
    else:            

                return {"problems":None}




@app.post("/medicaldeepdive")
def MedicalDDive(data:QA2):
    documents=coll.find_one({"owner":data.owner})
    content=[]
    if documents:

        checkifalreadypresent=GetDeepDive(data.owner,"medical",data.files)

        
        if len(checkifalreadypresent["dive"]) !=0:
             return checkifalreadypresent["dive"]
        
        for file in documents["files"]:
            if file["filename"] in data.files:
                content_payload=f"""
                
                FILENAME :{file["filename"]}
                CONTENT : {file["content"]}
            """
                content.append(content_payload)
                dive=MedicalDeepDive(content=content)
                payload={"type":"medical","dive":dive,"files":data.files}
            
                coll.update_one(
                    {"owner": data.owner},
                    {"$push": {"deepdive": payload}}
                )

                return {"deepdive":dive}
    else:            

                return {"deepdive":None}




@app.post("/medicalbreakdown")
def MedicalB(data:QA2):
    documents=coll.find_one({"owner":data.owner})
    print(data)
    content=[]
    if documents:

        checkifalreadypresent=GetBreakdown(data.owner,"medical",data.files)

        
        if len(checkifalreadypresent["breakdown"]) !=0:
             return checkifalreadypresent["breakdown"]



        for file in documents["files"]:
            if file["filename"] in data.files:
                content_payload=f"""
                
                FILENAME :{file["filename"]}
                CONTENT : {file["content"]}
            """
                content.append(content_payload)
                breakdown=MedicalBreakdown(content=content)
                payload={"type":"medical","breakdown":breakdown,"files":data.files}
            
                coll.update_one(
                    {"owner": data.owner},
                    {"$push": {"breakdown": payload}}
                )

                return {"problems":breakdown}
    else:            

                return {"problems":None}





@app.post("/researchproblems")
def ResearchProblems(data:QA2):
    documents=coll.find_one({"owner":data.owner})
    content=[]
    if documents:

        checkifalreadypresent=GetProblems(data.owner,"research",data.files)

        
        if len(checkifalreadypresent["problems"])!=0:
             return checkifalreadypresent["problems"]
        
        for file in documents["files"]:
            if file["filename"] in data.files:
                content_payload=f"""
                
                FILENAME :{file["filename"]}
                CONTENT : {file["content"]}
            """
                content.append(content_payload)
                problems=ResearchKeyPoints(content=content)
                payload={"type":"research","problems":problems,"files":data.files}
            
                coll.update_one(
                    {"owner": data.owner},
                    {"$push": {"keypoints": payload}}
                )

                return {"problems":problems}
    else:            

                return {"problems":None}




@app.post("/researchbreakdown")
def ResearchB(data:QA2):
    documents=coll.find_one({"owner":data.owner})
    print(data)
    content=[]
    if documents:


        checkifalreadypresent=GetBreakdown(data.owner,"research",data.files)

        
        if len(checkifalreadypresent["breakdown"]) !=0:
             return checkifalreadypresent["breakdown"]

        for file in documents["files"]:
            if file["filename"] in data.files:
                content_payload=f"""
                
                FILENAME :{file["filename"]}
                CONTENT : {file["content"]}
            """
                content.append(content_payload)
                breakdown=ResearchBreakdown(content=content)
                payload={"type":"research","breakdown":breakdown,"files":data.files}
            
                coll.update_one(
                    {"owner": data.owner},
                    {"$push": {"breakdown": payload}}
                )

                return {"problems":breakdown}
    else:            

                return {"problems":None}


@app.post("/researchdeepdive")
def ResearchDDive(data:QA2):
    documents=coll.find_one({"owner":data.owner})
    content=[]
    if documents:



        checkifalreadypresent=GetDeepDive(data.owner,"research",data.files)

        
        if len(checkifalreadypresent["dive"]) !=0:
             return checkifalreadypresent["dive"]
        
        for file in documents["files"]:
            if file["filename"] in data.files:
                content_payload=f"""
                
                FILENAME :{file["filename"]}
                CONTENT : {file["content"]}
            """
                content.append(content_payload)
                dive=ResearchDeepDive(content=content)
                payload={"type":"research","dive":dive,"files":data.files}
            
                coll.update_one(
                    {"owner": data.owner},
                    {"$push": {"deepdive": payload}}
                )

                return {"deepdive":dive}
    else:            

                return {"deepdive":None}