app.py

import gradio as gr
import mtdna_backend
import json
import data_preprocess, model, pipeline
import os
import hashlib
import threading
import asyncio
import mtdna_backend
# Gradio UI
#stop_flag = gr.State(value=False)
class StopFlag:
    def __init__(self):
        self.value = False
global_stop_flag = StopFlag()  # Shared between run + stop

with open("better_offer.html", "r", encoding="utf-8") as f:
    pricing_html = f.read()

with open("mtdna_tool_explainer_updated.html", "r", encoding="utf-8") as f:
    flow_chart = f.read()

css = """

/* The main container for the entire NPS section */

#nps-container {

    background-color: #333;

    padding: 20px;

    border-radius: 8px;

    display: flex;

    flex-direction: column;

    width: 100%;

}



/* Ensure the question text is properly spaced */

#nps-container h3 {

    color: #fff;

    margin-bottom: 20px; /* Space between question and buttons */

    text-align: center; /* Center the question text */

}



/* Flexbox container for the radio buttons */

#nps-radio-container {

    width: 100%;

    display: flex;

    justify-content: space-between;

    align-items: center;

}



/* Ensure the inner Gradio radio group stretches to fill the container */

#nps-radio-container > div.gr-radio-group {

    width: 100% !important;

    display: flex !important;

    justify-content: space-between !important;

}



/* Styling for each individual button */

#nps-radio-container .gr-radio-label {

    display: flex;

    justify-content: center;

    align-items: center;

    width: 35px;

    height: 35px;

    border-radius: 4px;

    background-color: #555;

    color: white;

    font-weight: bold;

    cursor: pointer;

    transition: background-color 0.2s ease;

    font-size: 14px;

    margin: 0; /* Remove default button margins */

}



#nps-radio-container .gr-radio-label:hover {

    background-color: #777;

}



#nps-radio-container input[type="radio"]:checked + .gr-radio-label {

    background-color: #999;

    border: 2px solid white;

}



#nps-radio-container .gr-radio-input {

    display: none;

}



/* The row for the "Not likely" and "Extremely likely" labels */

#nps-labels-row {

    display: flex;

    justify-content: space-between;

    margin-top: 15px; /* Adds space below the number buttons */

    width: 100%; /* Force labels row to take full width */

}



#nps-labels-row .gr-markdown p {

    margin: 0;

    font-size: 1.0em;

    color: #ccc;

    white-space: nowrap;

    width: 50%;

}



#nps-labels-row .gr-markdown:first-child p {

    text-align: left;

}



#nps-labels-row .gr-markdown:last-child p {

    text-align: right;

}



/* Submit button styling */

#nps-submit-button {

    margin-top: 25px; /* Adds space above the submit button */

    width: 100%;

}



#nps-submit-button:active {

    border-color: white !important;

    box-shadow: 0 0 5px white inset;

}

#nps-radio-container .wrap {

    display: grid !important;

    grid-template-columns: repeat(11, 1fr); /* 11 equal slots */

    gap: 8px; /* spacing between buttons */

}



#niche-input-box {

    display: none;

}



"""

with gr.Blocks(css=css) as interface:
    # with gr.Tab("CURIOUS ABOUT THIS PRODUCT?"):
    #     gr.HTML(value=pricing_html)
    with gr.Tab("🧬 Classifier"):
        gr.Markdown("# 🧬 mtDNA Location Classifier (MVP)")
        #inputMode = gr.Radio(choices=["Single Accession", "Batch Input"], value="Single Accession", label="Choose Input Mode")
        user_email = gr.Textbox(label="📧 Your email (used to track free quota). ",
                                placeholder="Enter your email and click Submit and Classify button below to run accessions.\nYou'll get +20 extra free queries and can download the results.")
            
    
        usage_display = gr.Markdown("", visible=False)
    
        raw_text = gr.Textbox(label="🧚 Input Accession Number(s) (single (KU131308) or comma-separated (e.g., MF362736.1,MF362738.1,KU131308,MW291678))")
        #niche_input = gr.Textbox(visible=False, elem_id="niche-input-box")
        niche_input = gr.Textbox(visible=True, elem_id="niche-input-box", interactive=False)

        gr.HTML("""

        <div style="margin-top: 10px; line-height: 1.8;">

          <a href="https://docs.google.com/spreadsheets/d/1lKqPp17EfHsshJGZRWEpcNOZlGo3F5qU/edit?usp=sharing" 

             target="_blank" style="display:block; margin-bottom: 8px;">

             Example Excel Input Template

          </a>

        

          <a href="#" id="no-dataset-link" style="color:#4EA8DE; text-decoration: underline; display:block; margin-bottom: 8px;">

            I don't have a dataset to test — where should I find it?

          </a>

        

          <a href="#" id="custom-label-link" style="color:#4EA8DE; text-decoration: underline; display:block; margin-bottom: 8px;">

            Customize your label

          </a>

        

          <!-- Box for instructions -->

          <div id="instruction-box" 

               style="display:none; background:#2b2b2b; color:white; padding:10px; border-radius:8px; margin-top:8px; position: relative; max-width: 600px;">

            <span id="close-instruction" 

                  style="position:absolute; top:5px; right:10px; cursor:pointer; font-weight:bold;">✕</span>

            <p style="margin:0;">

              <strong>Quick collect:</strong> type 

              <code>homo sapiens</code> [or any organism] 

              AND <code>mitochondrion</code> AND <code>&lt;country_name&gt;</code> 

              on <a href="https://www.ncbi.nlm.nih.gov/nuccore" target="_blank" style="color:#4EA8DE;">NCBI</a>.

            </p>

          </div>

        

          <!-- Customize Label Box -->

          <div id="custom-label-box" 

               style="display:none; background:#2b2b2b; color:white; padding:12px; border-radius:8px; margin-top:8px; position: relative; max-width: 600px;">

            <span id="close-custom-label" 

                  style="position:absolute; top:5px; right:10px; cursor:pointer; font-weight:bold;">✕</span>

        

            <label for="niche-dropdown" style="display:block; margin-bottom:6px;">Choose your label:</label>

            <select id="niche-dropdown" style="width:100%; padding:8px; border-radius:5px; border:none; background:#3b3b3b; color:white;">

              <option value="">-- Select a label --</option>

              <option value="ethnicity">Ethnicity</option>

              <option value="specific location">Specific Location</option>

              <option value="phenotype">Phenotype</option>

              <option value="haplogroup">Haplogroup</option>

              <option value="contact">Contact (for custom label)</option>

            </select>

        

            <p id="selected-label" style="margin-top:10px; color:#ddd;">No label selected</p>

          </div>

        </div>

        

        <script>



        function waitForElement(selector, callback) {

          const observer = new MutationObserver(() => {

            const el = document.querySelector(selector);

            if (el) {

              observer.disconnect();

              callback(el);

            }

          });

          observer.observe(document.body, { childList: true, subtree: true });

        }

        

        // Run when Gradio textbox appears

        waitForElement('#niche-input-box textarea', (hiddenBox) => {

          console.log("✅ Hidden textbox detected:", hiddenBox);

        

          const customLabelLink = document.getElementById('custom-label-link');

          const customLabelBox = document.getElementById('custom-label-box');

          const closeCustomLabel = document.getElementById('close-custom-label');

          const dropdown = document.getElementById('niche-dropdown');

          const display = document.getElementById('selected-label');

          let selectedValue = null;



          const noDatasetLink = document.getElementById('no-dataset-link');

          const instructionBox = document.getElementById('instruction-box');

          const closeInstruction = document.getElementById('close-instruction');

        

          // Show instruction box when link clicked

          noDatasetLink.addEventListener('click', (e) => {

            e.preventDefault();

            instructionBox.style.display = 'block';

          });

        

          // Close the instruction box

          closeInstruction.addEventListener('click', () => {

            instructionBox.style.display = 'none';

          });

        

          // Toggle open

          customLabelLink.addEventListener('click', (e) => {

            e.preventDefault();

            customLabelBox.style.display = 'block';

          });

        

          // Close button with optional warning

          closeCustomLabel.addEventListener('click', () => {

            if (selectedValue) {

              const confirmClose = confirm(

                `You selected "${selectedValue}". Closing will erase your choice. Continue?`

              );

              if (!confirmClose) return;

            }

            selectedValue = null;

            customLabelBox.style.display = 'none';

            hiddenBox.value = "";

            hiddenBox.dispatchEvent(new Event('input', { bubbles: true }));

            display.textContent = "No label selected";

          });

        

          // Handle dropdown changes

          dropdown.addEventListener('change', () => {

            const value = dropdown.value.trim().toLowerCase();

            selectedValue = value;

        

            if (value && value !== "contact") {

              hiddenBox.value = value;

              hiddenBox.dispatchEvent(new Event('input', { bubbles: true }));

              display.textContent = `✅ Selected Label: ${value}`;

            } else if (value === "contact") {

              hiddenBox.value = "";

              hiddenBox.dispatchEvent(new Event('input', { bubbles: true }));

              display.innerHTML = `📧 Please <a href="mailto:[email protected]" style="color:#4EA8DE;">contact us</a> for a custom label.`;

            } else {

              hiddenBox.value = "";

              hiddenBox.dispatchEvent(new Event('input', { bubbles: true }));

              display.textContent = "No label selected";

            }

        

            console.log("📤 Synced value to hidden textbox:", hiddenBox.value);

          });

        });

        </script>

        """)


        file_upload = gr.File(label="📁 Or Upload Excel File", file_types=[".xlsx"], interactive=True)
        processed_info = gr.Markdown(visible=False)  # new placeholder for processed list
        
        with gr.Row():
            run_button = gr.Button("🔍 Submit and Classify", elem_id="run-btn")
            stop_button = gr.Button("❌ Stop Batch", visible=False, elem_id="stop-btn")
            reset_button = gr.Button("🔄 Reset", elem_id="reset-btn")

    
        status = gr.Markdown(visible=False)
        
                
        with gr.Group(visible=False) as results_group:
            
            with gr.Accordion("Open to See the Output Table", open=True) as table_accordion:    
                  output_table = gr.HTML(render=True)
              
            gr.Markdown(" ") # A simple blank markdown can create space
                
            report_button = gr.Button("Report an unsatisfactory output for a free credit.",elem_id="run-btn")
            report_textbox = gr.Textbox(
                label="Describe the issue",
                lines=4,
                placeholder="e.g. DQ981467: it gives me unknown when I can in fact search it on NCBI \n DQ981467: cannot find the result in batch output when the live processing did show already processed",
                visible=False) 
            submit_report_button = gr.Button("Submit", visible=False, elem_id="run-btn")
            status_report = gr.Markdown(visible=False)  
    
            # Use gr.Markdown to add a visual space
            gr.Markdown(" ") # A simple blank markdown can create space
    
            download_file = gr.File(label="Download File Here", visible=False, interactive=True)
            
            gr.Markdown(" ") # A simple blank markdown can create space
    
            
            with gr.Group(visible=True, elem_id="nps-overlay") as nps_modal:
                with gr.Group(elem_id="nps-container"):
                    gr.Markdown("### How likely are you to recommend this tool to a colleague or peer?")
            
                    # Score options (0-10)
                    nps_radio = gr.Radio(
                        choices=[str(i) for i in range(11)],
                        label="Select score:",
                        interactive=True,
                        container=False,
                        elem_id="nps-radio-container"
                    )
            
                    # Row for labels under the ends
                    with gr.Row():
                        with gr.Column(scale=1):
                            gr.Markdown("Not likely")
                        with gr.Column(scale=8):
                            gr.Markdown("")  # spacer
                        with gr.Column(scale=1):
                            gr.Markdown("Extremely likely")
            
                    nps_submit = gr.Button("Submit", elem_id="nps-submit-button")
                    nps_output = gr.Textbox(label="", interactive=False, visible=True)

            gr.Markdown(" ") # A simple blank markdown can create space
            
            progress_box = gr.Textbox(label="Live Processing Log", lines=20, interactive=False)   
    
            gr.Markdown("---")
           
        def classify_with_loading():
            return gr.update(value="⏳ Please wait... processing...",visible=True)  # Show processing message
             
        
        active_processes = []
        def stop_batch():
          global_stop_flag.value = True
          return gr.update(value="❌ Stopping...", visible=True)
    
        
        def submit_nps(email,nps_score):
            if nps_score is None:
                return "❌ Please select a score before submitting."
            log_submission_to_gsheet(email, [], nps_score)
            return "✅ Thanks for submitting your feedback!"
                    
        def log_submission_to_gsheet(email, samples, nps_score=None):
            from datetime import datetime, timezone
            import json, os, gspread
            from oauth2client.service_account import ServiceAccountCredentials
            import uuid
        
            timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")
            if not email.strip():
                email = f"anonymous_{str(uuid.uuid4())[:8]}"
        
            try:
                creds_dict = json.loads(os.environ["GCP_CREDS_JSON"])
                scope = ["https://spreadsheets.google.com/feeds", "https://www.googleapis.com/auth/drive"]
                creds = ServiceAccountCredentials.from_json_keyfile_dict(creds_dict, scope)
                client = gspread.authorize(creds)
        
                sheet = client.open("user_usage_log")
                worksheet = sheet.sheet1  # Main sheet
        
                data = worksheet.get_all_values()
                headers = data[0]
                email_col = headers.index("email")
                samples_col = headers.index("samples")
                recent_time_col = headers.index("recent_time")
                nps_col = headers.index("nps_score") if "nps_score" in headers else -1
                print("this is nps col: ", nps_col)
                # Step 1: Find row matching the email
                for i, row in enumerate(data[1:], start=2):  # start=2 for correct row indexing
                    if row[email_col].strip().lower() == email.strip().lower():
                        old_samples = row[samples_col].strip() if len(row) > samples_col else ""
                        old_sample_list = [s.strip() for s in old_samples.split(",") if s.strip()]
                        all_samples = list(dict.fromkeys(old_sample_list + samples))  # deduplicate while preserving order
                        new_sample_string = ", ".join(all_samples)

                        # Update recent_time to store history
                        old_timestamp = row[recent_time_col].strip() if len(row) > recent_time_col else ""
                        if old_timestamp:
                            new_timestamp = f"{old_timestamp}, {timestamp}"
                        else:
                            new_timestamp = timestamp
                            
                        worksheet.update_cell(i, samples_col + 1, new_sample_string)
                        worksheet.update_cell(i, recent_time_col + 1, str(new_timestamp))
                        if nps_score is not None:
                            print("this is nps score:", nps_score)
                            old_nps = row[nps_col].strip() if len(row) > nps_col else ""
                            if old_nps:
                                new_nps = f"{old_nps},{nps_score}"
                            else:
                                new_nps = str(nps_score)
                            worksheet.update_cell(i, nps_col + 1, str(new_nps))

                        print(f"✅ Updated existing user row for: {email}")
                        return
        
                # Step 2: If email not found, add new row
                new_row = [""] * len(headers)
                new_row[email_col] = email
                new_row[samples_col] = ", ".join(samples)
                new_row[recent_time_col] = timestamp
                if nps_col != -1:
                    if len(new_row) <= nps_col:
                        new_row.extend([""] * (nps_col + 1 - len(new_row)))
                    new_row[nps_col] = str(nps_score) if nps_score is not None else ""
                worksheet.append_row(new_row)
                print(f"✅ Appended new user row for: {email}")
        
            except Exception as e:
                print(f"❌ Failed to log submission to Google Sheets: {e}")


        import multiprocessing
        import time
        
        def run_with_timeout(func, args=(), kwargs={}, timeout=30, stop_value=None):
            """

            Runs func in a separate process with optional timeout.

            If stop_value is provided and becomes True during execution, the process is killed early.

            """
            def wrapper(q, *args, **kwargs):
                try:
                    result = func(*args, **kwargs)
                    q.put((True, result))
                except Exception as e:
                    q.put((False, e))
        
            q = multiprocessing.Queue()
            p = multiprocessing.Process(target=wrapper, args=(q, *args), kwargs=kwargs)
            active_processes.append(p)   # ✅ track it
            p.start()
        
            start_time = time.time()
            while p.is_alive():
                # Timeout check
                if timeout is not None and (time.time() - start_time) > timeout:
                    p.terminate()
                    p.join()
                    print(f"⏱️ Timeout exceeded ({timeout} sec) — function killed.")
                    return False, None
        
                if stop_value is not None and stop_value.value:
                    print("🛑 Stop flag detected — waiting for child to exit gracefully.")
                    p.join(timeout=3)  # short wait for graceful exit
                    if p.is_alive():
                        print("⚠️ Child still alive, forcing termination.")
                        p.terminate()
                        p.join(timeout=2)
                    return False, None
                time.sleep(0.1)  # avoid busy waiting
        
            # Process finished naturally
            if not q.empty():
                success, result = q.get()
                if success:
                    return True, result
                else:
                    raise result
        
            return False, None
        def cleanup_processes():
            global active_processes
            print("inside cleanup process and number of active process: ", len(active_processes))
            for p in active_processes:
                if p.is_alive():
                    try:
                        p.terminate()
                        p.join(timeout=2)
                    except Exception:
                        pass
            active_processes = []

        def summarize_results_sync(acc, stop_flag=None, niche_cases=None):
            print("in sum_resukt_sync and niche case is: ", niche_cases)
            return asyncio.run(mtdna_backend.summarize_results(acc, stop_flag, niche_cases))
            
        def threaded_batch_runner(file=None, text="", email="", niche_cases=None):
            print("clean everything remain before running")
            cleanup_processes()
            print("📧 EMAIL RECEIVED:", repr(email))
            import tempfile
            from mtdna_backend import (
                extract_accessions_from_input,
                summarize_results,
                save_to_excel,
                increment_usage,
            )
            import os
                
            global_stop_flag.value = False  # reset stop flag
            #active_processes = []
            
            tmp_dir = tempfile.mkdtemp()
            output_file_path = os.path.join(tmp_dir, "batch_output_live.xlsx")
            #output_file_path = "/mnt/data/batch_output_live.xlsx"
            all_rows = []
            processed_accessions = 0  # ✅ track successful accessions
            email_tracked = False
            log_lines = []
            usage_text = ""
            processed_info = ""
            if not email.strip():
                output_file_path = None#"Write your email so that you can download the outputs."
                log_lines.append("📥 Provide your email to receive a downloadable Excel report and get 20 more free queries.")
                limited_acc = 30
            if email.strip():
                usage_count, max_allowed = increment_usage(email, processed_accessions) 
                if int(usage_count) >= int(max_allowed):
                    log_lines.append("❌ You have reached your quota. Please contact us to unlock more.")
                    
                    # Minimal blank yield to trigger UI rendering
                    yield (
                        make_html_table([]),            # 1 output_table
                        gr.update(visible=True),        # 2 results_group
                        gr.update(visible=False),       # 3 download_file
                        gr.update(value="", visible=True), # 4 usage_display
                        "⛔️ Quota limit",               # 5 status
                        "⛔️ Quota limit",               # 6 progress_box
                        gr.update(visible=True),        # 7 run_button
                        gr.update(visible=False),       # 8 stop_button
                        gr.update(visible=True),        # 9 reset_button
                        gr.update(visible=True),        # 10 raw_text
                        gr.update(visible=True),        # 11 file_upload
                        gr.update(value=processed_info, visible=False), # 12 processed_info
                        gr.update(visible=False)        # 13 nps_modal
                    )
            
                    # Actual warning frame
                    yield (
                        make_html_table([]),
                        gr.update(visible=False),
                        gr.update(visible=False),
                        gr.update(value="❌ You have reached your quota. Please contact us to unlock more.", visible=True),
                        "❌ Quota Exceeded",
                        "\n".join(log_lines),
                        gr.update(visible=True),
                        gr.update(visible=False),
                        gr.update(visible=True),
                        gr.update(visible=True),
                        gr.update(visible=True),
                        gr.update(value="", visible=False),
                        gr.update(visible=False)
                    )
                    return
                limited_acc = int(max_allowed-usage_count)
            
            # Step 1: Parse input
            accessions, invalid_accessions, error = extract_accessions_from_input(file, text)
            total = len(accessions)
            print("total len original accessions: ", total)
            if total > 0:
                if total > limited_acc:
                    accessions = accessions[:limited_acc]
                    if invalid_accessions:
                        warning = f"⚠️ Only processing first {limited_acc} accessions. ⚠️ Invalid accessions: {', '.join(invalid_accessions)}."
    
                    else:
                        warning = f"⚠️ Only processing first {limited_acc} accessions."
                else:
                    if invalid_accessions:
                        warning = f"✅ All {total} accessions will be processed. ⚠️ Invalid accessions: {', '.join(invalid_accessions)}."
                    else:
                        warning = f"✅ All {total} accessions will be processed."
            else:
                if invalid_accessions:
                    warning = f"⚠️ Invalid accessions: {', '.join(invalid_accessions)}."
                else:
                    warning = "Nothing to processing"
            if len(accessions) == 1:    
                processed_info = warning + "\n" +f"Processed accessions: {accessions[0]}"
            else:    
                if len(accessions) > 0:
                    processed_info = warning + "\n" +f"Processed accessions: {accessions[0]}...{accessions[-1]}"   
                elif len(accessions) == 0:
                    processed_info = warning
                else:
                    processed_info = "⚠️ Cannot process the input"
            ### NEW: Hide inputs, show processed_info at start
            yield (
                make_html_table(all_rows), # output_table
                gr.update(visible=False),   # results_group
                gr.update(visible=False),   # download_file
                "", # usage_display
                "⏳ Processing...", # status
                "", # progess_box
                gr.update(visible=False), # run_button,
                gr.update(visible=True),     # show stop button
                gr.update(visible=True),     # show reset button
                gr.update(visible=True),    # hide raw_text
                gr.update(visible=True),    # hide file_upload
                gr.update(value=processed_info, visible=True),  # processed_info
                gr.update(visible=False)     # hide NPS modal at start
            )
            
            log_submission_to_gsheet(email, accessions)

            print("🧪 Accessions received:", accessions)
            if error:
                yield (
                    "",                               # 1 output_table
                    gr.update(visible=False),         # 2 results_group
                    gr.update(visible=False),         # 3 download_file
                    "",                               # 4 usage_display
                    "❌ Error",                        # 5 status
                    str(error),                       # 6 progress_box
                    gr.update(visible=True),          # 7 run_button
                    gr.update(visible=False),         # 8 stop_button
                    gr.update(visible=True),          # 9 reset_button
                    gr.update(visible=True),          # 10 raw_text
                    gr.update(visible=True),          # 11 file_upload
                    gr.update(value="", visible=False), # 12 processed_info
                    gr.update(visible=False)           # 13 nps_modal
                )
                return
        
            
            if niche_cases and niche_cases.strip():
                niche_cases_list = [x.strip() for x in niche_cases.split(",") if x.strip()]
            else:
                niche_cases_list = None
                # print("this is niche case in the None: ", niche_cases_list)
                # niche_cases_list = ["ethnicity"]
            print("niche case is: ", niche_cases_list)    
            for i, acc in enumerate(accessions):
                try:
                    if global_stop_flag.value:
                        log_lines.append(f"🛑 Stopped at {acc} ({i+1}/{total})")
                        usage_text = ""
            
                        if email.strip() and not email_tracked:
                            print(f"🧪 increment_usage at STOP: {email=} {processed_accessions=}")
                            usage_count, max_allowed = increment_usage(email, processed_accessions)
                            email_tracked = True
                            usage_text = f"**{usage_count}**/{max_allowed} allowed samples used by this email."
                            #Ten more samples are added first (you now have 60 limited accessions), then wait we will contact you via this email."
                        else:
                            usage_text = f"The limited accession is 30. The user has used {processed_accessions}, and only {30 - processed_accessions} left."
            
                        
                        cleanup_processes()   # ✅ hard kill anything left
                        yield (
                            make_html_table(all_rows),
                            gr.update(visible=True),                           # results_group
                            gr.update(value=output_file_path, visible=bool(output_file_path)),  # download_file
                            gr.update(value=usage_text, visible=True),         # usage_display
                            "🛑 Stopped",                                       # "✅ Done" or "🛑 Stopped"
                            "\n".join(log_lines),
                            gr.update(visible=False),                          # run_button
                            gr.update(visible=False),                          # stop_button
                            gr.update(visible=True),                           # reset_button
                            gr.update(visible=True),                          # raw_text
                            gr.update(visible=True),                          # file_upload
                            gr.update(value=processed_info, visible=False),                # processed_info
                            gr.update(visible=True)                            # NPS modal now visible
                        )
    
                        return
            
                    log_lines.append(f"[{i+1}/{total}] Processing {acc}")
                    
                    # Hide inputs, show processed_info at start
                    yield (
                        make_html_table(all_rows),         # output_table
                        gr.update(visible=True),          # results_group
                        gr.update(visible=False),          # download_file
                        "",                                # usage_display
                        "⏳ Processing...",                 # status
                        "\n".join(log_lines),              # progress_box
                        gr.update(visible=False),           # run_button
                        gr.update(visible=True),           # stop_button
                        gr.update(visible=True),           # reset_button
                        gr.update(visible=True),          # hide raw_text
                        gr.update(visible=True),          # hide file_upload
                        gr.update(value=processed_info, visible=True),  # processed_info
                        gr.update(visible=False)           # hide NPS modal at start
                    )

                    print("📄 Processing accession:", acc)
                    # --- Before calling summarize_results ---
                    samples_left = total - i  # including current one
                    estimated_seconds_left = samples_left * 100  # your observed average per sample
                    
                    log_lines.append(
                        f"Running... usually ~100s per sample"
                    )
                    log_lines.append(
                        f"⏳ Estimated time left: ~{estimated_seconds_left} seconds ({samples_left} sample{'s' if samples_left > 1 else ''} remaining)"
                    )
                    
                    # Yield update to UI before the heavy pipeline call
                    yield (
                        make_html_table(all_rows),
                        gr.update(visible=True),          # results_group
                        gr.update(visible=False),         # download_file
                        "",                               # usage_display
                        "⏳ Processing...",                # status
                        "\n".join(log_lines),             # progress_box
                        gr.update(visible=False),         # run_button
                        gr.update(visible=True),          # stop_button
                        gr.update(visible=True),          # reset_button
                        gr.update(visible=True),         # raw_text
                        gr.update(visible=True),         # file_upload
                        gr.update(value=processed_info, visible=True),  # processed_info
                        gr.update(visible=False)          # hide NPS modal
                    )
    
                    # Run summarize_results in a separate process with stop flag support
                    success, rows = run_with_timeout(
                        #summarize_results,
                        summarize_results_sync,
                        args=(acc,global_stop_flag, niche_cases_list),
                        timeout=None,              # or set max seconds per sample if you want
                        stop_value=global_stop_flag
                    )
                    
                    # If stop was pressed during this accession
                    if not success and global_stop_flag.value:
                        log_lines.append(f"🛑 Cancelled {acc} before completion")
                        
                        cleanup_processes()   # ✅ hard kill anything left
                        yield (
                            make_html_table(all_rows),
                            gr.update(visible=True),                           # results_group
                            gr.update(value=output_file_path, visible=bool(output_file_path)),  # download_file
                            gr.update(value=usage_text, visible=True),         # usage_display
                            "🛑 Stopped",                                       # "✅ Done" or "🛑 Stopped"
                            "\n".join(log_lines),
                            gr.update(visible=False),                          # run_button
                            gr.update(visible=False),                          # stop_button
                            gr.update(visible=True),                           # reset_button
                            gr.update(visible=True),                          # raw_text
                            gr.update(visible=True),                          # file_upload
                            gr.update(value="", visible=False),                # processed_info
                            gr.update(visible=True)                            # NPS modal now visible
                        )
    
                        break  # stop processing entirely
                    
                    # If it finished normally
                    if success and rows:
                        all_rows.extend(rows)
                        processed_accessions += 1
                        if email.strip():
                            save_to_excel(all_rows, "", "", output_file_path, is_resume=False)
                        log_lines.append(f"✅ Processed {acc} ({i+1}/{total})")
                    else:
                        # If it failed due to timeout or other error
                        if not global_stop_flag.value:
                            log_lines.append(f"⚠️ Skipped {acc} due to timeout or error")
                    
                    # Always yield updated logs after each attempt
                    
                    yield (
                        make_html_table(all_rows),         # output_table
                        gr.update(visible=True),          # results_group
                        gr.update(visible=False),          # download_file
                        "",                                # usage_display
                        "⏳ Processing...",                 # status
                        "\n".join(log_lines),              # progress_box
                        gr.update(visible=False),           # run_button
                        gr.update(visible=True),           # stop_button
                        gr.update(visible=True),           # reset_button
                        gr.update(visible=True),          # hide raw_text
                        gr.update(visible=True),          # hide file_upload
                        gr.update(value=processed_info, visible=True),  # processed_info
                        gr.update(visible=False)           # hide NPS modal at start
                    )
            

                except Exception as e:
                    log_lines.append(f"❌ Failed to process {acc}: {e}. Report on the box above so that we won't count this bad one for you (email required).")
                    yield (
                        make_html_table(all_rows),         # output_table
                        gr.update(visible=True),          # results_group
                        gr.update(visible=False),          # download_file
                        "",                                # usage_display
                        "⏳ Processing...",                 # status
                        "\n".join(log_lines),              # progress_box
                        gr.update(visible=False),           # run_button
                        gr.update(visible=True),           # stop_button
                        gr.update(visible=True),           # reset_button
                        gr.update(visible=True),          # hide raw_text
                        gr.update(visible=True),          # hide file_upload
                        gr.update(value=processed_info, visible=True),  # processed_info
                        gr.update(visible=False)           # hide NPS modal at start
                    )
                
            # Step 3: Final usage update
            usage_text = ""
            if email.strip() and not email_tracked:
                print(f"🧪 increment_usage at END: {email=} {processed_accessions=}")
                usage_count, max_allowed = increment_usage(email, processed_accessions)
                email_tracked = True
                usage_text = f"**{usage_count}**/{max_allowed} allowed samples used by this email." 
                #Ten more samples are added first (you now have 60 limited accessions), then wait we will contact you via this email."
            elif not email.strip():
                usage_text = f"The limited accession is 30. The user has used {processed_accessions}, and only {30 - processed_accessions} left."
        
            yield (
                make_html_table(all_rows),
                gr.update(visible=True),                           # results_group
                gr.update(value=output_file_path, visible=bool(output_file_path)),  # download_file
                gr.update(value=usage_text, visible=True),         # usage_display
                "✅ Done",                                      # "✅ Done" or "🛑 Stopped"
                "\n".join(log_lines),
                gr.update(visible=False),                          # run_button
                gr.update(visible=False),                          # stop_button
                gr.update(visible=True),                           # reset_button
                gr.update(visible=True),                          # raw_text
                gr.update(visible=True),                          # file_upload
                gr.update(value=processed_info, visible=True),                # processed_info
                gr.update(visible=True)                            # NPS modal now visible
            )
    
        # SUBMIT REPORT UI
        # 1. Google Sheets setup
        def get_worksheet(sheet_name="Report"):
            import os, json
            import gspread
            from oauth2client.service_account import ServiceAccountCredentials
            try:
                creds_dict = json.loads(os.environ["GCP_CREDS_JSON"])
                scope = ["https://spreadsheets.google.com/feeds", "https://www.googleapis.com/auth/drive"]
                creds = ServiceAccountCredentials.from_json_keyfile_dict(creds_dict, scope)
                client = gspread.authorize(creds)
                sheet = client.open(sheet_name).sheet1
                return sheet
            except Exception as e:
                print(f"❌ Error loading Google Sheet '{sheet_name}':", e)
                return None
                
        # 2. Submit function to send report to the Google Sheet
        def submit_report(report_text,user_email=""):
            try:
                sheet = get_worksheet()
                # ✅ Parse the report_text (each line like 'ACCESSION: message')
                lines = report_text.strip().split('\n')
                user = ""
                if user_email.strip():
                    user = user_email
                for line in lines:
                    if ':' in line:
                        accession, message = line.split(':', 1)
                        sheet.append_row([accession.strip(), message.strip(), user.strip()])
                return "✅ Report submitted successfully!"
            except Exception as e:
                return f"❌ Error submitting report: {str(e)}"
        def show_report_ui():
            return gr.update(visible=True), gr.update(visible=True), gr.update(visible=False)

        def handle_submission(text,user_email):
            msg = submit_report(text, user_email)
            return gr.update(value=msg, visible=True), gr.update(visible=False), gr.update(visible=False)        

        def make_html_table(rows):
            """

            Dynamically builds an HTML table based on the detected headers in `rows`.

            Works with both list-of-lists and list-of-dicts.

            Automatically includes any new columns (e.g. niche_cases).

            """
            if not rows:
                return "<p style='color:#ccc;'>No results to display.</p>"
        
            # 🧩 Detect if rows are list-of-lists or list-of-dicts
            if isinstance(rows[0], dict):
                data_dicts = rows
                # dynamic headers from all dict keys (union of keys)
                print("make html table: ", data_dicts)
                all_keys = []
                for r in data_dicts:
                    for k in r.keys():
                        if k not in all_keys:
                            all_keys.append(k)
                headers = ["No."] + all_keys
            else:
                # fallback: static columns (old format)
                headers = [
                    "No.", "Sample ID", "Predicted Country", "Country Explanation",
                    "Predicted Sample Type", "Sample Type Explanation", "Sources", "Time cost"
                ]
                data_dicts = [dict(zip(headers[1:], r)) for r in rows]
        
            # 🧱 Build HTML table
            html = """

            <div style='overflow-x: auto; padding: 10px;'>

                <div style='max-height: 400px; overflow-y: auto; border: 1px solid #444; border-radius: 8px;'>

                    <table style='width:100%; border-collapse: collapse; table-layout: auto; font-size: 14px; color: #f1f1f1; background-color: #1e1e1e;'>

                        <thead style='position: sticky; top: 0; background-color: #2c2c2c; z-index: 1;'>

                            <tr>

            """
            # Add headers dynamically
            html += "".join(
                f"<th style='padding:10px; border:1px solid #555; text-align:left; white-space:nowrap;'>{h}</th>"
                for h in headers
            )
            html += "</tr></thead><tbody>"
        
            # Fill rows
            for idx, row in enumerate(data_dicts, 1):
                html += "<tr>"
                html += f"<td style='padding:10px; border:1px solid #555;'>{idx}</td>"
                for h in headers[1:]:
                    col = row.get(h, "")
                    style = "padding:10px; border:1px solid #555; vertical-align:top;"
                    if h == "Sources" and isinstance(col, str):
                        links = [
                            f"<a href='{url.strip()}' target='_blank' style='color:#4ea1f3; text-decoration:underline;'>{url.strip()}</a>"
                            for url in col.strip().split("\\n") if url.strip()
                        ]
                        col = "- " + "<br>- ".join(links)
                    elif isinstance(col, str):
                        col = col.replace("\\n", "<br>")
                    html += f"<td style='{style}'>{col}</td>"
                html += "</tr>"
        
            html += "</tbody></table></div></div>"
            return html

        def reset_fields():
            global_stop_flag.value = True  # Stop any running job
            cleanup_processes()   # ✅ same cleanup here

            return (
                gr.update(value="", visible=True),   # raw_text
                gr.update(value=None, visible=True), # file_upload
                gr.update(value=[], visible=True),   # output_table
                gr.update(value="", visible=True),   # status
                gr.update(visible=False),            # results_group
                gr.update(value="", visible=True),   # usage_display
                gr.update(value="", visible=True),   # progress_box
                gr.update(value="", visible=False),  # report_textbox
                gr.update(visible=False),             # submit_report_button
                gr.update(value="", visible=False),  # status_report
                gr.update(value="", visible=False),  # processed_info
                gr.update(visible=False),              # hide NPS modal
                gr.update(visible=True),              # run_button ✅ restore
                gr.update(visible=False)              # stop button 
            )

        interface.queue()  # No arguments here!
        
        run_button.click(
            fn=threaded_batch_runner,
            inputs=[file_upload, raw_text, user_email, niche_input],
            outputs=[
                output_table,      # 1
                results_group,     # 2
                download_file,     # 3
                usage_display,     # 4
                status,            # 5
                progress_box,      # 6
                run_button,        # 7
                stop_button,       # 8
                reset_button,      # 9
                raw_text,          # 10
                file_upload,       # 11
                processed_info,    # 12
                nps_modal          # 13
            ],
            concurrency_limit=1,
            queue=True
        )

        
    
        
    
        stop_button.click(fn=stop_batch, inputs=[], outputs=[status])
    
        reset_button.click(
            fn=reset_fields,
            inputs=[],
            outputs=[
                raw_text, 
                file_upload, 
                output_table, 
                status, 
                results_group, 
                usage_display, 
                progress_box,
                report_textbox,
                submit_report_button,
                status_report, 
                processed_info,
                nps_modal,
                run_button,
                stop_button
            ]
        )

        report_button.click(fn=show_report_ui, outputs=[report_textbox, submit_report_button, status_report])
        submit_report_button.click(fn=handle_submission, inputs=[report_textbox, user_email], outputs=[status_report, report_textbox, submit_report_button])
        
        nps_submit.click(fn=submit_nps, inputs=[user_email, nps_radio], outputs=[nps_output])
        # Link each button to submit function
        
        gr.HTML("""

        <style>

          body, html {

              background-color: #121212 !important;

              color: #ffffff !important;

          }

        

          .gradio-container, .gr-block, .gr-box, textarea, input, select, .prose, .prose * {

              background-color: #1e1e1e !important;

              color: #ffffff !important;

              border-color: #333 !important;

          }

        

          textarea::placeholder,

          input::placeholder {

              color: #aaa !important;

          }

        

          button {

              background-color: #2d2d2d !important;

              color: #fff !important;

              border: 1px solid #444 !important;

          }

        

          a {

              color: #4ea1f3 !important;

          }



          /* Shared hover style for the three main buttons */

          #run-btn:hover, #stop-btn:hover, #reset-btn:hover {

              border-color: white !important;

              box-shadow: 0 0 5px white;

              transition: border-color 0.2s ease-in-out, box-shadow 0.2s ease-in-out;

          }

        

          /* Active click style */

          #run-btn:active, #stop-btn:active, #reset-btn:active {

              border-color: white !important;

              box-shadow: 0 0 5px white inset;

              }



        </style>

        """)
    
    with gr.Tab("Curious about this product?"):
        gr.HTML(value=flow_chart)
    
    with gr.Tab("Pricing"):
        gr.HTML(value=pricing_html)

interface.launch(share=True,debug=True)