import gradio as gr
import requests
import os
from dotenv import load_dotenv


def request_meddra_encode_form(req_reported_term, req_language, req_version, req_terms_checkbox):
    # Check if all required fields are filled and the conditions are met
    if not req_reported_term:
        return "**Please enter a medical term.**"
    if not req_version:
        return "**Please select a valid MedDRA version.**"
    if not req_terms_checkbox:
        return "**You need to agree to Safeterm terms of use.**"
    load_dotenv()

    req_apikey = os.getenv("SAFETERM_API_KEY")

    encode_output = encode_caller(req_apikey, req_reported_term, req_language, req_version)
    return encode_output


def encode_caller(apikey, reported_terms, language, meddra_version):
    url = os.getenv("SAFETERM_ENCODE_URL")
    reported_terms_list = [reported_terms.strip()]  # Ensure it's a list of strings

    payload = {
        "reported_terms": reported_terms_list,
        "version": meddra_version,
        "language": language,
        "nmax": 1
    }

    headers = {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {apikey}'
    }

    response = requests.post(url, headers=headers, json=payload, verify=False)
    data = response.json()

    if "detail" in data:
        return data["detail"]

    results = []

    for term_data in data.get('result', []):
        reported_term = term_data.get('reported_term', 'Term missing')
        encoded_term_data = term_data.get('encoded_term')
        detected_language = term_data.get('detected_language', None)  # Get detected language

        llt_term = ''
        pt_term = ''
        llt_id = ''
        pt_id = ''
        alt_pt_term = []
        result = f"Reported Term:\t {reported_term}\n-------------------------\n"

        if isinstance(encoded_term_data, dict) and encoded_term_data:
            report = encoded_term_data.get('report', ' ')
            llt_id = encoded_term_data.get('llt_id', 'no_result')
            llt_term = encoded_term_data.get('llt_term', 'no_result')
            pt_id = encoded_term_data.get('pt_id', 'no_result')
            pt_term = encoded_term_data.get('pt_term', 'no_result')
            alt_pt_terms = encoded_term_data.get('alternative_pt_terms', [])

            result += f"LLT Term:\t\t\t\t {llt_term} [{llt_id}]\nPT Term:\t\t\t\t\t {pt_term} [{pt_id}]\n"

            if alt_pt_terms:
                result += "\nAlternative PT Terms:\n"
                for term in alt_pt_terms:
                    result += f"\t\t\t\t\t\t\t{term}\n"

            result += f"{report}\n-------------------------\n"

        result += f"Status: {term_data['status']}"
        if detected_language:  # Check if detected_language is not null and add to result
            result += f"\nDetected Language: {detected_language}"
        results.append(result)

    # # Add the API messages at the end.
    # api_message = data.get("messages", "No API message available")
    # api_message = "OK" if api_message is None else api_message
    # results.append(f"API Message: {api_message}")

    return "\n".join(results)


# Create Gradio interface with improved styling
with gr.Blocks() as demo:
    with gr.Row():
        with gr.Tab("MedDRA Dictionary Search Engine"):
            # Multi-column layout for MedDRA Encoder tab
            with gr.Row():
                # Column 1: Inputs
                with gr.Column():
                    intro_text = gr.HTML("""
                                            Search for and encode medical verbatims into MedDRA. Select language (default="detect") and MedDRA version. <br>
                                            A best match LLT/PT combination is reported along with a few optional alternative PTs. <br>
                                         """)
                    encode_reported_terms = gr.Dropdown(
                        ["While walking across the street the patient was hit by a motor vehicle",
                         "Pijn in derde vinger",
                         "Mientras cruzaba la calle, el paciente fue golpeado por un vehículo motorizado.",
                         "a bigg Migrein W1th 0Ra", "lower left limb varices", "basse pression sanguine"],
                        label="Medical term",
                        info="Enter your medical term here or choose from presets.",
                        allow_custom_value=True
                    )

                    # Added Language selection dropdown
                    encode_language = gr.Dropdown(
                        choices=["english", "arabic", "brazilian", "chinese", "czech", "dutch", "estonian", "french",
                                 "german", "greek", "hungarian", "italian", "japanese", "korean", "latvian", "polish",
                                 "portuguese", "russian", "spanish", "swedish", "detect"],
                        label="Language",
                        value="detect",  # Default choice
                        info="Choose the coding language or 'detect' for automatic detection. Note some languages may "
                             "not be available in all versions.",
                    )

                    version_values = [float(f"{i:.1f}") for i in range(7, 28)] + [item + 0.1 for item in range(7, 27)]
                    version_values.sort()
                    version_list = [f"{i:.1f}" for i in version_values]

                    encode_version = gr.Dropdown(choices=version_list, label="MedDRA Version", value=version_list[-1])
                    terms_text = gr.HTML("""
                         I confirm that my organization has a valid <a href=https://www.meddra.org/subscription/process>MedDRA License</a>.
                         I consent to the storage of my personal data for training and communication purposes.
                     """)
                    terms_checkbox = gr.Checkbox(label="I agree.")

                    submit_button = gr.Button("Search")

                # Column 2: Output and Terms of use
                with gr.Column():
                    api_response_encode = gr.Textbox(label="Output")

                    submit_button.click(request_meddra_encode_form,
                                        inputs=[encode_reported_terms, encode_language, encode_version, terms_checkbox],
                                        outputs=api_response_encode)

       
    with gr.Row():
        gr.Markdown("(c) ClinBAY - 2024. Contact us at info@clinbay.com")

demo.launch()