[REFACTOR] tab1: relocate utility functions, refactor dialog key management and group selector

tabs/tab1_inputs.py

@@ -4,46 +4,10 @@ import streamlit as st
 from config.config import (resource_groups, resource_order, resource_tooltips,
                            resource_unit_map, method_groups, CO2_UNIT, secondary_resources,
                            hidden_resource_names)
-from utils.data_utils import render_resource_input, strip_unit_suffix, get_resource_to_group, get_resource_to_unit, get_method_group
-from utils.ui_helpers import show_bar
-from io import BytesIO
-
-
-def standard_resource_names():
-    """Return the set of all standard resource names defined in resource_groups config.
-
-    Returns:
-        set[str]: flat set of every resource name across all resource groups.
-    """
-    return {r for rlist in resource_groups.values() for r in rlist}
-
-
-def init_custom_resources():
-    """Initialise custom resource session state keys and coerce amounts/coefficients to float.
-
-    Ensures custom_resources, enabled_methods, and auto_disabled_methods exist in
-    session state, then sanitises every batch so numeric fields are float (not str).
-
-    Returns:
-        None
-    """
-    if "custom_resources" not in st.session_state:
-        st.session_state.custom_resources = []
-    if "enabled_methods" not in st.session_state:
-        st.session_state.enabled_methods = {}
-    if "auto_disabled_methods" not in st.session_state:
-        st.session_state.auto_disabled_methods = set()
-    for batch in st.session_state.custom_resources:
-        try:
-            batch["amount"] = float(batch["amount"])
-        except (ValueError, TypeError):
-            batch["amount"] = 0.0
-        for m, coefs in batch.get("methods", {}).items():
-            for key in ("min", "median", "max"):
-                try:
-                    coefs[key] = float(coefs[key])
-                except (ValueError, TypeError):
-                    coefs[key] = 0.0
+from utils.data_utils import (strip_unit_suffix, get_resource_to_group, get_resource_to_unit,
+                              get_method_group, standard_resource_names, to_excel_bytes, parse_custom_excel)
+from utils.state_utils import apply_auto_disable_logic, init_custom_resources
+from utils.ui_helpers import show_bar, render_resource_input
 
 
 @st.dialog("Add a new resource", width="large")
@@ -62,13 +26,10 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
     Returns:
         None
     """
-    if edit_index is not None and not st.session_state.get(f"_dlg_initialized_{edit_index}"):
-        for key in list(st.session_state.keys()):
-            if key.startswith(("_dlg_existing_enable_",
-                            "_dlg_existing_min_", "_dlg_existing_med_", "_dlg_existing_max_",
-                            "_dlg_new_chk_", "_dlg_new_min_", "_dlg_new_med_", "_dlg_new_max_")):
-                del st.session_state[key]
-        st.session_state[f"_dlg_initialized_{edit_index}"] = True
+    # Use edit_index as a key suffix so each edit session gets fresh widgets.
+    # Streamlit ignores value= when a key already exists in session_state, so
+    # suffixing with eix guarantees unique keys per resource and avoids stale data.
+    eix = edit_index if edit_index is not None else "new"
 
     standard_names = standard_resource_names()
     existing_names = {
@@ -82,7 +43,6 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
     # If opened from a specific resource-group expander ("+ Add resource" inline
     # button), restrict the reference-resource choice to that group's resources
     # only — the user picked the group by clicking that button.
-    group_options = preset_resources if preset_resources else resource_order
     if preset_resources:
         physical_group = resource_to_group.get(preset_resources[0], "")
         st.markdown(
@@ -99,19 +59,48 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
             value=existing.get("name", ""),
             placeholder="e.g. Degraded forest lands – North",
             help="It can't match the name of an existing resource.",
-            key="label-input-name"
-        )
-    with col_group:
-        default_group_idx = group_options.index(existing["group"]) if existing.get("group") in group_options else 0
-        batch_group = st.selectbox(
-            "Resource group *",
-            options=group_options,
-            index=default_group_idx,
-            help="Determines the physical unit of this resource.",
-            disabled=bool(preset_resources) and len(group_options) == 1,
-            key="label-input-group"
+            key=f"label-input-name-{eix}"
         )
 
+    if preset_resources:
+        # Already scoped to a specific resource list (inline "Add resource" button)
+        preset_idx = preset_resources.index(existing["group"]) if existing.get("group") in preset_resources else 0
+        with col_group:
+            batch_group = st.selectbox(
+                "Resource group *",
+                options=preset_resources,
+                index=preset_idx,
+                help="Determines the physical unit of this resource.",
+                disabled=len(preset_resources) == 1,
+                key=f"label-input-group-{eix}"
+            )
+    else:
+        # Two-level selection: physical group → specific resource
+        phys_group_options = list(resource_groups.keys())
+        existing_phys = resource_to_group.get(existing.get("group", ""), phys_group_options[0])
+        default_phys_idx = phys_group_options.index(existing_phys) if existing_phys in phys_group_options else 0
+        with col_group:
+            selected_phys = st.selectbox(
+                "Resource group *",
+                options=phys_group_options,
+                index=default_phys_idx,
+                help="Determines the physical category of this resource.",
+                key=f"label-input-phys-group-{eix}"
+            )
+        sub_resources = resource_groups[selected_phys]
+        if len(sub_resources) > 1:
+            existing_sub = existing.get("group", "")
+            default_sub_idx = sub_resources.index(existing_sub) if existing_sub in sub_resources else 0
+            batch_group = st.selectbox(
+                "Resource sub-type *",
+                options=sub_resources,
+                index=default_sub_idx,
+                help="Specific resource type within this group.",
+                key=f"label-input-subgroup-{eix}"
+            )
+        else:
+            batch_group = sub_resources[0]
+
     group = resource_to_group.get(batch_group)
     unit = resource_unit_map.get(group, "?")
 
@@ -125,7 +114,7 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
         format="%.2f",
         value=float(existing["amount"]) if existing.get("amount") and existing.get("amount") != 0.0 else None,
         help=f"Total quantity available for 1 year, in {unit}.",
-        key="label-input-amount",
+        key=f"label-input-amount-{eix}",
         placeholder="0.0"
     )
 
@@ -167,12 +156,10 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
 
                 already_selected = m in existing.get("methods", {})
 
-                if f"_dlg_existing_enable_{m}" not in st.session_state:
-                    st.session_state[f"_dlg_existing_enable_{m}"] = already_selected
-
                 enabled = st.checkbox(
                     f"{m}",
-                    key=f"_dlg_existing_enable_{m}",
+                    value=already_selected,
+                    key=f"_dlg_existing_enable_{eix}_{m}",
                 )
 
                 if not enabled:
@@ -180,31 +167,31 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
 
                 existing_coeff = existing.get("methods", {}).get(m, coeff)
 
-                st.warning("Modifying these values only affects this resource batch: the base method coefficients are unchanged.")
+                st.warning("Modifying these values only affects this resource batch: the base method coefficients are unchanged.", icon=":material/warning:")
                 col_min, col_med, col_max = st.columns(3)
                 with col_min:
                     e_min = st.number_input(
                         f"Min ({unit}/{CO2_UNIT})",
                         min_value=0.0,
                         format="%.10g",
-                        value=float(existing_coeff["min"]),
-                        key=f"_dlg_existing_min_{m}",
+                        value=max(float(0.0), float(existing_coeff["min"])),
+                        key=f"_dlg_existing_min_{eix}_{m}",
                     )
                 with col_med:
                     e_med = st.number_input(
                         f"Median ({unit}/{CO2_UNIT})",
                         min_value=0.0,
                         format="%.10g",
-                        value=float(existing_coeff["median"]),
-                        key=f"_dlg_existing_med_{m}",
+                        value=max(float(0.0), float(existing_coeff["median"])),
+                        key=f"_dlg_existing_med_{eix}_{m}",
                     )
                 with col_max:
                     e_max = st.number_input(
                         f"Max ({unit}/{CO2_UNIT})",
                         min_value=0.0,
                         format="%.10g",
-                        value=float(existing_coeff["max"]),
-                        key=f"_dlg_existing_max_{m}",
+                        value=max(float(0.0), float(existing_coeff["max"])),
+                        key=f"_dlg_existing_max_{eix}_{m}",
                     )
                 method_configs[m] = {
                     "min": e_min,
@@ -237,7 +224,7 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
             for m in available_methods:
                 enabled = st.checkbox(
                     f"**{m}**",
-                    key=f"_dlg_new_chk_{m}",
+                    key=f"_dlg_new_chk_{eix}_{m}",
                 )
                 if enabled:
                     col_min, col_med, col_max = st.columns(3)
@@ -247,7 +234,7 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
                             min_value=0.0,
                             value=None,
                             format="%.10g",
-                            key=f"_dlg_new_min_{m}",
+                            key=f"_dlg_new_min_{eix}_{m}",
                             placeholder="0.0000",
                         )
                     with col_med:
@@ -256,16 +243,16 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
                             min_value=0.0,
                             value=None,
                             format="%.10g",
-                            key=f"_dlg_new_med_{m}",
+                            key=f"_dlg_new_med_{eix}_{m}",
                             placeholder="0.0000",
                         )
                     with col_max:
                         v_max = st.number_input(
-                            f"Ma ({unit}/{CO2_UNIT})",
+                            f"Max ({unit}/{CO2_UNIT})",
                             min_value=0.0,
                             value=None,
                             format="%.10g",
-                            key=f"_dlg_new_max_{m}",
+                            key=f"_dlg_new_max_{eix}_{m}",
                             placeholder="0.0000",
                         )
                     method_configs[m] = {
@@ -277,7 +264,7 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
     col_save, col_cancel = st.columns([2, 2])
 
     with col_cancel:
-        if st.button("Cancel", width='stretch', key="btn-reset-cancel"):
+        if st.button("Cancel", width='stretch', key=f"btn-reset-cancel-{eix}"):
             st.rerun()
 
     def validate():
@@ -303,7 +290,7 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
         return errors
 
     with col_save:
-        if st.button("Add to session", type="tertiary", width='stretch', icon=":material/check:", key="btn-new-add"):
+        if st.button("Add to session", type="tertiary", width='stretch', icon=":material/check:", key=f"btn-new-add-{eix}"):
             errors = validate()
             if errors:
                 with error_placeholder.container():
@@ -329,77 +316,6 @@ def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None, pres
 
 
 
-def to_excel_bytes(batches: list) -> bytes:
-    """Serialise all custom resource batches to an Excel file (one row per batch × method).
-
-    Args:
-        batches (list): list of custom batch dicts with keys name, group, amount, unit, methods.
-
-    Returns:
-        bytes: raw bytes of the .xlsx workbook.
-    """
-    rows = []
-    for batch in batches:
-        for m, coefs in batch["methods"].items():
-            rows.append({
-                "name":   batch["name"],
-                "group":  batch["group"],
-                "amount": float(batch["amount"]),
-                "unit": batch["unit"],
-                "method": m,
-                "min":    float(coefs["min"]),
-                "median": float(coefs["median"]),
-                "max":    float(coefs["max"]),
-            })
-    excel_buffer = BytesIO()
-    with pd.ExcelWriter(excel_buffer, engine="openpyxl") as writer:
-        pd.DataFrame(rows).to_excel(writer, index=False, sheet_name="custom_resources")
-    return excel_buffer.getvalue()
-
-
-def parse_custom_excel(file) -> list:
-    """Parse a custom resource Excel file into a list of batch dicts.
-
-    Expects columns: name, group, amount, unit, method, min, median, max.
-
-    Args:
-        file: file-like object pointing to an .xlsx workbook.
-
-    Returns:
-        list[dict]: one dict per unique batch name with keys
-                    name, group, amount, unit, methods.
-
-    Raises:
-        ValueError: if required columns are missing.
-    """
-    df = pd.read_excel(file, sheet_name=0)
-    required = {"name", "group", "amount", "unit", "method", "min", "median", "max"}
-    if not required.issubset(df.columns):
-        raise ValueError(f"Missing columns: {required - set(df.columns)}")
-    batches = []
-    for batch_name in df["name"].unique():
-        df_b = df[df["name"] == batch_name]
-        methods = {
-            row["method"]: {
-                "min":    float(row["min"]),
-                "median": float(row["median"]),
-                "max":    float(row["max"]),
-            }
-            for _, row in df_b.iterrows()
-        }
-        group_name = str(df_b["group"].iloc[0])
-        resource_to_group = get_resource_to_group()
-        batches.append({
-            "name":    str(batch_name),
-            "group":   group_name,
-            "amount":  float(df_b["amount"].iloc[0]),
-            "unit":    resource_unit_map.get(resource_to_group.get(group_name), "?"),
-            "methods": methods,
-        })
-    return batches
-
-
-
 @st.dialog("Load custom resource batches", width="large")
 def dialog_load_custom_batch():
     """Dialog for importing custom resource batches from an Excel file.
@@ -531,9 +447,12 @@ def render_custom_batch_inline(global_idx, batch, cost_sliders, unit):
                 st.session_state.custom_resources.pop(global_idx)
                 st.session_state.pop("latest_result", None)
                 st.rerun()
-            if st.button("Edit", key=f"edit_batch_{global_idx}", 
+            if st.button("Edit", key=f"edit_batch_{global_idx}",
                             type="secondary", icon=":material/edit:"):
-                dialog_add_custom_resource(cost_sliders, edit_index=global_idx)
+                _b = st.session_state.custom_resources[global_idx]
+                _phys = get_resource_to_group().get(_b.get("group", ""))
+                _preset = resource_groups.get(_phys) if _phys else None
+                dialog_add_custom_resource(cost_sliders, edit_index=global_idx, preset_resources=_preset)
 
 
 
@@ -565,6 +484,128 @@ def panel_custom_resources_controls(cost_sliders):
 
 
 
+def render_related_methods_popover(r, cost_sliders, secondary_resources):
+    """Render the 'Related CDR Methods' popover for a single resource.
+
+    Builds the method-to-group mapping, initialises enabled_methods in session
+    state, and renders a popover with per-method checkboxes (primary only) and
+    a caption listing secondary methods.
+
+    Args:
+        r (str): canonical resource name.
+        cost_sliders (dict): full cost slider config {method: {resource: {min, median, max}}}.
+        secondary_resources (set[tuple[str, str]]): set of (method, resource) pairs
+            where the resource is optional for that method.
+
+    Returns:
+        None
+    """
+    related_methods = {}
+    related_by_group = {}
+
+    for cdr_method, resource in cost_sliders.items():
+        for name, coeff in resource.items():
+            if r == strip_unit_suffix(name):
+                related_methods[cdr_method] = coeff
+
+    for m in related_methods:
+        related_by_group.setdefault(get_method_group(m), []).append(m)
+
+    related_method_names = list(related_methods.keys())
+    secondary_for_r = [m for m in related_method_names if (m, r) in secondary_resources]
+    primary_for_r = [m for m in related_method_names if (m, r) not in secondary_resources]
+
+    if r not in st.session_state.enabled_methods:
+        st.session_state.enabled_methods[r] = {}
+    for m in related_method_names:
+        st.session_state.enabled_methods[r].setdefault(m, True)
+
+    popover_key_prefix = f"pop_{r}"
+
+    with st.popover(":material/tune: Related CDR Methods", width='stretch'):
+        for method_group, methods in related_by_group.items():
+            primary_in_group = [m for m in methods if m in primary_for_r]
+            if not primary_in_group:
+                continue
+            st.markdown(f"*{method_group}*")
+            for m in primary_in_group:
+                widget_key = f"{popover_key_prefix}_{m}"
+                if widget_key not in st.session_state:
+                    st.session_state[widget_key] = st.session_state.enabled_methods[r][m]
+                checked = st.checkbox(m, key=widget_key)
+                st.session_state.enabled_methods[r][m] = checked
+
+        if secondary_for_r:
+            st.caption(
+                "The following methods use this resource as secondary and may be assigned later in the **Resource Coefficients** tab:\n\n"
+                + "\n".join(f"- {m}" for m in secondary_for_r)
+            )
+
+    for m in secondary_for_r:
+        st.session_state.enabled_methods[r][m] = True
+
+
+def render_resource_summary():
+    """Render the 'Summary of available resources' section.
+
+    Builds a combined dataframe of standard and custom resource availability
+    and displays it as a Streamlit dataframe.
+
+    Returns:
+        None
+    """
+    st.markdown('<p class="crra-sub-heading">Summary of available resources</p>', unsafe_allow_html=True)
+
+    resource_to_unit = get_resource_to_unit()
+    resource_to_group = get_resource_to_group()
+
+    df_caps = pd.DataFrame.from_dict(
+        {r: st.session_state.resource_caps[r] for r in resource_order
+         if st.session_state.resource_caps.get(r, 0.0) > 0},
+        orient="index", columns=["Available Amount"],
+    ).reindex(resource_order).dropna()
+    df_caps["Available Amount"] = [
+        f"{value:,.2f} {resource_to_unit.get(resource, '?')}"
+        for resource, value in df_caps["Available Amount"].items()
+    ]
+
+    custom_rows = []
+    for batch in st.session_state.get("custom_resources", []):
+        group = resource_to_group.get(batch["group"])
+        unit = resource_unit_map.get(group, "?")
+        custom_rows.append({
+            "Resource": batch["name"],
+            "Available Amount": f"{float(batch['amount']):,.2f} {unit}",
+        })
+
+    if not df_caps.empty or custom_rows:
+        dfs = []
+        if not df_caps.empty:
+            df_std = df_caps.copy()
+            df_std["Type"] = "Standard"
+            dfs.append(df_std)
+        if custom_rows:
+            df_custom = pd.DataFrame(custom_rows).set_index("Resource")
+            df_custom["Type"] = "New"
+            dfs.append(df_custom)
+        df_all = pd.concat(dfs)[["Available Amount", "Type"]].reset_index().rename(columns={"index": "Resource"})
+        num_rows = len(df_all)
+        st.dataframe(
+            df_all,
+            width='stretch',
+            hide_index=True,
+            height=(num_rows * 36 + 36),
+            column_config={
+                "Resource": st.column_config.TextColumn("Resource", width="large"),
+                "Available Amount": st.column_config.TextColumn("Available Amount"),
+                "Type": st.column_config.TextColumn("Type"),
+            },
+            row_height=36,
+        )
+    else:
+        st.warning("No resources defined yet. Set availability above to populate the summary table.", icon=":material/warning:")
+
+
 def render_tab(cost_sliders):
     """Render the Resource Inputs tab.
 
@@ -704,52 +745,7 @@ def render_tab(cost_sliders):
 
                     render_resource_input(name_clean, r, tooltip=tooltip)
 
-                    related_methods = {}
-                    related_by_group = {}
-
-                    for cdr_method, resource in cost_sliders.items():
-                        for name, coeff in resource.items():
-                            if r == strip_unit_suffix(name):
-                                related_methods[cdr_method] = coeff
-
-                    for m in related_methods:
-                        related_by_group.setdefault(get_method_group(m), []).append(m)
-
-                    related_method_names = list(related_methods.keys())
-                    secondary_for_r = [m for m in related_method_names if (m, r) in secondary_resources]
-                    primary_for_r = [m for m in related_method_names if (m, r) not in secondary_resources]
-
-                    if r not in st.session_state.enabled_methods:
-                        st.session_state.enabled_methods[r] = {}
-                    for m in related_method_names:
-                        st.session_state.enabled_methods[r].setdefault(m, True)
-                    popover_key_prefix = f"pop_{r}"
-
-                    with st.popover(
-                        f":material/tune: Related CDR Methods",
-                        width='stretch',
-                    ):
-                        for method_group, methods in related_by_group.items():
-                            primary_in_group = [m for m in methods if m in primary_for_r]
-                            if not primary_in_group:
-                                continue
-                            st.markdown(f"*{method_group}*")
-                            for m in primary_in_group:
-                                widget_key = f"{popover_key_prefix}_{m}"
-                                if widget_key not in st.session_state:
-                                    st.session_state[widget_key] = st.session_state.enabled_methods[r][m]
-
-                                checked = st.checkbox(m, key=widget_key)
-                                st.session_state.enabled_methods[r][m] = checked
-
-                        if secondary_for_r:
-                            st.caption(
-                                "The following methods use this resource as secondary and may be assigned later in the **Resource Coefficients** tab:\n\n"
-                                + "\n".join(f"- {m}" for m in secondary_for_r)
-                            )
-
-                    for m in secondary_for_r:
-                        st.session_state.enabled_methods[r][m] = True
+                    render_related_methods_popover(r, cost_sliders, secondary_resources)
 
             # Custom batches for this group
             group_unit = resource_unit_map.get(group, "")
@@ -768,122 +764,8 @@ def render_tab(cost_sliders):
                 ):
                     dialog_add_custom_resource(cost_sliders, preset_resources=rlist)
 
-    # ── AUTO-DISABLE LOGIC ────────────────────────────────────────────────────
-    # A CDR method cannot run in the optimisation if it has no usable resources.
-    # This block detects that situation automatically and deactivates the method
-    # in the Method Constraints tab — so the optimisation never fails silently.
-    #
-    # The logic runs in three steps every time this tab renders:
-    #   1. Count how many active primary resources each method still has.
-    #   2. Re-enable any method that was auto-disabled and now has resources again
-    #      (e.g. the user re-entered a value). Methods the user manually disabled
-    #      are stored separately and are NOT touched here.
-    #   3. Disable any method whose resource count just dropped to zero, and show
-    #      a notification so the user knows what changed.
-    # ─────────────────────────────────────────────────────────────────────────
-
-    # Step 1 – count active primary resources per method (secondary resources are
-    # optional extras; they do not determine whether a method can run).
-    method_active_resource_count = {}
-    for r, methods in st.session_state.enabled_methods.items():
-        for m, ok in methods.items():
-            if (m, r) in secondary_resources:
-                continue
-            method_active_resource_count.setdefault(m, 0)
-            if ok:
-                method_active_resource_count[m] += 1
-
-    # Custom batches also count as active resources for the methods they are
-    # assigned to, even when the standard reference resource is toggled off.
-    for batch in st.session_state.get("custom_resources", []):
-        if float(batch.get("amount") or 0) <= 0:
-            continue
-        for m_name in batch.get("methods", {}).keys():
-            method_active_resource_count.setdefault(m_name, 0)
-            method_active_resource_count[m_name] += 1
-
-    methods_with_no_active_resource = [
-        m for m in method_to_primary_resources
-        if method_active_resource_count.get(m, 0) == 0
-    ]
-
-    # Step 2 – re-enable methods that the tool previously auto-disabled but that
-    # now have at least one active resource (user restored a value or added a batch).
-    for m in list(st.session_state.auto_disabled_methods):
-        if method_active_resource_count.get(m, 0) > 0:
-            if m in st.session_state.constraints:
-                st.session_state.constraints[m]["active"] = True
-                st.session_state.constraints[m]["cap_type"] = "percent"
-                st.session_state.constraints[m]["cap_value"] = 100
-            st.session_state[f"toggle_{m}"] = True
-            st.session_state[f"slider_{m}"] = 100
-            st.session_state.auto_disabled_methods.discard(m)
-            st.session_state.setdefault("just_activated_methods", set()).add(m)
-
-    # Step 3 – disable methods that now have zero active primary resources.
-    # We record which methods the tool disabled (auto_disabled_methods) so that
-    # step 2 can safely re-enable them later without touching user-chosen settings.
-    newly_disabled = []
-    for m in methods_with_no_active_resource:
-        # Always track in auto_disabled_methods so Step 2 can re-enable later,
-        # even if the method was already inactive (e.g. initialised as False in app.py).
-        st.session_state.auto_disabled_methods.add(m)
-        if st.session_state.constraints.get(m, {}).get("active", True):
-            st.session_state.constraints.setdefault(m, {"active": True, "cap_type": "percent", "cap_value": 100})
-            st.session_state.constraints[m]["active"] = False
-            newly_disabled.append(m)
-            toggle_key = f"toggle_{m}"
-            if toggle_key in st.session_state:
-                st.session_state[toggle_key] = False
+    apply_auto_disable_logic(method_to_primary_resources, secondary_resources)
 
     panel_custom_resources_controls(cost_sliders)
 
-    st.markdown('<p class="crra-sub-heading">Summary of available resources</p>', unsafe_allow_html=True)
-
-    resource_to_unit = get_resource_to_unit()
-
-    df_caps = pd.DataFrame.from_dict(
-        {r: st.session_state.resource_caps[r] for r in resource_order
-         if st.session_state.resource_caps.get(r, 0.0) > 0},
-        orient="index", columns=["Available Amount"],
-    ).reindex(resource_order).dropna()
-    df_caps["Available Amount"] = [
-        f"{value:,.2f} {resource_to_unit.get(resource, '?')}"
-        for resource, value in df_caps["Available Amount"].items()
-    ]
-
-    custom_rows = []
-    for batch in st.session_state.get("custom_resources", []):
-        group = resource_to_group.get(batch["group"])
-        unit = resource_unit_map.get(group, "?")
-        custom_rows.append({
-            "Resource": batch["name"],
-            "Available Amount": f"{float(batch['amount']):,.2f} {unit}",
-        })
-
-    if not df_caps.empty or custom_rows:
-        dfs = []
-        if not df_caps.empty:
-            df_std = df_caps.copy()
-            df_std["Type"] = "Standard"
-            dfs.append(df_std)
-        if custom_rows:
-            df_custom = pd.DataFrame(custom_rows).set_index("Resource")
-            df_custom["Type"] = "New"
-            dfs.append(df_custom)
-        df_all = pd.concat(dfs)[["Available Amount", "Type"]].reset_index().rename(columns={"index": "Resource"})
-        num_rows = len(df_all)
-        st.dataframe(
-            df_all,
-            width='stretch',
-            hide_index=True,
-            height=(num_rows * 36 + 36),
-            column_config={
-                "Resource": st.column_config.TextColumn("Resource", width="large"),
-                "Available Amount": st.column_config.TextColumn("Available Amount"),
-                "Type": st.column_config.TextColumn("Type"),
-            },
-            row_height=36
-        )
-    else:
-        st.error("No resources defined yet. Set availability above to populate the summary table.")
+    render_resource_summary()