from selenium.common.exceptions import TimeoutException
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import time
import os
import re
import json
import base64
import calendar
from datetime import date

from ddma_browser_manager import get_browser_manager

MEMBERS_URL = "https://www.deltadentalma.com/private/provider/dashboard"

# Absolute path to the Backend app root (two levels up from this file's SeleniumService dir)
_SERVICE_DIR = os.path.dirname(os.path.abspath(__file__))
_BACKEND_CWD = os.path.normpath(os.path.join(_SERVICE_DIR, "..", "Backend"))


class AutomationDDMAClaimSubmit:
    def __init__(self, data):
        self.headless = False
        self.driver = None

        raw = data if isinstance(data, dict) else {}
        claim = raw.get("claim", {}) or {}

        patient_name = (claim.get("patientName") or "").strip()
        parts = patient_name.split()
        first_name = parts[0] if parts else ""
        last_name = " ".join(parts[1:]) if len(parts) > 1 else ""

        self.massddma_username = claim.get("massddmaUsername", "") or raw.get("massddmaUsername", "")
        self.massddma_password = claim.get("massddmaPassword", "") or raw.get("massddmaPassword", "")
        self.memberId = claim.get("memberId", "")
        self.dateOfBirth = claim.get("dateOfBirth", "")
        self.serviceDate = claim.get("serviceDate", "")
        self.firstName = claim.get("firstName", "") or first_name
        self.lastName = claim.get("lastName", "") or last_name
        self.serviceLines = claim.get("serviceLines", []) or []
        self.claimFiles   = claim.get("claimFiles",   []) or []
        self.providerName = claim.get("providerName", "") or raw.get("providerName", "")

        self.download_dir = get_browser_manager().download_dir

        print(f"[DDMA Claim] Init — member={self.memberId}, "
              f"patient={self.firstName} {self.lastName}, "
              f"lines={len(self.serviceLines)}")

    def config_driver(self):
        self.driver = get_browser_manager().get_driver(self.headless)

    # ------------------------------------------------------------------ #
    #  Login — identical to DDMA eligibility worker                        #
    # ------------------------------------------------------------------ #
    def _force_logout(self):
        try:
            print("[DDMA Claim login] Forcing logout due to credential change...")
            browser_manager = get_browser_manager()
            try:
                self.driver.get("https://www.deltadentalma.com/")
                time.sleep(2)
                for selector in [
                    "//button[contains(text(), 'Log out') or contains(text(), 'Logout') or contains(text(), 'Sign out')]",
                    "//a[contains(text(), 'Log out') or contains(text(), 'Logout') or contains(text(), 'Sign out')]",
                ]:
                    try:
                        btn = WebDriverWait(self.driver, 3).until(
                            EC.element_to_be_clickable((By.XPATH, selector))
                        )
                        btn.click()
                        time.sleep(2)
                        break
                    except TimeoutException:
                        continue
            except Exception as e:
                print(f"[DDMA Claim login] Could not click logout: {e}")
            try:
                self.driver.delete_all_cookies()
            except Exception:
                pass
            browser_manager.clear_credentials_hash()
        except Exception as e:
            print(f"[DDMA Claim login] Error during forced logout: {e}")

    def login(self, url):
        wait = WebDriverWait(self.driver, 30)
        browser_manager = get_browser_manager()

        try:
            if self.massddma_username and browser_manager.credentials_changed(self.massddma_username):
                self._force_logout()
                self.driver.get(url)
                time.sleep(2)

            # Check if already on a logged-in page
            try:
                current_url = self.driver.current_url
                print(f"[DDMA Claim login] Current URL: {current_url}")
                logged_in_patterns = ["member", "dashboard", "eligibility", "search", "patients", "private/provider"]
                is_logged_in_url = any(p in current_url.lower() for p in logged_in_patterns)

                if is_logged_in_url and "sign-in" not in current_url.lower():
                    # Navigate to members page to confirm
                    if "member" not in current_url.lower():
                        try:
                            WebDriverWait(self.driver, 5).until(
                                EC.presence_of_element_located((By.XPATH, "//a[contains(@href, 'check-patient-benefits-search')]"))
                            )
                            print("[DDMA Claim login] Already logged in")
                            return "ALREADY_LOGGED_IN"
                        except TimeoutException:
                            self.driver.get(MEMBERS_URL)
                            time.sleep(2)
                    try:
                        WebDriverWait(self.driver, 5).until(
                            EC.presence_of_element_located((By.XPATH, "//a[contains(@href, 'check-patient-benefits-search')]"))
                        )
                        print("[DDMA Claim login] Already logged in — member search found")
                        return "ALREADY_LOGGED_IN"
                    except TimeoutException:
                        print("[DDMA Claim login] Could not find member search, will try login")
            except Exception as e:
                print(f"[DDMA Claim login] Error checking current state: {e}")

            self.driver.get(url)
            time.sleep(2)

            # Check if session redirected us straight to member search
            try:
                current_url = self.driver.current_url
                if "sign-in" not in current_url.lower():
                    member_search = WebDriverWait(self.driver, 3).until(
                        EC.presence_of_element_located((By.XPATH, "//a[contains(@href, 'check-patient-benefits-search')]"))
                    )
                    if member_search:
                        print("[DDMA Claim login] Session valid — skipping login")
                        return "ALREADY_LOGGED_IN"
            except TimeoutException:
                print("[DDMA Claim login] Proceeding with login form")

            # Dismiss any "Authentication flow continued in another tab" modal
            modal_dismissed = False
            try:
                ok_button = WebDriverWait(self.driver, 3).until(
                    EC.element_to_be_clickable((By.XPATH,
                        "//button[normalize-space(text())='Ok' or normalize-space(text())='OK']"
                    ))
                )
                ok_button.click()
                print("[DDMA Claim login] Dismissed authentication modal")
                modal_dismissed = True
                time.sleep(2)

                all_windows = self.driver.window_handles
                if len(all_windows) > 1:
                    original_window = self.driver.current_window_handle
                    for window in all_windows:
                        if window != original_window:
                            self.driver.switch_to.window(window)
                            break
                    try:
                        otp_candidate = WebDriverWait(self.driver, 10).until(
                            EC.presence_of_element_located((By.XPATH,
                                "//input[@data-test-id='MfaCode']"
                            ))
                        )
                        if otp_candidate:
                            print("[DDMA Claim login] OTP required (popup)")
                            return "OTP_REQUIRED"
                    except TimeoutException:
                        self.driver.switch_to.window(original_window)
            except TimeoutException:
                pass

            if modal_dismissed:
                time.sleep(2)
                try:
                    WebDriverWait(self.driver, 5).until(
                        EC.presence_of_element_located((By.XPATH, "//a[contains(@href, 'check-patient-benefits-search')]"))
                    )
                    print("[DDMA Claim login] Already authenticated after modal dismiss")
                    return "ALREADY_LOGGED_IN"
                except TimeoutException:
                    pass

            # Fill login form
            try:
                email_field = WebDriverWait(self.driver, 10).until(
                    EC.element_to_be_clickable((By.XPATH, "//input[@data-test-id='Username']"))
                )
            except TimeoutException:
                return "ERROR: Login form not found"

            email_field.clear()
            email_field.send_keys(self.massddma_username)

            password_field = wait.until(
                EC.presence_of_element_located((By.XPATH, "//input[@data-test-id='Password']"))
            )
            password_field.clear()
            password_field.send_keys(self.massddma_password)

            login_button = wait.until(EC.element_to_be_clickable(
                (By.XPATH, "//button[@data-test-id='SigninSubmitButton']")
            ))
            login_button.click()

            if self.massddma_username:
                browser_manager.save_credentials_hash(self.massddma_username)

            # OTP detection
            try:
                otp_candidate = WebDriverWait(self.driver, 30).until(
                    EC.presence_of_element_located((By.XPATH,
                        "//input[@data-test-id='MfaCode']"
                    ))
                )
                if otp_candidate:
                    print("[DDMA Claim login] OTP required")
                    return "OTP_REQUIRED"
            except TimeoutException:
                try:
                    current_url = self.driver.current_url.lower()
                    if "member" in current_url or "dashboard" in current_url:
                        print("[DDMA Claim login] Login succeeded without OTP")
                        return "SUCCESS"
                except Exception:
                    pass
                if "sign-in" in self.driver.current_url.lower():
                    return "ERROR: LOGIN FAILED: Still on login page"
                print("[DDMA Claim login] Assuming login succeeded")
                return "SUCCESS"

        except Exception as e:
            print(f"[DDMA Claim login] Exception: {e}")
            return f"ERROR:LOGIN FAILED: {e}"

    # ------------------------------------------------------------------ #
    #  Step 1 — Navigate to claims-submission page, search by Subscriber   #
    #  ID + Birthdate (same search form as the eligibility flow)          #
    # ------------------------------------------------------------------ #
    def step1_search_patient(self):
        """From the dashboard, click 'Submit Claims' and search for the patient."""
        wait = WebDriverWait(self.driver, 30)

        try:
            claims_url = "https://www.deltadentalma.com/private/provider/claims-submission"

            if "dashboard" not in self.driver.current_url.lower():
                print(f"[DDMA Claim step1] Not on dashboard — navigating to {MEMBERS_URL}")
                self.driver.get(MEMBERS_URL)
                time.sleep(2)

            try:
                submit_claims_link = wait.until(EC.element_to_be_clickable(
                    (By.XPATH, "//a[@href='/private/provider/claims-submission']")
                ))
                submit_claims_link.click()
                print("[DDMA Claim step1] Clicked 'Submit Claims' quick link")
            except Exception as e:
                print(f"[DDMA Claim step1] Could not click 'Submit Claims' link ({e}) — falling back to direct navigation")
                self.driver.get(claims_url)

            time.sleep(2)

            if "claims-submission" not in self.driver.current_url.lower():
                print(f"[DDMA Claim step1] Warning: Ended up at {self.driver.current_url} instead of claims-submission page")

            # Claims-submission page opens on the "Service Office" step — click the
            # "Member Search" sidebar item to get to the birthdate/subscriber search form.
            try:
                member_search_link = wait.until(EC.element_to_be_clickable(
                    (By.XPATH, "//span[contains(@class,'mainLabel') and normalize-space(text())='Member Search']")
                ))
                member_search_link.click()
                print("[DDMA Claim step1] Clicked 'Member Search' sidebar link")
                time.sleep(1)
            except Exception as e:
                print(f"[DDMA Claim step1] Warning: Could not click 'Member Search' sidebar link: {e}")

            # Fill Member ID
            if self.memberId:
                try:
                    member_id_input = wait.until(EC.element_to_be_clickable(
                        (By.XPATH, "//input[@data-test-id='memberId']")
                    ))
                    member_id_input.click()
                    member_id_input.send_keys(Keys.CONTROL, "a")
                    member_id_input.send_keys(Keys.BACKSPACE)
                    member_id_input.send_keys(self.memberId)
                    print(f"[DDMA Claim step1] Filled Member ID: {self.memberId}")
                except Exception as e:
                    print(f"[DDMA Claim step1] Warning: Could not fill Member ID: {e}")

            # Fill Birthdate (masked mm/dd/yyyy input — send digits only, mask inserts slashes)
            if self.dateOfBirth:
                try:
                    dob_parts = self.dateOfBirth.split("-")
                    year  = dob_parts[0]
                    month = dob_parts[1].zfill(2)
                    day   = dob_parts[2].zfill(2)

                    birthdate_input = wait.until(EC.element_to_be_clickable(
                        (By.XPATH, "//input[@data-test-id='memberBirthDate']")
                    ))
                    birthdate_input.click()
                    birthdate_input.send_keys(Keys.CONTROL, "a")
                    birthdate_input.send_keys(Keys.BACKSPACE)
                    birthdate_input.send_keys(f"{month}{day}{year}")
                    print(f"[DDMA Claim step1] Filled Birthdate: {month}/{day}/{year}")
                except Exception as e:
                    print(f"[DDMA Claim step1] Warning: Could not fill Birthdate: {e}")

            time.sleep(0.3)

            # Click Search
            search_btn = wait.until(EC.element_to_be_clickable(
                (By.XPATH, "//button[@data-test-id='memberSearchButton']")
            ))
            search_btn.click()
            print("[DDMA Claim step1] Clicked Search button")

            # Wait for the Members results table to render
            try:
                WebDriverWait(self.driver, 15).until(
                    EC.presence_of_element_located((By.XPATH, "//table//tbody//tr"))
                )
                time.sleep(2)
            except TimeoutException:
                print("[DDMA Claim step1] Warning: No results table appeared within timeout")
                return "ERROR: No patient found with given search criteria"

            print("[DDMA Claim step1] Search completed")
            return "SUCCESS"

        except Exception as e:
            print(f"[DDMA Claim step1] Exception: {e}")
            return f"ERROR: step1 failed: {e}"

    # ------------------------------------------------------------------ #
    #  Step 2 — Select the matching family member row → Member detail page #
    # ------------------------------------------------------------------ #
    def step2_open_member_page(self):
        """Pick the family member row matching this patient and check its selection box.

        The results table (columns: checkbox, Member, Member Id, Role, Group Name,
        Date Of Birth, Termination Date) stays on the same page — no navigation happens.
        """
        try:
            # Wait for the results table to appear, then let it stabilize
            try:
                WebDriverWait(self.driver, 20).until(
                    EC.presence_of_element_located((By.XPATH, "//table//tbody//tr"))
                )
                time.sleep(2)
            except TimeoutException:
                print("[DDMA Claim step2] Warning: Results table not found within timeout")

            rows = self.driver.find_elements(By.XPATH, "//table//tbody//tr")
            print(f"[DDMA Claim step2] Found {len(rows)} family member row(s)")

            target_row = None

            if self.dateOfBirth and rows:
                try:
                    dob_parts = self.dateOfBirth.split("-")
                    dob_year  = dob_parts[0]
                    dob_month = dob_parts[1].zfill(2)
                    dob_day   = dob_parts[2].zfill(2)
                    expected_dob = f"{dob_month}/{dob_day}/{dob_year}"
                    for row in rows:
                        cells = row.find_elements(By.XPATH, "./td")
                        # cells: [0]=checkbox, [1]=Member, [2]=Member Id, [3]=Role,
                        #        [4]=Group Name, [5]=Date Of Birth, [6]=Termination Date
                        if len(cells) >= 6 and cells[5].text.strip() == expected_dob:
                            target_row = row
                            break
                except Exception as e:
                    print(f"[DDMA Claim step2] DOB matching error (non-fatal): {e}")

            if target_row is None and self.lastName and rows:
                for row in rows:
                    if self.lastName.strip().lower() in row.text.lower():
                        target_row = row
                        break

            if target_row is None and rows:
                target_row = rows[0]
                print("[DDMA Claim step2] No DOB/name match — defaulting to first family member row")

            if target_row is None:
                return "ERROR: step2 failed: no family member rows found"

            try:
                checkbox = target_row.find_element(By.XPATH, ".//i[contains(@class,'fa-check-square')]")
                checkbox.click()
                print("[DDMA Claim step2] Checked the matching family member row")
            except Exception as e:
                print(f"[DDMA Claim step2] Warning: Could not click member checkbox: {e}")
                return f"ERROR: step2 failed: could not click member checkbox: {e}"

            time.sleep(1)

            try:
                claim_detail_link = WebDriverWait(self.driver, 10).until(
                    EC.element_to_be_clickable(
                        (By.XPATH, "//span[contains(@class,'mainLabel') and normalize-space(text())='Claim Detail']")
                    )
                )
                claim_detail_link.click()
                print("[DDMA Claim step2] Clicked 'Claim Detail' sidebar link")
                time.sleep(2)
            except Exception as e:
                print(f"[DDMA Claim step2] Warning: Could not click 'Claim Detail' sidebar link: {e}")
                return f"ERROR: step2 failed: could not click 'Claim Detail' link: {e}"

            return "SUCCESS"

        except Exception as e:
            print(f"[DDMA Claim step2] Exception: {e}")
            return f"ERROR: step2 failed: {e}"

    # ------------------------------------------------------------------ #
    #  Step 3 — No-op: step2 already navigates into the Claim Detail form #
    #  on the new site (no separate "Create claim" button exists there). #
    # ------------------------------------------------------------------ #
    def step3_click_create_claim(self):
        """Confirm the Claim Detail / Treatment Form is present (navigation already happened in step2)."""
        try:
            WebDriverWait(self.driver, 15).until(
                EC.presence_of_element_located((By.XPATH,
                    "//*[contains(text(),'Treatment Form')] | //input[@data-test-id='claimRowServiceDate0']"
                ))
            )
            print("[DDMA Claim step3] Treatment Form is present — no-op (step2 already navigated here)")
            return "SUCCESS"
        except TimeoutException:
            page_text = self.driver.execute_script("return document.body.innerText;")[:400]
            print(f"[DDMA Claim step3] Treatment Form not detected — page: {page_text}")
            return "ERROR: step3 failed: Treatment Form not found"
        except Exception as e:
            print(f"[DDMA Claim step3] Exception: {e}")
            return f"ERROR: step3 failed: {e}"

    # ------------------------------------------------------------------ #
    #  Step 4 — Fill service date and procedure code                      #
    # ------------------------------------------------------------------ #
    def _parse_service_date(self):
        s = str(self.serviceDate or "").strip()
        if not s:
            return None, None, None
        if "-" in s:
            parts = s.split("-")
            if len(parts) == 3 and len(parts[0]) == 4:
                return parts[1].zfill(2), parts[2].zfill(2), parts[0]
            if len(parts) == 3 and len(parts[2]) == 4:
                return parts[0].zfill(2), parts[1].zfill(2), parts[2]
        if "/" in s:
            parts = s.split("/")
            if len(parts) == 3:
                return parts[0].zfill(2), parts[1].zfill(2), parts[2]
        return None, None, None

    def _fill_spinbutton(self, label_fragment, value):
        for sel in [
            f"//span[@contenteditable='true' and contains(@aria-label,'{label_fragment}')]",
            f"//span[@data-type='{label_fragment}' and @contenteditable='true']",
        ]:
            try:
                elem = WebDriverWait(self.driver, 5).until(
                    EC.presence_of_element_located((By.XPATH, sel))
                )
                elem.click()
                elem.send_keys(Keys.CONTROL, "a")
                elem.send_keys(Keys.BACKSPACE)
                elem.send_keys(value)
                time.sleep(0.1)
                print(f"[DDMA Claim step4] Filled spinbutton '{label_fragment}' = {value!r}")
                return True
            except Exception:
                continue
        print(f"[DDMA Claim step4] Warning: spinbutton '{label_fragment}' not found")
        return False

    def _fill_combobox(self, inp, value, label="field"):
        """Type value into a combobox and select the first matching dropdown option."""
        try:
            inp.click()
            inp.send_keys(Keys.CONTROL + "a")
            inp.send_keys(Keys.DELETE)
            inp.send_keys(str(value))
            time.sleep(0.5)
            # Try to click matching option in listbox
            listbox_id = inp.get_attribute("aria-controls") or ""
            try:
                if listbox_id:
                    option = WebDriverWait(self.driver, 4).until(
                        EC.element_to_be_clickable((By.XPATH,
                            f"//*[@id='{listbox_id}']//*[@role='option'][1]"
                        ))
                    )
                else:
                    option = WebDriverWait(self.driver, 4).until(
                        EC.element_to_be_clickable((By.XPATH,
                            f"//*[@role='listbox']//*[@role='option' and contains(normalize-space(.),'{value}')]"
                            f" | //*[@role='listbox']//*[@role='option'][1]"
                        ))
                    )
                option.click()
                print(f"[DDMA Claim step4] {label}: selected '{value}'")
            except TimeoutException:
                # No dropdown — press Enter or Tab to confirm free text
                inp.send_keys(Keys.TAB)
                print(f"[DDMA Claim step4] {label}: typed '{value}' (no dropdown)")
        except Exception as e:
            print(f"[DDMA Claim step4] Warning: could not fill {label}: {e}")

    def _fill_text_input(self, inp, value, label="field"):
        """Clear and type value into a plain text input."""
        try:
            inp.click()
            inp.send_keys(Keys.CONTROL + "a")
            inp.send_keys(Keys.DELETE)
            inp.send_keys(str(value))
            time.sleep(0.1)
            print(f"[DDMA Claim step4] {label}: typed '{value}'")
        except Exception as e:
            print(f"[DDMA Claim step4] Warning: could not fill {label}: {e}")

    def step4_fill_claim_form(self):
        """Fill each treatment row: service date, procedure code, tooth number, surface, amount.

        The new Claim Detail Treatment Form has one row per procedure, each with
        indexed fields (ServiceDate{i}, Surface{i}, Amount{i} by data-test-id;
        procedure code and tooth number have no id, so they're matched positionally).
        """
        try:
            month, day, year = self._parse_service_date()
            service_date_str = f"{month}/{day}/{year}" if (month and day and year) else None
            if not service_date_str:
                print(f"[DDMA Claim step4] No valid service date: {self.serviceDate!r}")

            active_lines = [ln for ln in self.serviceLines if str(ln.get("procedureCode") or "").strip()]
            print(f"[DDMA Claim step4] {len(active_lines)} service line(s)")

            for idx, line in enumerate(active_lines):
                code    = str(line.get("procedureCode") or "").strip().upper()
                tooth   = str(line.get("toothNumber")  or line.get("tooth")    or "").strip()
                surface = str(line.get("toothSurface") or line.get("surface")  or "").strip().upper()
                billed  = str(line.get("totalBilled")  or line.get("billedAmount") or line.get("fee") or "").strip()
                billed  = billed.replace("$", "").strip()

                print(f"[DDMA Claim step4] Line {idx}: code={code} tooth={tooth!r} surface={surface!r} billed={billed!r}")

                # ── Click "+ Add another treatment" for lines after the first ──
                if idx > 0:
                    try:
                        add_link = WebDriverWait(self.driver, 10).until(
                            EC.element_to_be_clickable((By.XPATH, "//a[@data-test-id='addNewRowButton']"))
                        )
                        self.driver.execute_script("arguments[0].scrollIntoView({block:'center'});", add_link)
                        add_link.click()
                        print(f"[DDMA Claim step4] Clicked 'Add another treatment' for line {idx}")
                        time.sleep(1)
                    except Exception as e:
                        print(f"[DDMA Claim step4] Could not click 'Add another treatment': {e}")

                # ── Service date ────────────────────────────────────────────
                if service_date_str:
                    try:
                        date_inp = WebDriverWait(self.driver, 8).until(
                            EC.element_to_be_clickable((By.XPATH, f"//input[@data-test-id='claimRowServiceDate{idx}']"))
                        )
                        date_inp.click()
                        date_inp.send_keys(Keys.CONTROL, "a")
                        date_inp.send_keys(Keys.BACKSPACE)
                        date_inp.send_keys(f"{month}{day}{year}")
                        print(f"[DDMA Claim step4] serviceDate[{idx}]: filled {service_date_str}")
                    except Exception as e:
                        print(f"[DDMA Claim step4] Could not fill service date[{idx}]: {e}")
                time.sleep(0.2)

                # ── Procedure code (no id/data-test-id — matched positionally) ─
                if code:
                    try:
                        proc_inputs = self.driver.find_elements(By.XPATH, "//input[@aria-label='e.g. D1234']")
                        proc_inp = proc_inputs[idx] if idx < len(proc_inputs) else (proc_inputs[-1] if proc_inputs else None)
                        if proc_inp:
                            self.driver.execute_script("arguments[0].scrollIntoView({block:'center'});", proc_inp)
                            self._fill_combobox(proc_inp, code, f"procedureCode[{idx}]")
                        else:
                            print(f"[DDMA Claim step4] procedureCode[{idx}]: input not found")
                    except Exception as e:
                        print(f"[DDMA Claim step4] Could not fill procedure code[{idx}]: {e}")
                time.sleep(0.2)

                # ── Tooth Number (custom scrollable dropdown, no native <select>) ─
                if tooth:
                    try:
                        tooth_triggers = self.driver.find_elements(By.XPATH, "//span[contains(@class,'filtrable')]")
                        if idx < len(tooth_triggers):
                            trigger = tooth_triggers[idx]
                            self.driver.execute_script("arguments[0].scrollIntoView({block:'center'});", trigger)
                            trigger.click()
                            time.sleep(0.4)
                            option = WebDriverWait(self.driver, 5).until(
                                EC.element_to_be_clickable((By.XPATH,
                                    f"//*[@role='option' and normalize-space(.)='{tooth}'] | "
                                    f"//li[normalize-space(.)='{tooth}'] | "
                                    f"//*[contains(@class,'dropdown')]//*[normalize-space(.)='{tooth}']"
                                ))
                            )
                            option.click()
                            print(f"[DDMA Claim step4] tooth[{idx}]: selected '{tooth}'")
                        else:
                            print(f"[DDMA Claim step4] tooth[{idx}]: dropdown trigger not found")
                    except Exception as e:
                        print(f"[DDMA Claim step4] Could not fill tooth[{idx}]: {e}")
                time.sleep(0.2)

                # ── Surface ──────────────────────────────────────────────────
                if surface:
                    try:
                        surf_inp = WebDriverWait(self.driver, 5).until(
                            EC.element_to_be_clickable((By.XPATH, f"//input[@data-test-id='claimRowSurface{idx}']"))
                        )
                        self._fill_text_input(surf_inp, surface, f"surface[{idx}]")
                    except Exception as e:
                        print(f"[DDMA Claim step4] Could not fill surface[{idx}]: {e}")
                time.sleep(0.2)

                # ── Amount ───────────────────────────────────────────────────
                if billed:
                    try:
                        amount_inp = WebDriverWait(self.driver, 5).until(
                            EC.element_to_be_clickable((By.XPATH, f"//input[@data-test-id='claimRowAmount{idx}']"))
                        )
                        self._fill_text_input(amount_inp, billed, f"amount[{idx}]")
                    except Exception as e:
                        print(f"[DDMA Claim step4] Could not fill amount[{idx}]: {e}")
                time.sleep(0.2)

            print("[DDMA Claim step4] Done")
            return "SUCCESS"

        except Exception as e:
            print(f"[DDMA Claim step4] Exception: {e}")
            return f"ERROR: step4 failed: {e}"

    # ------------------------------------------------------------------ #
    #  Step 5 — Attach files                                              #
    # ------------------------------------------------------------------ #
    def step5_attach_files(self):
        """Upload all claimFiles at once via the multi-file drag-and-drop input."""
        if not self.claimFiles:
            print("[DDMA Claim step5] No files to attach")
            return "SUCCESS"

        abs_paths = []
        for cf in self.claimFiles:
            relative_path = cf.get("filePath") or ""
            if not relative_path:
                print(f"[DDMA Claim step5] Skipping file with no filePath: {cf}")
                continue

            # Build absolute path — filePath is like /uploads/patients/Name/file.pdf
            abs_path = os.path.normpath(os.path.join(_BACKEND_CWD, relative_path.lstrip("/")))
            if not os.path.isfile(abs_path):
                print(f"[DDMA Claim step5] File not found on disk: {abs_path}")
                continue
            abs_paths.append(abs_path)

        if not abs_paths:
            print("[DDMA Claim step5] No valid files found on disk to attach")
            return "SUCCESS"

        try:
            file_input = WebDriverWait(self.driver, 10).until(
                EC.presence_of_element_located((By.XPATH, "//input[@data-test-id='fileUploadInput']"))
            )
            # The input may be visually hidden behind a drag-and-drop overlay.
            self.driver.execute_script("arguments[0].style.display='block';", file_input)
            # <input multiple> accepts several paths joined by newlines in one send_keys call.
            file_input.send_keys("\n".join(abs_paths))
            time.sleep(1.5)
            print(f"[DDMA Claim step5] Attached {len(abs_paths)}/{len(self.claimFiles)} file(s): "
                  f"{[os.path.basename(p) for p in abs_paths]}")
        except Exception as e:
            print(f"[DDMA Claim step5] Could not attach files: {e}")
            return f"ERROR: step5 failed: {e}"

        return "SUCCESS"

    # ------------------------------------------------------------------ #
    #  Step 6 — Click Next step                                           #
    # ------------------------------------------------------------------ #
    def step6_click_next(self):
        """Click the sidebar 'Submit Claim' navigation button to advance from the Claim Detail form."""
        try:
            print(f"[DDMA Claim step6] Current URL: {self.driver.current_url}")
            btn = WebDriverWait(self.driver, 15).until(
                EC.element_to_be_clickable((By.XPATH, "//button[@data-test-id='submitClaimNavigationButton']"))
            )
            self.driver.execute_script("arguments[0].scrollIntoView({block:'center'});", btn)
            time.sleep(0.5)
            self.driver.execute_script("""
                var el = arguments[0];
                el.dispatchEvent(new PointerEvent('pointerover',  {bubbles:true, cancelable:true, composed:true}));
                el.dispatchEvent(new PointerEvent('pointerdown',  {bubbles:true, cancelable:true, composed:true}));
                el.dispatchEvent(new PointerEvent('pointerup',    {bubbles:true, cancelable:true, composed:true}));
                el.dispatchEvent(new MouseEvent('click',          {bubbles:true, cancelable:true, composed:true}));
            """, btn)
            print(f"[DDMA Claim step6] Clicked 'Next step'")
            time.sleep(2)
            print(f"[DDMA Claim step6] URL after Next: {self.driver.current_url}")
            return "SUCCESS"
        except Exception as e:
            print(f"[DDMA Claim step6] Exception: {e}")
            return f"ERROR: step6 failed: {e}"

    # ------------------------------------------------------------------ #
    #  Step 7 — No-op: step6's "Submit Claim" click already finalizes the #
    #  claim on the new site (no separate acknowledgement/summary page). #
    # ------------------------------------------------------------------ #
    def step7_submit_claim(self):
        """Confirm the confirmation page is present (submission already happened in step6)."""
        try:
            WebDriverWait(self.driver, 20).until(
                lambda d: "claim submitted successfully" in d.page_source.lower()
            )
            print("[DDMA Claim step7] Confirmation page detected — no-op (step6 already submitted)")
            return "SUCCESS"
        except TimeoutException:
            print(f"[DDMA Claim step7] Confirmation page not detected — URL: {self.driver.current_url}")
            return "ERROR: step7 failed: confirmation page not detected"
        except Exception as e:
            print(f"[DDMA Claim step7] Exception: {e}")
            return f"ERROR: step7 failed: {e}"

    def step8_save_confirmation_pdf(self):
        """Wait for the confirmation page, extract the claim number, save page as PDF."""
        import re
        try:
            # Wait for confirmation page
            WebDriverWait(self.driver, 30).until(
                lambda d: "claim submitted successfully" in d.page_source.lower()
            )
            time.sleep(2)
            print(f"[DDMA Claim step8] Confirmation page URL: {self.driver.current_url}")

            # Extract claim number from page text (row: "Claim Number" label + value, e.g. "202626032473000")
            claim_number = None
            try:
                body_text = self.driver.find_element(By.TAG_NAME, "body").text
                match = re.search(r'claim number\s*\n?\s*(\d{6,})', body_text, re.IGNORECASE)
                if match:
                    claim_number = match.group(1)
                    print(f"[DDMA Claim step8] Extracted claim number: {claim_number}")
                else:
                    # Fallback: any long digit sequence
                    match = re.search(r'\b(\d{12,})\b', body_text)
                    if match:
                        claim_number = match.group(1)
                        print(f"[DDMA Claim step8] Extracted claim number (fallback): {claim_number}")
            except Exception as e:
                print(f"[DDMA Claim step8] Could not extract claim number: {e}")

            # Save page as PDF via Chrome DevTools Protocol
            # Use the shared 'downloads/' dir that agent.py serves as static files
            shared_downloads = os.path.join(_SERVICE_DIR, "downloads")
            os.makedirs(shared_downloads, exist_ok=True)
            safe_member = "".join(c for c in str(self.memberId) if c.isalnum() or c in "-_.")
            safe_claim = ("_" + claim_number[:20]) if claim_number else ""
            timestamp = time.strftime("%Y%m%d_%H%M%S")
            pdf_filename = f"ddma_claim_confirmation_{safe_member}{safe_claim}_{timestamp}.pdf"
            pdf_path = os.path.join(shared_downloads, pdf_filename)

            try:
                pdf_data = self.driver.execute_cdp_cmd("Page.printToPDF", {
                    "printBackground": True,
                    "paperWidth": 8.5,
                    "paperHeight": 11,
                    "marginTop": 0.4,
                    "marginBottom": 0.4,
                    "marginLeft": 0.4,
                    "marginRight": 0.4,
                })
                pdf_bytes = base64.b64decode(pdf_data["data"])
                with open(pdf_path, "wb") as f:
                    f.write(pdf_bytes)
                print(f"[DDMA Claim step8] PDF saved: {pdf_path}")
            except Exception as e:
                print(f"[DDMA Claim step8] PDF capture failed: {e}")
                return f"ERROR: step8 PDF failed: {e}"

            return {
                "status": "success",
                "pdf_path": pdf_path,
                "claimNumber": claim_number,
            }

        except Exception as e:
            print(f"[DDMA Claim step8] Exception: {e}")
            return f"ERROR: step8 failed: {e}"

    # ------------------------------------------------------------------ #
    #  Fee schedule helpers                                                #
    # ------------------------------------------------------------------ #
    def _load_ddma_fee_schedule(self):
        base = os.path.dirname(os.path.abspath(__file__))
        json_path = os.path.join(base, "..", "Frontend", "src", "assets", "data", "procedureCodesDDMA.json")
        try:
            with open(json_path) as f:
                rows = json.load(f)
            fee_map = {}
            for row in rows:
                code = str(row.get("Procedure Code", "")).strip().upper()
                if code:
                    fee_map[code] = row
            print(f"[DDMA Claim] Loaded {len(fee_map)} fee codes")
            return fee_map
        except Exception as e:
            print(f"[DDMA Claim] Could not load fee schedule: {e}")
            return {}

    def _get_patient_age(self):
        if not self.dateOfBirth:
            return None
        try:
            parts = self.dateOfBirth.split("-")
            dob = date(int(parts[0]), int(parts[1]), int(parts[2]))
            today = date.today()
            return today.year - dob.year - ((today.month, today.day) < (dob.month, dob.day))
        except Exception:
            return None

    def _get_fee(self, code, fee_map, age):
        row = fee_map.get(str(code).strip().upper(), {})
        if not row:
            return ""
        if "Price" in row:
            val = str(row["Price"])
        elif age is not None and age <= 21:
            val = str(row.get("PriceLTEQ21") or row.get("PriceGT21") or "")
        else:
            val = str(row.get("PriceGT21") or row.get("PriceLTEQ21") or "")
        return "" if val in ("NC", "IC", "None", "") else val