import gradio as gr
import requests
from fpdf import FPDF
import pdfplumber

# Mistral API key (replace with your key)
API_KEY = "gz6lDXokxgR6cLY72oomALWcm7vhjzQ"
MISTRAL_API_URL = "https://api.mistral.ai/v1/chat/completions"

# Function to call Mistral API
def call_mistral_api(prompt):
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    payload = {
        "model": "mistral-medium",
        "messages": [
            {"role": "user", "content": prompt}
        ]
    }
    response = requests.post(MISTRAL_API_URL, headers=headers, json=payload)
    if response.status_code == 200:
        return response.json()['choices'][0]['message']['content']
    else:
        return f"Error: {response.status_code}, {response.text}"

# Function to analyze a single requirement
def analyze_requirement(requirement):
    # Detect requirement type
    type_prompt = f"Classify the following requirement as Functional or Non-Functional:\n\n{requirement}\n\nType:"
    req_type = call_mistral_api(type_prompt)

    # Identify stakeholders
    stakeholders_prompt = f"Identify the stakeholders for the following requirement:\n\n{requirement}\n\nStakeholders:"
    stakeholders = call_mistral_api(stakeholders_prompt)

    # Classify domain
    domain_prompt = f"Classify the domain for the following requirement (e.g., Bank, Healthcare, etc.):\n\n{requirement}\n\nDomain:"
    domain = call_mistral_api(domain_prompt)

    # Detect defects
    defects_prompt = f"Detect any defects in the following requirement (e.g., Ambiguity, Incompleteness, etc.):\n\n{requirement}\n\nDefects:"
    defects = call_mistral_api(defects_prompt)

    # Rewrite requirement
    rewrite_prompt = f"Rewrite the following requirement in a simpler form:\n\n{requirement}\n\nSimplified Requirement:"
    rewritten = call_mistral_api(rewrite_prompt)

    return {
        "Requirement": requirement,
        "Type": req_type,
        "Stakeholders": stakeholders,
        "Domain": domain,
        "Defects": defects,
        "Rewritten": rewritten
    }

# Function to process multiple requirements
def process_requirements(input_text, uploaded_file):
    requirements = []

    # If a file is uploaded, extract text from the PDF
    if uploaded_file:
        with pdfplumber.open(uploaded_file) as pdf:
            for page in pdf.pages:
                requirements.extend(page.extract_text().split("\n"))

    # If text input is provided, split into individual requirements
    if input_text:
        requirements.extend(input_text.split("\n"))

    # Analyze each requirement
    results = []
    for req in requirements:
        if req.strip():  # Ignore empty lines
            results.append(analyze_requirement(req.strip()))

    return results

# Function to generate a PDF report
def generate_pdf_report(results):
    pdf = FPDF()
    pdf.add_page()
    pdf.set_font("Arial", size=12)

    for result in results:
        pdf.cell(200, 10, txt=f"Requirement: {result['Requirement']}", ln=True)
        pdf.cell(200, 10, txt=f"Type: {result['Type']}", ln=True)
        pdf.cell(200, 10, txt=f"Stakeholders: {result['Stakeholders']}", ln=True)
        pdf.cell(200, 10, txt=f"Domain: {result['Domain']}", ln=True)
        pdf.cell(200, 10, txt=f"Defects: {result['Defects']}", ln=True)
        pdf.cell(200, 10, txt=f"Rewritten: {result['Rewritten']}", ln=True)
        pdf.cell(200, 10, txt="-" * 50, ln=True)

    pdf_output = "requirements_report.pdf"
    pdf.output(pdf_output)
    return pdf_output

# Gradio interface
def app_interface(input_text, uploaded_file):
    results = process_requirements(input_text, uploaded_file)
    pdf_report = generate_pdf_report(results)

    # Display results in a clean format
    output_text = ""
    for result in results:
        output_text += f"Requirement: {result['Requirement']}\n"
        output_text += f"Type: {result['Type']}\n"
        output_text += f"Stakeholders: {result['Stakeholders']}\n"
        output_text += f"Domain: {result['Domain']}\n"
        output_text += f"Defects: {result['Defects']}\n"
        output_text += f"Rewritten: {result['Rewritten']}\n"
        output_text += "-" * 50 + "\n\n"

    return output_text, pdf_report

# Gradio app
title = "Requirement Analysis App"
description = """
This app analyzes software requirements using the Mistral model. 
You can either enter requirements manually or upload a PDF file containing requirements.
"""
team_name = "Team Innovators"

interface = gr.Interface(
    fn=app_interface,
    inputs=[
        gr.Textbox(label="Enter Requirements (one per line)"),
        gr.File(label="Upload PDF File (optional)")
    ],
    outputs=[
        gr.Textbox(label="Analysis Results"),
        gr.File(label="Download PDF Report")
    ],
    title=title,
    description=description,
    theme="soft"
)

# Add team name to the interface
interface.launch()