/* IDR Team tab — physician-first surface + optional staff console. */
(function(){
  const { useEffect, useMemo, useState } = React;

  function fmtMoney(n){
    const v = Number.isFinite(+n) ? +n : 0;
    return "$" + Math.round(v).toLocaleString("en-US");
  }

  function pill(route){
    const map = {
      federal: "idr-pill fed",
      ny_state: "idr-pill ny",
      non_nsa: "idr-pill non",
      pending: "idr-pill pend",
    };
    return map[route] || "idr-pill";
  }

  function routeLabel(route){
    if(route==="federal") return "Federal";
    if(route==="ny_state") return "NY State";
    if(route==="pending") return "Pending";
    return "Non-NSA";
  }

  function statusLabel(s){
    const map = {
      ready: "Ready",
      open_negotiation: "Open negotiation",
      at_idr: "At IDR",
      awaiting_determination: "Awaiting determination",
      won_paid: "Won / paid",
      blocked: "Blocked",
      non_federal: "Non-federal path",
    };
    return map[s] || s;
  }

  function routeReasonHint(reason){
    const map = {
      FEDERAL_ELIGIBLE: "Ready for federal IDR pursue flow.",
      NY_FULLY_INSURED_PLAN: "Route to NY state process, not federal NSA.",
      PLAN_TYPE_UNKNOWN: "Needs plan funding verification before routing.",
      FACILITY_NOT_LONG_ISLAND_OR_MANHATTAN_ASC: "Needs facility eligibility confirmation.",
      QPA_MISSING: "Needs QPA disclosure before filing.",
      PROCEDURE_NOT_QUALIFYING: "Procedure currently outside configured qualifying set.",
      PAYER_NOT_OON_TARGET: "Payer not currently in out-of-network federal target list.",
      COVERAGE_DENIAL_NOT_IDR: "Coverage denial path does not route through IDR.",
    };
    return map[reason] || "Manual review needed before route can advance.";
  }

  function fmtDate(value){
    if(!value) return "needs review";
    const d = new Date(value);
    if(Number.isNaN(d.getTime())) return "needs review";
    return d.toLocaleDateString("en-US",{year:"numeric",month:"short",day:"numeric"});
  }

  function fmtMoneyOrUnknown(value, fallback="needs review"){
    if(value == null || !Number.isFinite(Number(value))) return fallback;
    return fmtMoney(value);
  }

  function caseStageLabel(c){
    const byStatus = {
      ready: "Intake",
      open_negotiation: "Open negotiation",
      at_idr: "Filed at IDR",
      awaiting_determination: "Awaiting determination",
      won_paid: "Recovered",
      blocked: "Blocked",
      non_federal: "Non-federal",
    };
    return byStatus[c.status] || "Needs review";
  }

  function caseNextAction(c){
    if(c.verificationState==="needs_review"){
      return { label:"Resolve unverified inputs", blocked:true, reason:"Case has unverified or untraceable values. Review provenance first." };
    }
    if(c.route==="federal"){
      if(c.status==="ready") return { label:"Start open negotiation", blocked:false, reason:"Federal-eligible case is ready to pursue." };
      if(c.status==="open_negotiation") return { label:"Prepare IDR filing packet", blocked:false, reason:"Open negotiation started; stage federal filing evidence." };
      if(c.status==="at_idr") return { label:"Monitor portal + payer responses", blocked:false, reason:"Case is at IDR; track updates and requests." };
      if(c.status==="awaiting_determination") return { label:"Await determination", blocked:false, reason:"No filing action pending until determination posts." };
      if(c.status==="won_paid") return { label:"Reconcile recovered payment", blocked:false, reason:"Confirm remittance and close case activity." };
    }
    if(c.route==="ny_state"){
      return { label:"Route to NY State process", blocked:false, reason:"Case is state-routed, not federal NSA." };
    }
    if(c.route==="non_nsa"){
      return { label:"Work non-NSA collection path", blocked:false, reason:"Claim is outside NSA scope; continue non-NSA workflow." };
    }
    return { label:"Manual eligibility review", blocked:true, reason:routeReasonHint(c.routeReason) };
  }

  function summarizeDocuments(c){
    if(c.lastAction && String(c.lastAction).includes("pursue_all_by")){
      return [
        "open_negotiation_notice draft",
        "idr_initiation_notice draft",
        "position_statement draft",
      ];
    }
    return [];
  }

  function RouteChip({ active, label, count, dollars, onClick }){
    return (
      <button className={"idr-route-chip"+(active?" on":"")} onClick={onClick}>
        <span>{label}</span>
        <span>{count} · {fmtMoney(dollars)}</span>
      </button>
    );
  }

  function CaseDrawer({ c, onClose }){
    if(!c) return null;
    const action = caseNextAction(c);
    const docs = summarizeDocuments(c);
    return (
      <div className="idr-drawer-backdrop" onClick={onClose}>
        <aside className="idr-drawer" onClick={e=>e.stopPropagation()}>
          <div className="idr-drawer-head">
            <div>
              <div className="idr-kicker">Claim workspace</div>
              <div className="idr-drawer-title">{c.claimRef} · {c.patientName}</div>
              <div className="muted">{c.payer} · Gap {fmtMoney(c.amountAtStakeUsd)} · {routeLabel(c.route)} · {caseStageLabel(c)}</div>
            </div>
            <button className="ghost-btn" onClick={onClose}>Close</button>
          </div>

          <div className={"idr-next-action"+(action.blocked?" blocked":"")}>
            <b>Next action:</b> {action.label}
            <div className="muted">{action.reason}</div>
          </div>

          <details open className="idr-drawer-section">
            <summary>Eligibility evidence + provenance</summary>
            <div className="muted">Route reason code: <code>{c.routeReason}</code> · {routeReasonHint(c.routeReason)}</div>
            <div className="idr-prov-list">
              {Object.entries(c.provenance || {}).map(([key, prov])=>(
                <div className="idr-prov-item" key={key}>
                  <div><b>{key}</b> · {prov.track} · {prov.verified ? "verified" : "needs review"}</div>
                  <div className="muted">{prov.assertion}</div>
                  <div className="muted">Pointers: {(prov.pointers||[]).length ? prov.pointers.map(p=>`${p.rowRef}${p.field?`:${p.field}`:""}`).join(" · ") : "needs review"}</div>
                </div>
              ))}
            </div>
          </details>

          <details open className="idr-drawer-section">
            <summary>Deadline timeline (BD/CD clocks)</summary>
            <div className="muted">Open negotiation closes (CD+30): {c.deadlines?.openNegotiationBy ? fmtDate(c.deadlines.openNegotiationBy) : "needs review"}</div>
            <div className="muted">IDR file-by (BD+4): {c.deadlines?.idrFileBy ? fmtDate(c.deadlines.idrFileBy) : "needs review"}</div>
            {!c.deadlines?.openNegotiationBy && <div className="muted">Anchor date unavailable, deadline clock fail-closed.</div>}
          </details>

          <details open className="idr-drawer-section">
            <summary>Documents</summary>
            {docs.length ? (
              <ul className="idr-mini-list">{docs.map(d=><li key={d}>{d}</li>)}</ul>
            ) : (
              <div className="muted">No generated drafts detected for this case yet (needs review).</div>
            )}
          </details>

          <details open className="idr-drawer-section">
            <summary>Offer + evidence bundle</summary>
            <div className="muted">QPA: {c.qpaDisclosure==="not_disclosed" ? "not_disclosed" : fmtMoneyOrUnknown(c.qpaUsd)}</div>
            <div className="muted">Initial payment: {fmtMoneyOrUnknown(c.initialPaymentUsd)}</div>
            <div className="muted">Estimated recovery: {c.route==="federal" ? fmtMoneyOrUnknown(c.offerDeltaUsd, "needs review") : "not applicable"}</div>
            <div className="muted">Proposed offer: {fmtMoneyOrUnknown(c.proposedOfferUsd, "needs review")}</div>
            <div className="muted">Evidence factors: {(c.evidenceFactors||[]).length ? c.evidenceFactors.join(" · ") : "needs review"}</div>
          </details>

          <details open className="idr-drawer-section">
            <summary>Activity log</summary>
            <ul className="idr-mini-list">
              <li>Current stage: {caseStageLabel(c)}</li>
              <li>Last action: {c.lastAction || "needs review"}</li>
              <li>Updated: {c.statusUpdatedAt ? fmtDate(c.statusUpdatedAt) : "needs review"}</li>
            </ul>
          </details>
        </aside>
      </div>
    );
  }

  function buildEmptyDashboard(){
    return {
      generatedAt: new Date().toISOString(),
      entitlement: { enabled: false, console: false },
      preauthRule: null,
      moneyLine: { federalUsd: 0, federalClaims: 0, nyStateUsd: 0, nyStateClaims: 0, otherUsd: 0, otherClaims: 0 },
      statusStrip: { openNegotiation: 0, atIdr: 0, awaitingDetermination: 0, wonPaid: 0, recoveredToDateUsd: 0 },
      exceptions: [],
      cases: [],
    };
  }

  function PhysicianView({ dashboard, onPursue, pursuing, onStage, onRefresh, refreshing, actionFeedback }){
    const m = dashboard.moneyLine;
    const st = dashboard.statusStrip;
    const preauth = dashboard.preauthRule;
    const cases = Array.isArray(dashboard.cases) ? dashboard.cases : [];
    const readyFederal = cases.filter(c => c.route==="federal" && c.status==="ready").length;
    const [activeRoute, setActiveRoute] = useState("all");
    const [sortField, setSortField] = useState("gap");
    const [sortDir, setSortDir] = useState("desc");
    const [selectedClaimRef, setSelectedClaimRef] = useState("");

    const routeStats = useMemo(()=>{
      const bucket = { all:{count:cases.length,dollars:0}, federal:{count:0,dollars:0}, ny_state:{count:0,dollars:0}, non_nsa:{count:0,dollars:0} };
      for(const c of cases){
        const dollars = Number(c.amountAtStakeUsd || 0);
        bucket.all.dollars += dollars;
        if(c.route==="federal"){ bucket.federal.count += 1; bucket.federal.dollars += dollars; }
        else if(c.route==="ny_state"){ bucket.ny_state.count += 1; bucket.ny_state.dollars += dollars; }
        else { bucket.non_nsa.count += 1; bucket.non_nsa.dollars += dollars; }
      }
      return bucket;
    }, [cases]);

    const filteredCases = useMemo(()=>{
      if(activeRoute==="all") return cases;
      return cases.filter(c => c.route===activeRoute);
    }, [cases, activeRoute]);

    const sortedCases = useMemo(()=>{
      const list = filteredCases.slice();
      list.sort((a,b)=>{
        const va = sortField==="recovery" ? Number(a.offerDeltaUsd || 0) : Number(a.amountAtStakeUsd || 0);
        const vb = sortField==="recovery" ? Number(b.offerDeltaUsd || 0) : Number(b.amountAtStakeUsd || 0);
        return sortDir==="desc" ? (vb - va) : (va - vb);
      });
      return list;
    }, [filteredCases, sortField, sortDir]);

    const selectedCase = useMemo(()=>cases.find(c => c.claimRef===selectedClaimRef) || null,[cases, selectedClaimRef]);

    function onSort(field){
      if(sortField===field){
        setSortDir(d => d==="desc" ? "asc" : "desc");
      } else {
        setSortField(field);
        setSortDir("desc");
      }
    }

    const emptyGuidance = activeRoute==="federal"
      ? "No federal claims currently qualify. Non-NSA and NY-state opportunities remain in this same worklist—switch route chips to continue action."
      : "No claims match this route right now. Review route reason codes or refresh to re-evaluate.";

    return (
      <div className="idr-wrap">
        <div className="idr-moneyline">
          <div className="idr-kicker">IDR Team</div>
          <div className="idr-head">{fmtMoney(m.federalUsd)} recoverable federal opportunity · {m.federalClaims} federal claim{m.federalClaims===1?"":"s"}</div>
          <div className="idr-sub">{fmtMoney(m.nyStateUsd)} NY state path ({m.nyStateClaims}) · {fmtMoney(m.otherUsd)} non-NSA worklist ({m.otherClaims})</div>
        </div>

        <div className="idr-action">
          {preauth && preauth.autoPursue ? (
            <div className="idr-auto">Auto-pursuing under your standing rule (min delta {fmtMoney(preauth.minDeltaUsd)} · target {preauth.targetPctQpa}% QPA)</div>
          ) : (
            <button className="login-btn" disabled={pursuing || refreshing} onClick={onPursue}>
              {pursuing ? "Pursuing…" : "Pursue all eligible"}
            </button>
          )}
          {!preauth && <button className="ghost-btn" onClick={()=>onStage("Set standing rule", "Open Staff Console to set a pre-authorization rule.")}>Set standing rule</button>}
          <button className="ghost-btn" disabled={refreshing || pursuing} onClick={onRefresh}>{refreshing ? "Refreshing…" : "Refresh dashboard"}</button>
        </div>
        <div className="muted">
          {readyFederal > 0
            ? `${readyFederal} federal-ready claim${readyFederal===1?"":"s"} can be pursued now.`
            : "No federal-ready claims right now. Continue with NY-state and non-NSA opportunities from the claims worklist below."}
        </div>
        {!!actionFeedback && (
          <div className="datamode-banner" style={{
            display:"flex",alignItems:"center",gap:8,margin:"0",padding:"8px 12px",borderRadius:8,
            background: actionFeedback.tone==="error" ? "rgba(154,42,42,.08)" : actionFeedback.tone==="success" ? "rgba(26,101,58,.10)" : "rgba(196,151,62,.10)",
            border: actionFeedback.tone==="error" ? "1px solid rgba(154,42,42,.28)" : actionFeedback.tone==="success" ? "1px solid rgba(26,101,58,.24)" : "1px solid rgba(196,151,62,.32)",
            color: actionFeedback.tone==="error" ? "#7a1e1e" : actionFeedback.tone==="success" ? "#1d5e3e" : "#7a5a1e"
          }}>
            {actionFeedback.text}
          </div>
        )}

        <div className="idr-status-strip">
          <div><b>{st.openNegotiation}</b><span>In open negotiation</span></div>
          <div><b>{st.atIdr}</b><span>At IDR</span></div>
          <div><b>{st.awaitingDetermination}</b><span>Awaiting determination</span></div>
          <div><b>{st.wonPaid}</b><span>Won / paid</span></div>
          <div><b>{fmtMoney(st.recoveredToDateUsd)}</b><span>Recovered to date</span></div>
        </div>

        <div className="idr-box">
          <div className="h1">Exceptions inbox</div>
          {!dashboard.exceptions.length ? (
            <div className="muted">No legal/compliance exceptions are currently blocking the flow.</div>
          ) : (
            <div className="idr-ex-list">
              {dashboard.exceptions.map(ex=>(
                <div className="idr-ex" key={ex.claimRef + ex.reason}>
                  <div className="idr-row-top">
                    <span className={pill(ex.route)}>{routeLabel(ex.route)}</span>
                    <b>{ex.patientName}</b>
                    <span className="muted">{ex.payer}</span>
                    <span className="muted">{ex.claimRef}</span>
                  </div>
                  <div className="muted">Reason: {ex.reason}</div>
                  <div className="muted">Needs: {ex.requires.join(" · ")}</div>
                </div>
              ))}
            </div>
          )}
        </div>

        <div className="idr-box">
          <div className="h1">Claims worklist</div>
          <div className="idr-chip-row">
            <RouteChip active={activeRoute==="all"} label="All" count={routeStats.all.count} dollars={routeStats.all.dollars} onClick={()=>setActiveRoute("all")} />
            <RouteChip active={activeRoute==="federal"} label="Federal" count={routeStats.federal.count} dollars={routeStats.federal.dollars} onClick={()=>setActiveRoute("federal")} />
            <RouteChip active={activeRoute==="ny_state"} label="NY State" count={routeStats.ny_state.count} dollars={routeStats.ny_state.dollars} onClick={()=>setActiveRoute("ny_state")} />
            <RouteChip active={activeRoute==="non_nsa"} label="Non-NSA" count={routeStats.non_nsa.count} dollars={routeStats.non_nsa.dollars} onClick={()=>setActiveRoute("non_nsa")} />
          </div>
          <div className="muted">Row click opens claim workspace. Untraceable or missing values render as needs review/not_disclosed.</div>
          {!sortedCases.length ? (
            <div className="muted">{emptyGuidance}</div>
          ) : (
            <div className="idr-table-wrap">
              <table className="idr-table">
                <thead>
                  <tr>
                    <th>Claim ID</th>
                    <th>Patient</th>
                    <th>DOS</th>
                    <th>Payer</th>
                    <th>Billed</th>
                    <th>Initial payment</th>
                    <th><button className="idr-sort-btn" onClick={()=>onSort("gap")}>Gap (billed-paid)</button></th>
                    <th>POS</th>
                    <th>Facility</th>
                    <th>Provider INN</th>
                    <th>Facility INN</th>
                    <th>Plan type</th>
                    <th>Route</th>
                    <th>Why / reason code</th>
                    <th>QPA</th>
                    <th><button className="idr-sort-btn" onClick={()=>onSort("recovery")}>Est recovery</button></th>
                    <th>Next action</th>
                    <th>Stage</th>
                  </tr>
                </thead>
                <tbody>
                  {sortedCases.map(c=>{
                    const action = caseNextAction(c);
                    const isFederal = c.route==="federal";
                    return (
                      <tr key={c.claimRef} onClick={()=>setSelectedClaimRef(c.claimRef)}>
                        <td>{c.claimRef}</td>
                        <td>{c.patientName}</td>
                        <td>{c.dos || "needs review"}</td>
                        <td>{c.payer}</td>
                        <td>{fmtMoneyOrUnknown(c.billedUsd)}</td>
                        <td>{fmtMoneyOrUnknown(c.initialPaymentUsd)}</td>
                        <td>{fmtMoney(c.amountAtStakeUsd)}</td>
                        <td>{c.placeOfService || "needs review"}</td>
                        <td>{c.facilityName || "needs review"}</td>
                        <td>{c.providerInn || "not_disclosed"}</td>
                        <td>{c.facilityInn || "not_disclosed"}</td>
                        <td>{c.planType}</td>
                        <td><span className={pill(c.route)}>{routeLabel(c.route)}</span></td>
                        <td><code>{c.routeReason}</code></td>
                        <td>{c.qpaDisclosure==="not_disclosed" ? "not_disclosed" : fmtMoneyOrUnknown(c.qpaUsd)}</td>
                        <td>{isFederal ? fmtMoneyOrUnknown(c.offerDeltaUsd) : "—"}</td>
                        <td>{action.label}</td>
                        <td><span className="idr-status">{statusLabel(c.status)}</span></td>
                      </tr>
                    );
                  })}
                </tbody>
              </table>
            </div>
          )}
        </div>
        <CaseDrawer c={selectedCase} onClose={()=>setSelectedClaimRef("")} />
      </div>
    );
  }

  function StaffConsole({ dashboard, onAdvance, saving, onSaveRule, savingRule }){
    const [rule, setRule] = useState(()=>{
      const r = dashboard.preauthRule || {};
      return {
        autoPursue: r.autoPursue !== false,
        minDeltaUsd: r.minDeltaUsd ?? 250,
        targetPctQpa: r.targetPctQpa ?? 200,
        autoSubmitUnderUsd: r.autoSubmitUnderUsd ?? 2500,
        requireApprovalOverUsd: r.requireApprovalOverUsd ?? 10000,
        delegateTo: r.delegateTo || "",
      };
    });

    useEffect(()=>{
      const r = dashboard.preauthRule || {};
      setRule({
        autoPursue: r.autoPursue !== false,
        minDeltaUsd: r.minDeltaUsd ?? 250,
        targetPctQpa: r.targetPctQpa ?? 200,
        autoSubmitUnderUsd: r.autoSubmitUnderUsd ?? 2500,
        requireApprovalOverUsd: r.requireApprovalOverUsd ?? 10000,
        delegateTo: r.delegateTo || "",
      });
    },[dashboard.generatedAt]);

    return (
      <div className="idr-wrap">
        <div className="idr-box">
          <div className="h1">Pre-authorization rule</div>
          <div className="idr-grid">
            <label><span>Auto pursue</span><input type="checkbox" checked={!!rule.autoPursue} onChange={e=>setRule({...rule, autoPursue:e.target.checked})}/></label>
            <label><span>Min delta ($)</span><input type="number" value={rule.minDeltaUsd} onChange={e=>setRule({...rule, minDeltaUsd:Number(e.target.value||0)})}/></label>
            <label><span>Target % of QPA</span><input type="number" value={rule.targetPctQpa} onChange={e=>setRule({...rule, targetPctQpa:Number(e.target.value||0)})}/></label>
            <label><span>Auto submit under ($)</span><input type="number" value={rule.autoSubmitUnderUsd} onChange={e=>setRule({...rule, autoSubmitUnderUsd:Number(e.target.value||0)})}/></label>
            <label><span>Require approval over ($)</span><input type="number" value={rule.requireApprovalOverUsd} onChange={e=>setRule({...rule, requireApprovalOverUsd:Number(e.target.value||0)})}/></label>
            <label><span>Delegate to</span><input value={rule.delegateTo} onChange={e=>setRule({...rule, delegateTo:e.target.value})} placeholder="staff user"/></label>
          </div>
          <button className="login-btn" disabled={savingRule} onClick={()=>onSaveRule(rule)}>{savingRule ? "Saving…" : "Save rule"}</button>
        </div>

        <div className="idr-box">
          <div className="h1">Case console</div>
          <div className="idr-case-list">
            {dashboard.cases.slice(0,60).map(c=>(
              <div className="idr-case" key={c.claimRef}>
                <div className="idr-row-top">
                  <span className={pill(c.route)}>{routeLabel(c.route)}</span>
                  <b>{c.patientName}</b>
                  <span className="muted">{c.payer}</span>
                  <span className="muted">{c.claimRef}</span>
                </div>
                <div className="muted">{c.cpt.join(", ") || "No CPT"} · {c.provider || "No provider"} · DOS {c.dos || "—"}</div>
                <div className="muted">At stake {fmtMoney(c.amountAtStakeUsd)} · QPA {c.qpaDisclosure==="not_disclosed"?"not_disclosed":fmtMoney(c.qpaUsd)} · Offer {c.proposedOfferUsd==null?"missing":fmtMoney(c.proposedOfferUsd)}</div>
                {c.verificationState==="needs_review" && <div className="muted" style={{color:"#9a2a2a"}}>Verification: needs review (untraceable provenance)</div>}
                {!!c.missingEvidence.length && <div className="muted">Missing evidence: {c.missingEvidence.join(" · ")}</div>}
                <div className="idr-row-top">
                  <span className="idr-status">{statusLabel(c.status)}</span>
                  <button className="ghost-btn" disabled={saving} onClick={()=>onAdvance(c.claimRef, "open_negotiation")}>Mark open negotiation</button>
                  <button className="ghost-btn" disabled={saving} onClick={()=>onAdvance(c.claimRef, "at_idr")}>Mark at IDR</button>
                  <button className="ghost-btn" disabled={saving} onClick={()=>onAdvance(c.claimRef, "awaiting_determination")}>Awaiting determination</button>
                  <button className="ghost-btn" disabled={saving} onClick={()=>onAdvance(c.claimRef, "won_paid")}>Mark won/paid</button>
                </div>
              </div>
            ))}
          </div>
        </div>
      </div>
    );
  }

  window.IdrTeamModule = function IdrTeamModule({ user, canViewConsole, onStage }){
    const [dashboard, setDashboard] = useState(null);
    const [err, setErr] = useState("");
    const [loading, setLoading] = useState(true);
    const [saving, setSaving] = useState(false);
    const [savingRule, setSavingRule] = useState(false);
    const [pursuing, setPursuing] = useState(false);
    const [view, setView] = useState("physician");
    const [actionFeedback, setActionFeedback] = useState(null);

    const userName = (user && user.name) ? user.name : "unknown";

    const load = async ()=>{
      setLoading(true);
      setErr("");
      try {
        // Live IDR aggregation can take >25s on first pass in production; keep a
        // bounded timeout, but long enough to avoid false "unavailable" failures.
        const j = await window.Adapters.getJSON(`/api/idr/dashboard?user=${encodeURIComponent(userName)}`, null, 60_000);
        if(!j){
          setErr("IDR dashboard unavailable. You can still review status and retry.");
          setDashboard(d => d || buildEmptyDashboard());
          return;
        }
        setDashboard(j);
      } catch(_e){
        setErr("IDR dashboard unavailable. You can still review status and retry.");
        setDashboard(d => d || buildEmptyDashboard());
      } finally {
        setLoading(false);
      }
    };

    useEffect(()=>{ load(); },[userName]);

    async function onPursue(){
      const readyFederal = (dashboard?.cases || []).filter(c => c.route==="federal" && c.status==="ready").length;
      if(readyFederal === 0){
        setActionFeedback({ tone:"info", text:"No federal-ready claims are available right now. Review route blockers in the case pipeline below." });
        return;
      }
      setPursuing(true);
      setActionFeedback(null);
      const r = await window.Adapters.postJSON("/api/idr/pursue-all", { user:userName });
      setPursuing(false);
      if(!r || r.error){
        setActionFeedback({ tone:"error", text:(r && r.error) || "Failed to pursue eligible claims." });
        return;
      }
      const pursuedCount = (r.pursued || []).length;
      if(pursuedCount === 0){
        const blockedReason = r.blocked && r.blocked[0] && r.blocked[0].reason;
        setActionFeedback({ tone:"info", text: blockedReason || "No federal-ready claims were moved." });
      } else {
        setActionFeedback({ tone:"success", text:`${pursuedCount} federal claim${pursuedCount===1?"":"s"} moved to open negotiation.` });
      }
      if(onStage) onStage("Pursue all eligible", `${(r.pursued||[]).length} federal claim(s) moved to open negotiation.`);
      await load();
    }

    async function onAdvance(claimRef, status){
      setSaving(true);
      const r = await window.Adapters.postJSON(`/api/idr/case/${encodeURIComponent(claimRef)}/status`, { status });
      setSaving(false);
      if(!r || r.error){ setActionFeedback({ tone:"error", text:(r && r.error) || "Status update failed." }); return; }
      setActionFeedback({ tone:"success", text:"Case status updated." });
      await load();
    }

    async function onSaveRule(rule){
      setSavingRule(true);
      const r = await window.Adapters.postJSON("/api/idr/preauth-rule", rule);
      setSavingRule(false);
      if(!r || r.error){ setActionFeedback({ tone:"error", text:(r && r.error) || "Rule save failed." }); return; }
      setActionFeedback({ tone:"success", text:"Standing rule saved." });
      if(onStage) onStage("Saved pre-authorization rule", "IDR Team will auto-pursue federal-eligible claims under the standing criteria.");
      await load();
    }

    if(loading && !dashboard) return <div className="login-load"><div className="ring"></div><div className="lt">Building IDR opportunity split…</div></div>;
    const activeDashboard = dashboard || buildEmptyDashboard();
    const canConsole = !!(canViewConsole && activeDashboard && activeDashboard.entitlement && activeDashboard.entitlement.console);

    return (
      <div>
        {!!err && <div className="datamode-banner" style={{background:"rgba(154,42,42,.08)",border:"1px solid rgba(154,42,42,.28)",color:"#7a1e1e"}}>{err}</div>}
        {canConsole && (
          <div className="seg">
            <button className={"seg-btn"+(view==="physician"?" on":"")} onClick={()=>setView("physician")}>Physician</button>
            <button className={"seg-btn"+(view==="console"?" on":"")} onClick={()=>setView("console")}>Staff Console</button>
          </div>
        )}
        {(view==="physician" || !canConsole)
          ? <PhysicianView dashboard={activeDashboard} onPursue={onPursue} pursuing={pursuing} onStage={onStage} onRefresh={load} refreshing={loading} actionFeedback={actionFeedback}/>
          : <StaffConsole dashboard={activeDashboard} onAdvance={onAdvance} saving={saving} onSaveRule={onSaveRule} savingRule={savingRule}/>}
      </div>
    );
  };
})();