aimbat.core

def add_data_to_project(
    session: Session,
    data_sources: Sequence[os.PathLike | str],
    data_type: DataType,
    station_id: UUID | None = None,
    event_id: UUID | None = None,
    dry_run: bool = False,
    disable_progress_bar: bool = True,
) -> tuple[list[AimbatDataSource], set[UUID], set[UUID], set[UUID]] | None:
    """Add data sources to the AIMBAT database.

    What gets created depends on which capabilities `data_type` supports:

    - Station + event + seismogram: all three records are created and linked,
      and an `AimbatDataSource` entry is stored.
    - Station or event only (e.g. `JSON_STATION`, `JSON_EVENT`): only the
      relevant metadata records are created; no seismogram or data source entry
      is stored.

    Use `station_id` or `event_id` to skip extracting station or event metadata
    from the data source and link to a pre-existing record instead.

    Args:
        session: The SQLModel database session.
        data_sources: List of data sources to add.
        data_type: Type of data.
        station_id: UUID of an existing station to use instead of extracting
            one from each data source.
        event_id: UUID of an existing event to use instead of extracting one
            from each data source.
        dry_run: If True, do not commit changes to the database.
        disable_progress_bar: Do not display progress bar.
    """

    logger.info(f"Adding {len(data_sources)} {data_type} data sources to project.")

    if station_id is not None and session.get(AimbatStation, station_id) is None:
        raise NoResultFound(f"No station found with ID {station_id}.")
    if event_id is not None and session.get(AimbatEvent, event_id) is None:
        raise NoResultFound(f"No event found with ID {event_id}.")

    # Snapshot existing IDs before entering the savepoint so we can identify
    # what would be new vs reused when running a dry run.
    if dry_run:
        existing_station_ids = set(session.exec(select(AimbatStation.id)).all())
        existing_event_ids = set(session.exec(select(AimbatEvent.id)).all())
        existing_seismogram_ids = set(session.exec(select(AimbatSeismogram.id)).all())

    try:
        added_datasources: list[AimbatDataSource] = []
        with session.begin_nested() as nested:
            for datasource in track(
                sequence=data_sources,
                description="Adding data ...",
                disable=disable_progress_bar,
            ):
                result = _process_datasource(
                    session, datasource, data_type, station_id, event_id
                )
                if result is not None:
                    added_datasources.append(result)

            if dry_run:
                logger.info("Dry run: displaying data that would be added.")
                if added_datasources:
                    session.flush()
                nested.rollback()
                logger.info("Dry run complete. Rolling back changes.")
                return (
                    added_datasources,
                    existing_station_ids,
                    existing_event_ids,
                    existing_seismogram_ids,
                )

        session.commit()
        logger.info("Data added successfully.")
        return None

    except Exception as e:
        logger.error(f"Failed to add data. Rolling back changes. Error: {e}")
        raise

def build_iccs_from_snapshot(session: Session, snapshot_id: UUID) -> BoundICCS:
    """Build a read-only BoundICCS from a snapshot's parameters and live waveform data.

    Uses the snapshot's event and seismogram parameters (window, t1, flip, select,
    bandpass, etc.) but reads waveform data from the live datasources. Seismograms
    added after the snapshot was taken are not included in the snapshot — their live
    parameters are used instead. No DB writes occur at any point.

    Args:
        session: Database session.
        snapshot_id: ID of the AimbatSnapshot to load.

    Returns:
        BoundICCS instance built from the snapshot parameters.

    Raises:
        ValueError: If no snapshot with the given ID is found.
    """
    logger.info(f"Building ICCS from snapshot {snapshot_id}.")

    statement = (
        select(AimbatSnapshot)
        .where(AimbatSnapshot.id == snapshot_id)
        .options(
            selectinload(rel(AimbatSnapshot.event))
            .selectinload(rel(AimbatEvent.seismograms))
            .selectinload(rel(AimbatSeismogram.parameters)),
            selectinload(rel(AimbatSnapshot.event_parameters_snapshot)),
            selectinload(rel(AimbatSnapshot.seismogram_parameters_snapshots)),
        )
    )
    snapshot = session.exec(statement).one_or_none()

    if snapshot is None:
        raise ValueError(f"Snapshot {snapshot_id} not found.")

    ep = snapshot.event_parameters_snapshot
    snap_params = AimbatEventParametersBase.model_validate(ep)

    # Build a map from seismogram_parameters_id → snapshot parameters
    snap_seis_map = {
        sp.seismogram_parameters_id: sp
        for sp in snapshot.seismogram_parameters_snapshots
    }

    seismograms = []
    for seis in snapshot.event.seismograms:
        snap_sp = snap_seis_map.get(seis.parameters.id)
        if snap_sp is None:
            # Seismogram was added after the snapshot — use live parameters
            seis_params = AimbatSeismogramParametersBase.model_validate(seis.parameters)
        else:
            seis_params = AimbatSeismogramParametersBase.model_validate(snap_sp)
        seismograms.append(
            MiniIccsSeismogram(
                begin_time=seis.begin_time,
                delta=seis.delta,
                data=seis.data,
                t0=seis.t0,
                t1=seis_params.t1,
                flip=seis_params.flip,
                select=seis_params.select,
                extra={"id": seis.id},
            )
        )

    iccs = ICCS(
        seismograms=seismograms,
        window_pre=snap_params.window_pre,
        window_post=snap_params.window_post,
        ramp_width=snap_params.ramp_width,
        bandpass_apply=snap_params.bandpass_apply,
        bandpass_fmin=snap_params.bandpass_fmin,
        bandpass_fmax=snap_params.bandpass_fmax,
        min_cc=snap_params.min_cc,
        context_width=settings.context_width,
    )
    return BoundICCS(
        iccs=iccs,
        event_id=snapshot.event_id,
        created_at=Timestamp.now("UTC"),
    )

def clear_iccs_cache() -> None:
    """Clear the process-level ICCS cache."""
    _iccs_cache.clear()

def clear_mccc_quality(session: Session, event: AimbatEvent) -> None:
    """Clear MCCC quality metrics from the live quality tables for an event.

    Sets all MCCC fields (`mccc_rmse`, `mccc_error`, `mccc_cc_mean`,
    `mccc_cc_std`) to `None` for the event and all its seismograms.
    ICCS CC values are not affected.

    Args:
        session: Database session.
        event: AimbatEvent whose quality should be cleared.
    """
    logger.debug(f"Clearing MCCC quality for event {event.id}.")

    if event.quality is not None:
        event.quality.mccc_rmse = None
        session.add(event.quality)

    for seis in event.seismograms:
        if seis.quality is not None:
            seis.quality.mccc_error = None
            seis.quality.mccc_cc_mean = None
            seis.quality.mccc_cc_std = None
            session.add(seis.quality)

    session.commit()

def compute_parameters_hash(event: AimbatEvent) -> str:
    """Compute a deterministic SHA-256 hash of the event's current parameters.

    Hashes the event ID, all event-level parameters, and per-seismogram
    parameters. Seismograms are sorted by ID so the result is independent of
    load order. Including the event ID means hashes are inherently
    event-scoped and will never collide across events.

    Excluded fields:

    - `completed` (event): does not affect seismogram processing.
    - `select` (seismogram): determines which seismograms are passed to MCCC
      but does not affect the computation for any individual seismogram.
      Membership of the actual MCCC run is captured by the seismogram quality
      records in the snapshot, so changing selection state should not
      invalidate a prior MCCC result.

    Args:
        event: AimbatEvent whose current parameters should be hashed.

    Returns:
        Hex-encoded SHA-256 digest.
    """
    logger.debug(f"Computing parameters hash for event {event.id}.")

    # exclude completed field since it does not affect the seismograms directly.
    event_data = AimbatEventParametersBase.model_validate(event.parameters).model_dump(
        mode="json", exclude={"completed"}
    )
    event_data["event_id"] = str(event.id)
    seis_data = sorted(
        [
            {
                "seismogram_id": str(seis.id),
                **AimbatSeismogramParametersBase.model_validate(
                    seis.parameters
                ).model_dump(mode="json", exclude={"select"}),
            }
            for seis in event.seismograms
        ],
        key=lambda x: x["seismogram_id"],
    )
    payload = json.dumps(
        {"event": event_data, "seismograms": seis_data}, sort_keys=True
    )
    return hashlib.sha256(payload.encode()).hexdigest()

def create_iccs_instance(session: Session, event: AimbatEvent) -> BoundICCS:
    """Return a BoundICCS instance for the given event.

    Returns the cached instance when it is still fresh (i.e. `event.last_modified`
    has not advanced since the instance was created). Otherwise builds a new one
    and updates the cache. ICCS CC values are written to the live quality table in
    a separate session so the caller's session is not affected.

    `MiniIccsSeismogram` instances are constructed directly from each
    `AimbatSeismogram`, passing `data` by reference to the read-only io cache.
    No waveform data is copied.

    Args:
        session: Database session.
        event: AimbatEvent.

    Returns:
        BoundICCS instance tied to the given event.

    """
    cached = _iccs_cache.get(event.id)
    if cached is not None and not cached.is_stale(event):
        logger.debug(f"Returning cached BoundICCS for event {event.id}.")
        return cached

    event = session.exec(
        select(AimbatEvent)
        .where(AimbatEvent.id == event.id)
        .options(
            selectinload(rel(AimbatEvent.parameters)),
            selectinload(rel(AimbatEvent.seismograms)).selectinload(
                rel(AimbatSeismogram.parameters)
            ),
        )
    ).one()

    logger.debug(f"Creating ICCS instance for event {event.id}.")
    bound = BoundICCS(
        iccs=_build_iccs(event),
        event_id=event.id,
        created_at=Timestamp.now("UTC"),
    )
    _iccs_cache[event.id] = bound
    _write_iccs_stats(event.id, bound.iccs)
    return bound

def create_project(engine: Engine) -> None:
    """Initializes a new AIMBAT project database schema and triggers.

    Args:
        engine: The SQLAlchemy/SQLModel Engine instance connected to the target database.

    Raises:
        RuntimeError: If a project schema already exists in the target database.
    """

    # Import locally to ensure SQLModel registers all table metadata before create_all()
    import aimbat.models  # noqa: F401

    logger.info(f"Creating new project in {engine.url}.")

    if _project_exists(engine):
        raise RuntimeError(
            f"Unable to create a new project: project already exists at {engine.url}!"
        )

    logger.debug("Creating database tables and loading defaults.")

    SQLModel.metadata.create_all(engine)

    if engine.name == "sqlite":
        with engine.begin() as connection:
            # Trigger 1: Track last modification time when event parameters change
            connection.execute(
                text("""
                CREATE TRIGGER IF NOT EXISTS event_modified_on_params_update
                AFTER UPDATE ON aimbateventparameters
                BEGIN
                    UPDATE aimbatevent SET last_modified = strftime('%Y-%m-%d %H:%M:%f', 'now')
                    WHERE id = NEW.event_id;
                END;
            """)
            )

            # Trigger 2: Track last modification time when seismogram parameters change
            connection.execute(
                text("""
                CREATE TRIGGER IF NOT EXISTS event_modified_on_seis_params_update
                AFTER UPDATE ON aimbatseismogramparameters
                BEGIN
                    UPDATE aimbatevent
                    SET last_modified = strftime('%Y-%m-%d %H:%M:%f', 'now')
                    WHERE id = (
                        SELECT event_id FROM aimbatseismogram
                        WHERE id = NEW.seismogram_id
                    );
                END;
            """)
            )

            # Trigger 3: Null all quality when event window/bandpass/ramp parameters change.
            # These parameters change the signal data used by both ICCS and MCCC.
            connection.execute(
                text("""
                CREATE TRIGGER IF NOT EXISTS null_all_quality_on_window_bandpass_change
                AFTER UPDATE ON aimbateventparameters
                WHEN (NEW.window_pre IS NOT OLD.window_pre)
                  OR (NEW.window_post IS NOT OLD.window_post)
                  OR (NEW.ramp_width IS NOT OLD.ramp_width)
                  OR (NEW.bandpass_apply IS NOT OLD.bandpass_apply)
                  OR (NEW.bandpass_fmin IS NOT OLD.bandpass_fmin)
                  OR (NEW.bandpass_fmax IS NOT OLD.bandpass_fmax)
                BEGIN
                    UPDATE aimbateventquality
                    SET mccc_rmse = NULL
                    WHERE event_id = NEW.event_id;
                    UPDATE aimbatseismogramquality
                    SET iccs_cc = NULL, mccc_cc_mean = NULL, mccc_cc_std = NULL, mccc_error = NULL
                    WHERE seismogram_id IN (
                        SELECT id FROM aimbatseismogram WHERE event_id = NEW.event_id
                    );
                END;
            """)
            )

            # Trigger 4: Null MCCC quality when MCCC-specific event parameters change.
            # These parameters affect only the MCCC inversion, not the underlying signal,
            # so iccs_cc remains valid.
            connection.execute(
                text("""
                CREATE TRIGGER IF NOT EXISTS null_mccc_quality_on_mccc_params_change
                AFTER UPDATE ON aimbateventparameters
                WHEN (NEW.mccc_damp IS NOT OLD.mccc_damp)
                  OR (NEW.mccc_min_cc IS NOT OLD.mccc_min_cc)
                BEGIN
                    UPDATE aimbateventquality
                    SET mccc_rmse = NULL
                    WHERE event_id = NEW.event_id;
                    UPDATE aimbatseismogramquality
                    SET mccc_cc_mean = NULL, mccc_cc_std = NULL, mccc_error = NULL
                    WHERE seismogram_id IN (
                        SELECT id FROM aimbatseismogram WHERE event_id = NEW.event_id
                    );
                END;
            """)
            )

            # Trigger 5a: Null quality when flip changes on a seismogram.
            # Flipping a trace only affects the ICCS stack if the seismogram is selected.
            # MCCC stats are invalidated if the seismogram was included in the last MCCC
            # run, which is inferred from the presence of live mccc_cc_mean stats —
            # not from select, because MCCC may have been run with --all.
            # The event-level UPDATE is ordered before the per-seismogram UPDATE so that
            # the EXISTS check sees the original (non-nulled) stats in both statements.
            connection.execute(
                text("""
                CREATE TRIGGER IF NOT EXISTS null_quality_on_seis_flip_change
                AFTER UPDATE ON aimbatseismogramparameters
                WHEN NEW.flip IS NOT OLD.flip
                BEGIN
                    -- Null iccs_cc for all event seismograms if selected (stack changed),
                    -- or just locally if deselected (the flipped seismogram's own CC is stale
                    -- even though the stack is unchanged).
                    UPDATE aimbatseismogramquality
                    SET iccs_cc = NULL
                    WHERE (
                        NEW."select" = TRUE
                        AND seismogram_id IN (
                            SELECT id FROM aimbatseismogram WHERE event_id = (
                                SELECT event_id FROM aimbatseismogram WHERE id = NEW.seismogram_id
                            )
                        )
                    ) OR (
                        NEW."select" IS NOT TRUE
                        AND seismogram_id = NEW.seismogram_id
                    );

                    -- Null event-level RMSE if this seismogram was in the last MCCC run
                    UPDATE aimbateventquality
                    SET mccc_rmse = NULL
                    WHERE EXISTS (
                        SELECT 1 FROM aimbatseismogramquality
                        WHERE seismogram_id = NEW.seismogram_id
                          AND mccc_cc_mean IS NOT NULL
                    )
                      AND event_id = (
                        SELECT event_id FROM aimbatseismogram WHERE id = NEW.seismogram_id
                    );

                    -- Null per-seismogram MCCC stats for the whole event if this seismogram
                    -- was in the last MCCC run (checked before these stats are nulled above)
                    UPDATE aimbatseismogramquality
                    SET mccc_cc_mean = NULL, mccc_cc_std = NULL, mccc_error = NULL
                    WHERE EXISTS (
                        SELECT 1 FROM aimbatseismogramquality
                        WHERE seismogram_id = NEW.seismogram_id
                          AND mccc_cc_mean IS NOT NULL
                    )
                      AND seismogram_id IN (
                        SELECT id FROM aimbatseismogram WHERE event_id = (
                            SELECT event_id FROM aimbatseismogram WHERE id = NEW.seismogram_id
                        )
                    );
                END;
            """)
            )

            # Trigger 5b: Null quality when t1 changes on a seismogram.
            # ICCS: if selected, the stack is affected so iccs_cc is stale for all;
            # if deselected, only this seismogram's own iccs_cc is stale.
            # MCCC: invalidated whenever the seismogram was in the last MCCC run,
            # inferred from live mccc_cc_mean — not select — because MCCC may have
            # been run with --all, meaning a deselected seismogram could still be included.
            connection.execute(
                text("""
                CREATE TRIGGER IF NOT EXISTS null_quality_on_seis_t1_change
                AFTER UPDATE ON aimbatseismogramparameters
                WHEN NEW.t1 IS NOT OLD.t1
                BEGIN
                    -- Null iccs_cc for all event seismograms if selected (stack changed),
                    -- otherwise only null locally.
                    UPDATE aimbatseismogramquality
                    SET iccs_cc = NULL
                    WHERE (
                        NEW."select" = TRUE
                        AND seismogram_id IN (
                            SELECT id FROM aimbatseismogram WHERE event_id = (
                                SELECT event_id FROM aimbatseismogram WHERE id = NEW.seismogram_id
                            )
                        )
                    ) OR (
                        NEW."select" IS NOT TRUE
                        AND seismogram_id = NEW.seismogram_id
                    );

                    -- Null event-level RMSE if this seismogram was in the last MCCC run
                    UPDATE aimbateventquality
                    SET mccc_rmse = NULL
                    WHERE EXISTS (
                        SELECT 1 FROM aimbatseismogramquality
                        WHERE seismogram_id = NEW.seismogram_id
                          AND mccc_cc_mean IS NOT NULL
                    )
                      AND event_id = (
                        SELECT event_id FROM aimbatseismogram WHERE id = NEW.seismogram_id
                    );

                    -- Null per-seismogram MCCC stats for the whole event if this seismogram
                    -- was in the last MCCC run
                    UPDATE aimbatseismogramquality
                    SET mccc_cc_mean = NULL, mccc_cc_std = NULL, mccc_error = NULL
                    WHERE EXISTS (
                        SELECT 1 FROM aimbatseismogramquality
                        WHERE seismogram_id = NEW.seismogram_id
                          AND mccc_cc_mean IS NOT NULL
                    )
                      AND seismogram_id IN (
                        SELECT id FROM aimbatseismogram WHERE event_id = (
                            SELECT event_id FROM aimbatseismogram WHERE id = NEW.seismogram_id
                        )
                    );
                END;
            """)
            )

            # Trigger 5c: Null quality when select changes on a seismogram.
            # ICCS stack composition changes in both directions (select → deselect and
            # vice versa), so iccs_cc is always invalidated for the whole event.
            # MCCC stats are only invalidated if the seismogram was in the last MCCC run,
            # inferred from live mccc_cc_mean — if MCCC was run with --all, changing
            # select does not change the MCCC set, so live stats remain valid.
            connection.execute(
                text("""
                CREATE TRIGGER IF NOT EXISTS null_quality_on_seis_select_change
                AFTER UPDATE ON aimbatseismogramparameters
                WHEN NEW."select" IS NOT OLD."select"
                BEGIN
                    -- Always null iccs_cc for the whole event (stack composition changed)
                    UPDATE aimbatseismogramquality
                    SET iccs_cc = NULL
                    WHERE seismogram_id IN (
                        SELECT id FROM aimbatseismogram WHERE event_id = (
                            SELECT event_id FROM aimbatseismogram WHERE id = NEW.seismogram_id
                        )
                    );

                    -- Null event-level RMSE if this seismogram was in the last MCCC run
                    UPDATE aimbateventquality
                    SET mccc_rmse = NULL
                    WHERE EXISTS (
                        SELECT 1 FROM aimbatseismogramquality
                        WHERE seismogram_id = NEW.seismogram_id
                          AND mccc_cc_mean IS NOT NULL
                    )
                      AND event_id = (
                        SELECT event_id FROM aimbatseismogram WHERE id = NEW.seismogram_id
                    );

                    -- Null per-seismogram MCCC stats for the whole event if this seismogram
                    -- was in the last MCCC run
                    UPDATE aimbatseismogramquality
                    SET mccc_cc_mean = NULL, mccc_cc_std = NULL, mccc_error = NULL
                    WHERE EXISTS (
                        SELECT 1 FROM aimbatseismogramquality
                        WHERE seismogram_id = NEW.seismogram_id
                          AND mccc_cc_mean IS NOT NULL
                    )
                      AND seismogram_id IN (
                        SELECT id FROM aimbatseismogram WHERE event_id = (
                            SELECT event_id FROM aimbatseismogram WHERE id = NEW.seismogram_id
                        )
                    );
                END;
            """)
            )

def create_snapshot(
    session: Session,
    event: AimbatEvent,
    comment: str | None = None,
) -> None:
    """Create a snapshot of the AIMBAT processing parameters and quality metrics.

    Parameter snapshots are always created. Quality snapshots are created
    whenever the corresponding live quality record has at least one non-None
    field. Seismogram quality is omitted when all quality fields are `None`
    (e.g. before any ICCS or MCCC run).

    Args:
        session: Database session.
        event: AimbatEvent.
        comment: Optional comment.
    """

    logger.info(
        f"Creating snapshot for event {event.id}"
        + (f" with comment '{comment}'" if comment else "")
        + "."
    )

    event = session.exec(
        select(AimbatEvent)
        .where(AimbatEvent.id == event.id)
        .options(
            selectinload(rel(AimbatEvent.parameters)),
            selectinload(rel(AimbatEvent.quality)),
            selectinload(rel(AimbatEvent.seismograms)).options(
                selectinload(rel(AimbatSeismogram.parameters)),
                selectinload(rel(AimbatSeismogram.quality)),
            ),
        )
    ).one()

    event_parameters_snapshot = AimbatEventParametersSnapshot.model_validate(
        event.parameters,
        update={
            "id": uuid4(),  # we don't want to carry over the id from the input event parameters
            "parameters_id": event.parameters.id,
        },
    )
    logger.debug(
        f"Adding event parameters snapshot with id={event_parameters_snapshot.id} to snapshot."
    )

    seismogram_parameter_snapshots = []
    for aimbat_seismogram in event.seismograms:
        seismogram_parameter_snapshot = AimbatSeismogramParametersSnapshot.model_validate(
            aimbat_seismogram.parameters,
            update={
                "id": uuid4(),  # we don't want to carry over the id from the input seismogram parameters
                "seismogram_parameters_id": aimbat_seismogram.parameters.id,
            },
        )
        logger.debug(
            f"Adding seismogram parameters snapshot with id={seismogram_parameter_snapshot.id} to snapshot."
        )
        seismogram_parameter_snapshots.append(seismogram_parameter_snapshot)

    # Capture quality metrics from the live quality tables.
    event_quality_snap: AimbatEventQualitySnapshot | None = None
    seis_quality_snaps: list[AimbatSeismogramQualitySnapshot] = []

    if event.quality is not None and event.quality.mccc_rmse is not None:
        logger.debug("Capturing event quality snapshot from live quality table.")
        event_quality_snap = AimbatEventQualitySnapshot.model_validate(
            event.quality,
            update={
                "id": uuid4(),
                "event_quality_id": event.quality.id,
            },
        )

    for aimbat_seismogram in event.seismograms:
        sq = aimbat_seismogram.quality
        if sq is None:
            continue
        if any(
            v is not None
            for v in [sq.iccs_cc, sq.mccc_cc_mean, sq.mccc_cc_std, sq.mccc_error]
        ):
            logger.debug(
                f"Adding seismogram quality snapshot for seismogram {aimbat_seismogram.id}."
            )
            seis_quality_snaps.append(
                AimbatSeismogramQualitySnapshot.model_validate(
                    sq,
                    update={
                        "id": uuid4(),
                        "seismogram_quality_id": sq.id,
                    },
                )
            )

    aimbat_snapshot = AimbatSnapshot(
        event=event,
        event_parameters_snapshot=event_parameters_snapshot,
        seismogram_parameters_snapshots=seismogram_parameter_snapshots,
        event_quality_snapshot=event_quality_snap,
        seismogram_quality_snapshots=seis_quality_snaps,
        comment=comment,
        parameters_hash=compute_parameters_hash(event),
    )
    session.add(aimbat_snapshot)
    session.commit()

def delete_event(session: Session, event_id: UUID) -> None:
    """Delete an AimbatEvent from the database.

    Args:
        session: Database session.
        event_id: Event ID.

    """

    logger.info(f"Deleting event {event_id}.")

    event = session.get(AimbatEvent, event_id)
    if event is None:
        raise NoResultFound(f"Unable to find event using id: {event_id}.")

    session.delete(event)
    session.commit()

def delete_project(engine: Engine) -> None:
    """Delete the AIMBAT project.

    Raises:
        RuntimeError: If unable to delete project.
    """

    logger.info(f"Deleting project at {engine.url}.")

    if not _project_exists(engine):
        raise RuntimeError("No project found to delete.")

    if engine.driver == "pysqlite":
        database = engine.url.database
        engine.dispose()
        if database == ":memory:":
            logger.info("Running database in memory, nothing to delete.")
            return
        elif database:
            project_path = Path(database)
            logger.info(f"Deleting project file: {project_path}.")
            project_path.unlink()
            return

    raise RuntimeError(
        f"Unable to delete project: unsupported engine driver '{engine.driver}'."
    )

def delete_seismogram(session: Session, seismogram_id: UUID) -> None:
    """Delete an AimbatSeismogram from the database.

    Args:
        session: Database session.
        seismogram_id: Seismogram ID.

    """

    logger.info(f"Deleting seismogram {seismogram_id}.")

    seismogram = session.get(AimbatSeismogram, seismogram_id)
    if seismogram is None:
        raise NoResultFound(f"No AimbatSeismogram found with {seismogram_id=}")

    session.delete(seismogram)
    session.commit()

def delete_snapshot(session: Session, snapshot_id: UUID) -> None:
    """Delete an AIMBAT parameter snapshot.

    Args:
        snapshot_id: Snapshot id.
    """
    logger.info(f"Deleting snapshot {snapshot_id}.")

    snapshot = session.get(AimbatSnapshot, snapshot_id)
    if snapshot is None:
        raise NoResultFound(f"Unable to find snapshot with {snapshot_id=}")

    session.delete(snapshot)
    session.commit()

def delete_station(session: Session, station_id: UUID) -> None:
    """Delete an AimbatStation from the database.

    Args:
        session: Database session.
        station_id: ID of the station to delete.
    """

    logger.info(f"Deleting station with id={station_id}.")

    station = session.get(AimbatStation, station_id)
    if station is None:
        raise NoResultFound(f"No AimbatStation found with {station_id=}")

    session.delete(station)
    session.commit()

def dump_data_table(
    session: Session,
    event_id: UUID | None = None,
    by_alias: bool = False,
    by_title: bool = False,
    exclude: set[str] | None = None,
) -> list[dict[str, Any]]:
    """Return AIMBAT datasources table as a JSON-serialisable list of dicts.

    Args:
        session: Database session.
        event_id: UUID of the event to filter data sources by. If None, all data sources are returned.
        by_alias: Whether to use field aliases.
        by_title: Whether to use field titles (from the Pydantic model) for the
            field names in the output. Mutually exclusive with by_alias.
        exclude: Set of field names to exclude from the output.

    Returns:
        Aimbat datasources table as a list of dicts.
    """
    logger.debug("Dumping AIMBAT datasources table to json.")

    if by_alias and by_title:
        raise ValueError("Arguments 'by_alias' and 'by_title' are mutually exclusive.")

    if exclude is not None:
        exclude: dict[str, set] = {"__all__": exclude}  # type: ignore[no-redef]

    adapter: TypeAdapter[Sequence[AimbatDataSource]] = TypeAdapter(
        Sequence[AimbatDataSource]
    )

    if event_id is not None:
        data_source = get_data_for_event(session, event_id)
    else:
        data_source = session.exec(select(AimbatDataSource)).all()

    data = adapter.dump_python(
        data_source, exclude=exclude, by_alias=by_alias, mode="json"
    )

    if by_title:
        title_map = get_title_map(AimbatDataSource)
        return [{title_map.get(k, k): v for k, v in row.items()} for row in data]

    return data