from __future__ import annotations


import numpy as np
import streamlit as st

from metrics import (
    format_metric,
    gray_levels_used,
    gray_levels_used_from_image,
    mean_squared_error,
    peak_signal_to_noise_ratio,
    shannon_entropy,
    shannon_entropy_from_image,
)
from processing import (
    apply_window,
    bounds_to_level_width,
    denormalize_image,
    normalize_with_range,
    quantize_normalized,
    resize_for_display,
)
from utils import (
    BuiltinSample,
    create_histogram_figure,
    create_mse_figure,
    create_visualization_svg_html,
    load_builtin_sample,
    load_uploaded_file,
    list_builtin_samples,
)


st.set_page_config(
    page_title="Image Quantization and CT Windowing Explorer",
    layout="wide",
)

st.markdown(
    """
    <style>
    div[data-testid="stMetricLabel"] p {
        font-size: 1.05rem;
        font-weight: 600;
    }
    div[data-testid="stMetricValue"] {
        font-size: 1.35rem;
    }
    </style>
    """,
    unsafe_allow_html=True,
)


VISUALIZATION_COMPONENT = st.components.v2.component(
    "quantization_windowing_visualization",
    html="""
    <div id="viz-root"></div>
    """,
    js="""
    export default function(component) {
      const { data, parentElement, setTriggerValue } = component;
      const root = parentElement.querySelector("#viz-root");
      if (!root) return;

      root.innerHTML = (data && data.html) || "";

      const clickable = root.querySelectorAll("[data-compare]");
      clickable.forEach((node) => {
        node.onclick = (event) => {
          event.preventDefault();
          const compare = node.getAttribute("data-compare");
          if (compare) {
            setTriggerValue("selected_compare", compare);
          }
        };
      });
    }
    """,
)


WINDOW_PRESETS = {
    "Manual": None,
    "Lung [-1350, 150]": (-1350.0, 150.0),
    "Mediastinal [-160, 240]": (-160.0, 240.0),
    "Bone [250, 1750]": (250.0, 1750.0),
}

ROTATION_OPTIONS = {
    "0°": 0,
    "90° clockwise": -1,
    "180°": 2,
    "90° counterclockwise": 1,
}

METRIC_COMPARISONS = {
    "Original vs Quantized + Windowed": ("original", "quantized_windowed"),
    "Original vs Quantized": ("original", "quantized"),
    "Windowed vs Quantized + Windowed": ("windowed", "quantized_windowed"),
    "Original vs Windowed": ("original", "windowed"),
    "Quantized vs Quantized + Windowed": ("quantized", "quantized_windowed"),
    "Windowed vs Quantized": ("windowed", "quantized"),
}


def set_bit_depth_from_slider() -> None:
    value = int(st.session_state["bit_depth_slider"])
    st.session_state["bit_depth"] = value
    st.session_state["bit_depth_input"] = value


def set_bit_depth_from_input() -> None:
    value = int(st.session_state["bit_depth_input"])
    max_bits = int(st.session_state.get("bit_depth_max", 12))
    value = min(max(value, 1), max_bits)
    st.session_state["bit_depth"] = value
    st.session_state["bit_depth_slider"] = value
    st.session_state["bit_depth_input"] = value


def sync_window_from_slider() -> None:
    low, high = st.session_state["window_slider"]
    st.session_state["window_low"] = float(low)
    st.session_state["window_high"] = float(high)
    st.session_state["window_preset"] = "Manual"


def sync_window_from_inputs(min_value: float, max_value: float, step: float) -> None:
    low = float(st.session_state["window_low"])
    high = float(st.session_state["window_high"])
    low = min(max(low, min_value), max_value - step)
    high = max(min(high, max_value), low + step)
    st.session_state["window_low"] = float(low)
    st.session_state["window_high"] = float(high)
    st.session_state["window_slider"] = (float(low), float(high))
    st.session_state["window_preset"] = "Manual"


def maybe_reset_controls(loaded_key: str, default_low: float, default_high: float, default_slice_index: int | None) -> None:
    if st.session_state.get("loaded_key") == loaded_key:
        return

    max_bits = int(st.session_state.get("bit_depth_max", 12))
    bit_depth = min(6, max_bits)
    st.session_state["loaded_key"] = loaded_key
    st.session_state["bit_depth"] = bit_depth
    st.session_state["bit_depth_slider"] = bit_depth
    st.session_state["bit_depth_input"] = bit_depth
    st.session_state["window_preset"] = "Mediastinal [-160, 240]"
    st.session_state["window_low"] = float(default_low)
    st.session_state["window_high"] = float(default_high)
    st.session_state["window_slider"] = (float(default_low), float(default_high))
    st.session_state["rotation_choice"] = "0°"
    st.session_state["metric_mode"] = "Original vs Quantized + Windowed"
    if default_slice_index is not None:
        st.session_state["slice_index"] = int(default_slice_index)

def apply_selected_preset(min_value: float, max_value: float) -> None:
    preset_name = st.session_state["window_preset"]
    if preset_name == "Manual":
        return
    if preset_name.startswith("Scanner default"):
        low, high = st.session_state["scanner_default_bounds"]
    else:
        low, high = WINDOW_PRESETS[preset_name]

    low = max(float(min_value), float(low))
    high = min(float(max_value), float(high))
    if high <= low:
        high = min(float(max_value), low + max((max_value - min_value) / 200.0, 1e-3))
    st.session_state["window_low"] = float(low)
    st.session_state["window_high"] = float(high)
    st.session_state["window_slider"] = (float(low), float(high))


def section_header(title: str, note: str) -> None:
    title_col, note_col = st.columns([20, 1])
    with title_col:
        st.markdown(f"## {title}")
    with note_col:
        with st.popover("ⓘ"):
            st.caption(note)


def format_pair(left: float | int, right: float | int, digits: int = 3) -> str:
    if isinstance(left, int) and isinstance(right, int):
        return f"{left} / {right}"
    return f"{format_metric(float(left), digits)} / {format_metric(float(right), digits)}"


def is_ct_like_image(minimum: float, maximum: float) -> bool:
    return minimum < -500.0 and maximum > 500.0


def get_metric_reference_pair(mode_label: str, images: dict[str, np.ndarray]) -> tuple[np.ndarray, np.ndarray]:
    left_key, right_key = METRIC_COMPARISONS[mode_label]
    return images[left_key], images[right_key]


def get_metric_reference_labels(mode_label: str) -> tuple[str, str]:
    left_key, right_key = METRIC_COMPARISONS[mode_label]
    label_map = {
        "original": "original",
        "quantized": "quantized",
        "windowed": "windowed",
        "quantized_windowed": "quantized+windowed",
    }
    return label_map[left_key], label_map[right_key]


def get_metric_reference_keys(mode_label: str) -> tuple[str, str]:
    return METRIC_COMPARISONS[mode_label]


def metric_explainer(title: str, latex: str, text: str) -> None:
    with st.expander(f"About {title}"):
        st.latex(latex)
        st.caption(text)


def sync_metric_mode_to_query_params() -> None:
    st.query_params["compare"] = st.session_state["metric_mode"]


def noop_callback() -> None:
    return None




def build_builtin_note(sample_label: str, sample: BuiltinSample | None) -> None:
    if sample is None:
        return

    st.caption(f"Built-in sample: **{sample_label}**")
    st.caption(f"Dataset source: [{sample.dataset_name}]({sample.dataset_url})")
    st.caption(f"Original data type: {sample.input_type_label}")
    st.caption(sample.dataset_summary)


def control_note(text: str) -> None:
    st.caption(text)


def show_user_error(prefix: str, exc: Exception) -> None:
    message = str(exc).strip() or exc.__class__.__name__
    st.error(f"{prefix} {message}")


def select_current_slice(loaded, source_mode: str):
    current_image = loaded.image
    current_slice_index = loaded.default_slice_index

    if loaded.volume is not None:
        slice_count = int(loaded.volume.shape[0])
        default_index = loaded.default_slice_index if loaded.default_slice_index is not None else slice_count // 2
        if "slice_index" not in st.session_state or not (0 <= int(st.session_state["slice_index"]) < slice_count):
            st.session_state["slice_index"] = int(default_index)
        st.slider(
            "Slice index",
            min_value=0,
            max_value=slice_count - 1,
            key="slice_index",
            help="For volumetric files, smaller indices are usually closer to the head and larger indices move toward the feet or hips.",
        )
        control_note("For 3D volumes, move through the stack one axial slice at a time. The app always analyzes the currently selected slice.")
        current_slice_index = int(st.session_state["slice_index"])
        current_image = loaded.volume[current_slice_index]

    if source_mode == "Upload a file" and loaded.source_kind in {"dicom"}:
        st.radio(
            "Rotate uploaded image",
            options=list(ROTATION_OPTIONS.keys()),
            key="rotation_choice",
            horizontal=False,
        )
        control_note(
            "If an uploaded DICOM slice looks sideways, use rotation to fix its viewing orientation before comparing outputs."
        )
        rotation_k = ROTATION_OPTIONS[st.session_state["rotation_choice"]]
        if rotation_k:
            current_image = np.rot90(current_image, k=rotation_k)

    return current_image, current_slice_index


def main() -> None:
    st.title("Image Quantization and CT Windowing Explorer")
    st.markdown(
        """
        This app teaches two different intensity-processing ideas. **Quantization** reduces the number of
        representable gray levels, while **CT windowing** changes how a selected intensity interval is displayed.
        """
    )

    builtin_samples = list_builtin_samples()
    compare_from_query = st.query_params.get("compare")
    if isinstance(compare_from_query, list):
        compare_from_query = compare_from_query[0] if compare_from_query else None
    if compare_from_query in METRIC_COMPARISONS:
        st.session_state["metric_mode"] = compare_from_query

    with st.sidebar:
        st.markdown("## Input and Controls")
        control_note("Use the controls below from top to bottom: choose an input, pick a slice if needed, then adjust quantization and CT window settings.")
        source_mode = st.radio("Input source", ["Built-in sample", "Upload a file"])
        control_note("Choose **Built-in sample** to explore prepared examples, or **Upload a file** to test your own grayscale, DICOM data.")

        selected_builtin = None
        loaded = None
        if source_mode == "Built-in sample":
            sample_label = st.selectbox("Built-in sample", list(builtin_samples.keys()))
            control_note("Each built-in sample comes from a different CT-oriented dataset so you can compare chest CT, CTPA, and volume-style data.")
            selected_builtin = builtin_samples[sample_label]
            try:
                loaded = load_builtin_sample(sample_label)
            except Exception as exc:
                show_user_error("Could not load the selected built-in sample.", exc)
                return
            build_builtin_note(sample_label, selected_builtin)
        else:
            uploaded = st.file_uploader(
                "Upload a file",
                type=["png", "jpg", "jpeg", "dcm"],
                help=(
                    "Upload a 2D PNG/JPG image or a single-slice DICOM (.dcm) file. "
                    "Large 3D NIfTI volumes are intentionally not supported in this online demo."
                ),
            )
            st.caption(
                "Accepted examples: PNG/JPG display images or single-slice DICOM (.dcm). "
                "NIfTI (.nii/.nii.gz) volumes are not supported for reliability on Hugging Face Spaces."
            )
            control_note(
                "Uploaded DICOM files can expose scanner-like intensity values, while PNG/JPG files are usually already display-ready 8-bit images."
            )
            if uploaded is not None:
                try:
                    loaded = load_uploaded_file(uploaded)
                except Exception as exc:
                    show_user_error("Could not read the uploaded file.", exc)
                    return

        if loaded is None:
            st.info("Choose a built-in sample or upload a file to begin.")
            return

        lung_low, lung_high = WINDOW_PRESETS["Mediastinal [-160, 240]"]
        try:
            preview_image = loaded.image
            preview_range_image = resize_for_display(preview_image)
            _, preview_range = normalize_with_range(preview_range_image)
        except Exception as exc:
            show_user_error("Could not inspect the input intensity range.", exc)
            return
        default_low = max(float(preview_range.minimum), float(lung_low))
        default_high = min(float(preview_range.maximum), float(lung_high))
        if default_high <= default_low:
            default_low = float(preview_range.minimum)
            default_high = float(preview_range.maximum)
        maybe_reset_controls(
            loaded_key=f"{source_mode}:{loaded.source_name}",
            default_low=default_low,
            default_high=default_high,
            default_slice_index=loaded.default_slice_index,
        )

        try:
            current_image, current_slice_index = select_current_slice(loaded, source_mode)
            raw_image = resize_for_display(current_image)
            normalized_image, value_range = normalize_with_range(raw_image)
        except Exception as exc:
            show_user_error("Could not prepare the selected image or slice.", exc)
            return
        st.session_state["bit_depth_max"] = int(max(1, loaded.original_bit_depth))
        if st.session_state.get("bit_depth", 1) > st.session_state["bit_depth_max"]:
            st.session_state["bit_depth"] = st.session_state["bit_depth_max"]
            st.session_state["bit_depth_slider"] = st.session_state["bit_depth_max"]
            st.session_state["bit_depth_input"] = st.session_state["bit_depth_max"]

        bit_depth_col, bit_depth_input_col = st.columns([2, 1])
        with bit_depth_col:
            st.slider(
                "Quantization bit depth",
                min_value=1,
                max_value=int(st.session_state["bit_depth_max"]),
                key="bit_depth_slider",
                on_change=set_bit_depth_from_slider,
                help="Example: 12 bits preserves many levels, while 4 bits can create visible banding.",
            )
        with bit_depth_input_col:
            st.number_input(
                " ",
                min_value=1,
                max_value=int(st.session_state["bit_depth_max"]),
                step=1,
                key="bit_depth_input",
                on_change=set_bit_depth_from_input,
                label_visibility="collapsed",
                help="e.g. 4, 8, or 12",
            )

        control_note("Lower bit depth means fewer representable gray levels. Use the slider for quick changes or type an exact bit depth on the right.")
        bit_depth = int(st.session_state["bit_depth"])
        st.caption(
            f"Current quantization: {bit_depth} bits = {2 ** bit_depth} representable gray levels. "
            f"Original max bit depth: {int(st.session_state['bit_depth_max'])}."
        )

        min_value = float(value_range.minimum)
        max_value = float(value_range.maximum)
        window_step = max((max_value - min_value) / 200.0, 1e-3)

        preset_options = ["Manual", "Lung [-1350, 150]"]
        if loaded.suggested_window is not None:
            scanner_low, scanner_high = loaded.suggested_window
            scanner_label = f"Scanner default [{scanner_low:.0f}, {scanner_high:.0f}]"
            st.session_state["scanner_default_bounds"] = (scanner_low, scanner_high)
            preset_options.append(scanner_label)
        if is_ct_like_image(min_value, max_value):
            preset_options.extend(["Mediastinal [-160, 240]", "Bone [250, 1750]"])

        current_preset = st.session_state.get("window_preset", "Lung [-1350, 150]")
        if current_preset not in preset_options:
            st.session_state["window_preset"] = "Lung [-1350, 150]"

        metric_mode = st.session_state.get("metric_mode", "Original vs Quantized + Windowed")

        st.selectbox(
            "CT window preset",
            options=preset_options,
            key="window_preset",
            on_change=apply_selected_preset,
            args=(min_value, max_value),
            help="Examples: Lung [-1350, 150] and Mediastinal [-160, 240]. The app uses lower and upper bounds directly.",
        )

        control_note("Presets are shortcuts for common clinical-style display ranges. Choosing **Manual** lets you fine-tune the lower and upper bounds yourself.")
        st.caption("Window bounds are shown as lower and upper intensity values, not only as WL/WW.")

        st.slider(
            "Window lower / upper bounds",
            min_value=min_value,
            max_value=max_value,
            key="window_slider",
            on_change=sync_window_from_slider,
            help="Drag both handles or type values directly below.",
        )
        control_note("The window slider controls which intensity interval is mapped into visible grayscale. Values outside the interval are clipped to black or white.")
        low_col, high_col = st.columns(2)
        with low_col:
            st.number_input(
                "Lower bound",
                min_value=min_value,
                max_value=max_value,
                step=window_step,
                key="window_low",
                on_change=sync_window_from_inputs,
                args=(min_value, max_value, window_step),
                help="e.g. -160 for a mediastinal-style lower bound",
            )
        with high_col:
            st.number_input(
                "Upper bound",
                min_value=min_value,
                max_value=max_value,
                step=window_step,
                key="window_high",
                on_change=sync_window_from_inputs,
                args=(min_value, max_value, window_step),
                help="e.g. 240 for a mediastinal-style upper bound",
            )
        control_note("Use the numeric lower and upper inputs when you want an exact CT-style window instead of dragging the slider handles.")

    try:
        window_low = float(st.session_state["window_low"])
        window_high = float(st.session_state["window_high"])
        level, width = bounds_to_level_width(window_low, window_high)

        quantized_norm, level_indices = quantize_normalized(normalized_image, bit_depth)
        quantized_raw = denormalize_image(quantized_norm, value_range)
        windowed_display, low, high = apply_window(raw_image, level=level, width=width)
        quantized_windowed_display, _, _ = apply_window(quantized_raw, level=level, width=width)
    except Exception as exc:
        show_user_error("Could not compute quantization or windowed displays.", exc)
        return

    section_header(
        "Input Summary",
        "This section names the current source, the original raw data type, and any notes about how the app interpreted the file.",
    )
    left_info, right_info = st.columns([1.3, 1.7])
    with left_info:
        st.markdown(f"**Current source:** `{loaded.source_name}`")
        st.markdown(f"**Input type in app:** {loaded.input_type_label}")
        st.markdown(f"**Observed intensity range:** [{value_range.minimum:.1f}, {value_range.maximum:.1f}]")
        if current_slice_index is not None:
            st.markdown(f"**Current slice index:** {current_slice_index}")
        if loaded.dataset_name and loaded.dataset_url:
            st.markdown(f"**Dataset source:** [{loaded.dataset_name}]({loaded.dataset_url})")
    with right_info:
        if loaded.dataset_summary:
            st.markdown(f"**Dataset description:** {loaded.dataset_summary}")
        st.markdown(f"**Interpretation note:** {loaded.note}")

    section_header(
        "Visualization",
        "The four panels separate raw precision loss from display windowing. This makes it easier to see what quantization changes by itself and what windowing changes by itself.",
    )
    viz_left_pad, viz_center, viz_right_pad = st.columns([0.6, 8.8, 0.6])
    with viz_center:
        try:
            visualization_html = create_visualization_svg_html(
                original_display=normalized_image,
                windowed_display=windowed_display,
                quantized_display=quantized_norm,
                quantized_windowed_display=quantized_windowed_display,
                bit_depth=bit_depth,
                low=low,
                high=high,
                metric_mode=metric_mode,
            )
        except Exception as exc:
            show_user_error("Could not render the visualization.", exc)
            return
        visualization_result = VISUALIZATION_COMPONENT(
            key="visualization_svg",
            data={"html": visualization_html},
            height=1000,
            on_selected_compare_change=noop_callback,
        )
        st.caption("Click any double-arrow connection to update the active comparison below. The selected connection changes color, and Metrics plus Comparison Views follow that choice.")
        selected_compare = getattr(visualization_result, "selected_compare", None)
        if selected_compare in METRIC_COMPARISONS and selected_compare != st.session_state.get("metric_mode"):
            st.session_state["metric_mode"] = selected_compare
            st.query_params["compare"] = selected_compare
            st.rerun()

    section_header(
        "Metrics",
        "Choose the comparison target directly in this section. Metrics are computed on the selected pair of image states.",
    )
    metric_left_pad, metric_center, metric_right_pad = st.columns([0.6, 8.8, 0.6])
    with metric_center:
        metric_title_col, metric_control_col = st.columns([1.6, 1.0])
        with metric_title_col:
            st.caption("Select which two image states should be compared by MSE and PSNR.")
        with metric_control_col:
            metric_mode = st.selectbox(
                "Compare",
                options=list(METRIC_COMPARISONS.keys()),
                index=list(METRIC_COMPARISONS.keys()).index(metric_mode),
                key="metric_mode",
                on_change=sync_metric_mode_to_query_params,
                label_visibility="visible",
                help="Choose which two displays should be compared by the quantitative metrics.",
            )
        st.caption("This selector and the clickable arrows above are synchronized. You can switch the comparison from either place.")
    metric_images = {
        "original": raw_image,
        "quantized": quantized_raw,
        "windowed": denormalize_image(windowed_display, value_range),
        "quantized_windowed": denormalize_image(quantized_windowed_display, value_range),
    }
    metric_left, metric_right = get_metric_reference_pair(metric_mode, metric_images)
    histogram_images = {
        "original": raw_image,
        "quantized": quantized_raw,
        "windowed": raw_image,
        "quantized_windowed": quantized_raw,
    }
    histogram_left, histogram_right = get_metric_reference_pair(metric_mode, histogram_images)
    histogram_left_key, histogram_right_key = get_metric_reference_keys(metric_mode)

    histogram_bounds = {
        "original": (float(np.min(raw_image)), float(np.max(raw_image))),
        "quantized": (float(np.min(quantized_raw)), float(np.max(quantized_raw))),
        "windowed": (low, high),
        "quantized_windowed": (low, high),
    }

    mse_value = mean_squared_error(metric_left, metric_right)
    psnr_value = peak_signal_to_noise_ratio(metric_left, metric_right, data_range=value_range.span)
    left_label, right_label = get_metric_reference_labels(metric_mode)
    left_levels = gray_levels_used_from_image(metric_left)
    right_levels = gray_levels_used_from_image(metric_right)
    left_entropy = shannon_entropy_from_image(metric_left)
    right_entropy = shannon_entropy_from_image(metric_right)

    with metric_center:
        metric_cols_top = st.columns(4)
        metric_cols_top[0].metric("MSE", format_metric(mse_value))
        metric_cols_top[1].metric("PSNR (dB)", format_metric(psnr_value))
        metric_cols_top[2].metric(
            "Gray levels",
            format_pair(left_levels, right_levels),
        )
        metric_cols_top[3].metric(
            "Entropy",
            format_pair(left_entropy, right_entropy),
        )

        st.caption(
            "Lower PSNR and higher MSE mean stronger intensity distortion between the two selected image states."
        )

        explain_row_1_col_1, explain_row_1_col_2 = st.columns(2)
        with explain_row_1_col_1:
            metric_explainer(
                "MSE",
                r"\mathrm{MSE} = \frac{1}{N}\sum_{i=1}^{N}(x_i-y_i)^2",
                "Mean squared error: MSE = (1/N) * sum_i (x_i - y_i)^2. Larger values mean the compared images differ more strongly in intensity.",
            )
        with explain_row_1_col_2:
            metric_explainer(
                "PSNR (dB)",
                r"\mathrm{PSNR} = 20\log_{10}(\mathrm{MAX}) - 10\log_{10}(\mathrm{MSE})",
                "Peak signal-to-noise ratio: PSNR = 20 log10(MAX) - 10 log10(MSE). Higher values mean the compared images are more similar.",
            )

        explain_row_2_col_1, explain_row_2_col_2 = st.columns(2)
        with explain_row_2_col_1:
            metric_explainer(
                "Gray levels",
                r"L = \left|\{v \mid v \in \mathrm{image}\}\right|",
                "This counts the number of distinct intensity values. Quantization usually reduces this count because many original values collapse onto fewer bins.",
            )
        with explain_row_2_col_2:
            metric_explainer(
                "Entropy",
                r"H = -\sum_k p_k \log_2 p_k",
                "Shannon entropy: H = -sum_k p_k log2(p_k). It summarizes how spread out the intensity distribution is across available levels.",
            )

    section_header(
        "Comparison Views",
        "The histogram compares the two currently selected image states using a shared intensity axis. The MSE map shows where the selected pair differs most strongly in squared-error terms.",
    )
    compare_left_pad, compare_center, compare_right_pad = st.columns([0.6, 8.8, 0.6])
    with compare_center:
        hist_col, error_col = st.columns([1.2, 1.0])
        with hist_col:
            st.pyplot(
                create_histogram_figure(
                    histogram_left,
                    histogram_right,
                    top_label=left_label,
                    bottom_label=right_label,
                    top_bounds=histogram_bounds[histogram_left_key],
                    bottom_bounds=histogram_bounds[histogram_right_key],
                ),
                clear_figure=True,
            )
        with error_col:
            st.pyplot(create_mse_figure(metric_left, metric_right), clear_figure=True)

    st.markdown("## Interpretation")
    st.caption(
        "Quantization changes stored intensities, so metrics like MSE and PSNR measure fidelity loss directly. "
        "Windowing changes only the display mapping, so the histogram and side-by-side views are better tools for understanding what becomes visible or clipped."
    )

    with st.expander("What the controls mean"):
        st.markdown(
            """
            - **Bit depth:** Lower bit depth means fewer available gray levels and usually more visible banding.
            - **Window lower / upper bounds:** These set the displayed intensity interval directly.
            - **CT window presets:** Lung, mediastinal, and bone presets provide common clinical-style display ranges.
            """
        )

    with st.expander("Known limitations"):
        st.markdown(
            """
            - This app is educational and does not replace a clinical image viewer.
            - Uploaded PNG and JPG images may already be limited to 8-bit precision.
            - The current app works on one 2D slice at a time.
            - Uploaded files are currently limited to PNG/JPG and single-slice DICOM in the active UI.
            - Public deployment may require license-safe built-in samples if a dataset does not allow redistribution of image content.
            """
        )


if __name__ == "__main__":
    main()