ui_state

def get_last_browsed_dir(purpose: str) -> str | None:
    """Return the last directory the user finalised for *purpose*.

    Args:
        purpose: A stable key identifying the chooser site (e.g.
            ``"model_chooser"``, ``"source_chooser"``).

    Returns:
        The persisted directory path, or ``None`` if nothing has been
        recorded for *purpose* yet, or the recorded path no longer
        exists on disk.
    """
    state = _load()
    dirs = state.get("last_browsed_dirs", {})
    candidate = dirs.get(purpose)
    if not candidate:
        return None
    if not os.path.isdir(candidate):
        return None
    return candidate

def set_last_browsed_dir(purpose: str, path: str) -> None:
    """Record *path* as the last directory the user finalised for *purpose*.

    *path* may point at a file or a directory; in both cases the
    parent directory is what gets stored, since that is what the
    chooser should restore on next open.

    Args:
        purpose: A stable key identifying the chooser site.
        path: The selection the user just confirmed (file or directory).
    """
    if not path:
        return
    if os.path.isdir(path):
        directory = path
    else:
        directory = os.path.dirname(path)
    # ipyfilechooser appends an OS separator when the user clicks
    # Select on a folder (its ``selected`` is ``path + sep + filename``
    # with an empty filename), so normalise away trailing separators
    # before storing — otherwise round-trip comparisons fail.
    directory = os.path.normpath(directory) if directory else directory
    if not directory:
        return

    state = _load()
    state["schema_version"] = _SCHEMA_VERSION
    dirs = state.setdefault("last_browsed_dirs", {})
    dirs[purpose] = directory
    _save(state)

def get_normalisation_settings(purpose: str) -> dict | None:
    """Return the normalisation settings last confirmed for *purpose*.

    Args:
        purpose: A stable key identifying the screen (e.g. ``"training_setup"``).

    Returns:
        ``{"settings": {...}, "extensions": [...]}`` exactly as recorded by
        :func:`set_normalisation_settings`, or ``None`` when nothing has been
        recorded yet or the stored record does not have that shape.
        ``extensions`` names the input channels the settings were chosen
        against; a caller must not apply a stored ``channel_combination``
        matrix to a source exposing a different set of channels.
    """
    state = _load()
    records = state.get(_NORMALISATION_KEY, {})
    record = records.get(purpose)
    if record is None:
        return None
    if not isinstance(record, dict):
        logger.debug("Normalisation state for {} is not a dict; ignoring", purpose)
        return None
    settings = record.get("settings")
    extensions = record.get("extensions")
    if not isinstance(settings, dict) or not isinstance(extensions, list):
        logger.debug("Normalisation state for {} is malformed; ignoring", purpose)
        return None
    return {"settings": settings, "extensions": extensions}

def set_normalisation_settings(purpose: str, settings: dict, extensions: list[str]) -> None:
    """Record the normalisation settings the user confirmed for *purpose*.

    Args:
        purpose: A stable key identifying the screen.
        settings: Normalisation config dict.  Values must already be
            JSON-serialisable — run a widget config through
            ``serialisable_config`` first so numpy matrices arrive as
            nested lists.
        extensions: Input-channel names the channel-combination matrix was
            built against, stored so a later restore can tell whether that
            matrix still describes the selected source.
    """
    state = _load()
    state["schema_version"] = _SCHEMA_VERSION
    records = state.setdefault(_NORMALISATION_KEY, {})
    records[purpose] = {"settings": dict(settings), "extensions": list(extensions)}
    _save(state)