/******************************************************************************
 * @file application.c
 * @brief Implémentation du cycle de vie de l'application GTK.
 ******************************************************************************/

#include "core/application.h"

#include "core/investigation_node.h"
#include "core/investigation_project.h"
#include "core/investigation_session.h"
#include "core/investigation_tree_model.h"
#include "core/investigation_graph_load_task.h"
#include "models/investigation_graph_layout.h"
#include "models/investigation_graph_model.h"
#include "models/investigation_record.h"
#include "models/osint_dns_query.h"
#include "models/osint_dns_proposal.h"
#include "models/osint_execution_record.h"
#include "core/investigation_tree_builder.h"
#include "views/create_investigation_dialog.h"
#include "views/folder_dialog.h"
#include "views/main_window.h"
#include "views/application_message_dialog.h"
#include "core/task_manager.h"
#include "core/background_task.h"
#include "core/tool_initializer.h"
#include "core/tool_task.h"
#include "core/osint_dns_integration.h"
#include "core/osint_execution_integrity.h"
#include "core/evidence_reclassification.h"
#include "views/file_dialog.h"
#include "core/evidence_import_task.h"
#include "models/evidence_record.h"
#include "dao/evidence_type_dao.h"
#include "dao/graph_node_position_dao.h"
#include "dao/relation_type_dao.h"
#include "models/relation_type.h"
#include "core/relation_type_service.h"
#include "views/evidence_import_dialog.h"
#include "views/evidence_metadata_dialog.h"
#include "views/create_relation_dialog.h"
#include "views/osint_dns_review_dialog.h"
#include "views/osint_execution_history_dialog.h"
#include "dao/evidence_dao.h"
#include "dao/evidence_entity_dao.h"
#include "dao/entity_dao.h"
#include "dao/relation_dao.h"
#include "dao/relation_evidence_dao.h"
#include "dao/osint_execution_dao.h"
#include "dao/extraction_dao.h"
#include "models/evidence_type.h"
#include "widgets/evidence_list_model.h"
#include "widgets/evidence_category_model.h"
#include "core/evidence_integrity_task.h"
#include "core/evidence_integrity_verifier.h"
#include "core/relation_service.h"
#include "core/social_account_service.h"
#include "core/person_entity_service.h"
#include "core/person_creation_coordinator.h"
#include "core/person_creation_task.h"
#include "core/person_creation_guard.h"
#include "core/eml_processing.h"
#include "core/eml_integration.h"
#include "core/eml_pipeline_task.h"
#include "core/file_hash.h"
#include "database/database.h"
#include "database/transaction.h"
#include "views/create_social_account_dialog.h"
#include "views/create_person_dialog.h"
#include "views/eml_analysis_dialog.h"
#include "views/manage_entity_evidence_dialog.h"
#include "views/rib_ocr_review_dialog.h"
#include "core/rib_ocr.h"
#include "core/iban_analyzer.h"
#include "core/exiftool_metadata.h"
#include "views/metadata_analysis_dialog.h"
#include "core/pdf_password_recovery.h"
#include "core/extraction_drop_service.h"
#include "views/pdf_password_dialog.h"

#include <gtk/gtk.h>
#include <glib/gstdio.h>
#include <errno.h>
#include <unistd.h>

/**
 * @brief Identifiant unique utilisé par GLib pour l'application.
 */
#define APPLICATION_ID "com.labfytools.investigation"

/**
 * @brief Erreurs produites lors du chargement d'une enquête.
 */
typedef enum
{
    APPLICATION_OPEN_ERROR_INVALID_ARGUMENT,
    APPLICATION_OPEN_ERROR_INVALID_PROJECT,
    APPLICATION_OPEN_ERROR_TREE_BUILD,
    APPLICATION_OPEN_ERROR_INSTALL,
    APPLICATION_OPEN_ERROR_EVIDENCE
} ApplicationOpenError;

/**
 * @brief Domaine d'erreur du chargement d'une enquête.
 */
#define APPLICATION_OPEN_ERROR \
    application_open_error_quark()

/**
 * @brief Dossier racine contenant les preuves originales.
 */
#define APPLICATION_EVIDENCE_ROOT_DIRECTORY \
    "01_Preuves_Originales"

/**
 * @brief Retourne le domaine d'erreur du chargement d'une enquête.
 *
 * @return Quark GLib du domaine d'erreur.
 */
static GQuark application_open_error_quark(void)
{
    return g_quark_from_static_string(
        "labfy-investigation-application-open-error"
    );
}

/**
 * @brief État interne de l'application.
 *
 * Cette structure reste privée au module afin d'empêcher les autres
 * composants de manipuler directement les objets GTK.
 */
struct Application
{
    GtkApplication *gtk_application;
    MainWindow *main_window;
    InvestigationSession *session;
    InvestigationTreeModel *tree_model;
    TaskManager *task_manager;
    ToolInitializer *tool_initializer;
    EvidenceListModel *evidence_list_model;
    EvidenceCategoryModel *evidence_category_model;

    InvestigationGraphLoadTask *graph_load_task;
    InvestigationGraphModel *graph_model;
    InvestigationGraphLayout *graph_layout;
    guint64 graph_load_generation;
    guint64 session_generation;
    gboolean graph_viewport_restored;
    guint graph_viewport_save_source_id;

    char *selected_evidence_identifier;
    char *pending_relation_selection_identifier;
    char *pending_entity_selection_identifier;
};

typedef struct
{
    Application *application;
    PersonCreationGuard *guard;
} ApplicationPersonDialogContext;
typedef struct
{
    Application *application;
    guint64 generation;
    char *root_path;
    char *database_path;
    EvidenceStaging *staging;
} ApplicationPersonCreationTaskContext;

static void application_person_dialog_context_free(
    ApplicationPersonDialogContext *context)
{
    if (context == NULL) return;
    person_creation_guard_free(context->guard);
    g_free(context);
}
static void application_person_creation_task_context_free(gpointer data)
{
    ApplicationPersonCreationTaskContext *context = data;
    if (context == NULL) return;
    g_free(context->root_path);
    g_free(context->database_path);
    evidence_staging_free(context->staging);
    g_free(context);
}

static void application_on_evidence_selected(
    const char *evidence_identifier, gpointer user_data);

typedef struct {
    Application *application;
    char *observation_identifier;
} ApplicationObservationRemovalContext;

static void application_observation_removal_context_free(
    ApplicationObservationRemovalContext *context)
{
    if (context == NULL) return;
    g_free(context->observation_identifier);
    g_free(context);
}

/**
 * @brief Contexte ApplicationOpenErrorconservé jusqu’à la fin d’un import.
 */
typedef struct
{
    Application *application;
    char *investigation_root_path;
    gpointer batch_context;
} ApplicationEvidenceImportContext;

/** @brief État d'un import groupé traité séquentiellement. */
typedef struct
{
    Application *application;
    GPtrArray *file_paths;
    GPtrArray *evidence_types;
    GPtrArray *failures;
    guint current_index;
    guint success_count;
    guint skipped_count;
} ApplicationEvidenceBatchContext;

/**
 * @brief Contexte conservé jusqu'à la fin d'un chargement de graphe.
 */
typedef struct
{
    Application *application;
    guint64 generation;
} ApplicationGraphLoadContext;

/**
 * @brief Contexte conservé pendant le dialogue de métadonnées.
 *
 * Le chemin fourni par FileDialog n'est valide que pendant son callback.
 * Il doit donc être copié avant l'ouverture du second dialogue.
 */
typedef struct
{
    Application *application;
    char *file_path;
} ApplicationEvidenceDialogContext;

/** @brief Contexte possédé pendant l'édition d'une preuve. */
typedef struct
{
    Application *application;
    char *evidence_identifier;
} ApplicationEvidenceMetadataContext;

/** @brief Données d'actualisation différée après reclassement. */
typedef struct
{
    Application *application;
    char *root_path;
} ApplicationEvidenceRefreshContext;

/**
 * @brief Contexte conservé jusqu'à la fin d'une vérification.
 */
typedef struct
{
    Application *application;

    char *investigation_root_path;
    char *database_path;

    char *evidence_identifier;
    char *original_name;
} ApplicationEvidenceIntegrityContext;

/**
 * @brief Contexte conservé jusqu'à la fin d'une action OSINT.
 */
typedef struct
{
    Application *application;
    char *action_identifier;
    char *target_identifier;
    char *target_value;
    char *started_at;
} ApplicationOsintActionContext;

typedef struct
{
    Application *application;
    ExtractionDropInfo *info;
    char *target_entity_identifier;
} ApplicationExtractionDropContext;

/** @brief Données possédées par l'étape de révision OSINT. */
typedef struct
{
    Application *application;
    char *source_entity_identifier;
    char *execution_identifier;
    GPtrArray *proposals;
} ApplicationOsintReviewContext;
static char *application_osint_output_to_utf8(GBytes *bytes);
static char *application_osint_create_timestamp(void);
/** @brief Contexte possédé pendant la révision d'une analyse EML. */
typedef struct {
    Application *application;
    InvestigationSession *expected_session;
    char *evidence_identifier;
    char *evidence_name;
    char *relative_path;
    char *source_sha256;
    char *staging_directory;
}
    ApplicationEmlReviewContext;

static void application_start_graph_loading(
    Application *application,
    const char *database_path
);

static void application_save_graph_viewport(Application *application)
{
    GraphNodePositionDao *dao = NULL;
    GError *error = NULL;
    double zoom = 0.0;
    double offset_x = 0.0;
    double offset_y = 0.0;

    if (application == NULL || application->session == NULL ||
        application->main_window == NULL ||
        !main_window_get_graph_view_transform(application->main_window,
            &zoom, &offset_x, &offset_y))
        return;

    dao = graph_node_position_dao_new(
        investigation_session_get_database(application->session), &error);
    if (dao == NULL || !graph_node_position_dao_upsert_viewport(
            dao, zoom, offset_x, offset_y, &error))
        g_warning("Impossible d'enregistrer le cadrage du graphe : %s",
            error != NULL ? error->message : "erreur inconnue");

    graph_node_position_dao_free(dao);
    g_clear_error(&error);
}

static gboolean application_save_graph_viewport_timeout(gpointer user_data)
{
    Application *application = user_data;
    if (application == NULL) return G_SOURCE_REMOVE;
    application->graph_viewport_save_source_id = 0U;
    application_save_graph_viewport(application);
    return G_SOURCE_REMOVE;
}

static void application_on_graph_transform_changed(gpointer user_data)
{
    Application *application = user_data;
    if (application == NULL) return;
    if (application->graph_viewport_save_source_id != 0U)
        g_source_remove(application->graph_viewport_save_source_id);
    application->graph_viewport_save_source_id = g_timeout_add(
        250U, application_save_graph_viewport_timeout, application);
}

static void application_restore_graph_viewport(Application *application)
{
    GraphNodePositionDao *dao = NULL;
    GError *error = NULL;
    gboolean found = FALSE;
    double zoom = 0.0;
    double offset_x = 0.0;
    double offset_y = 0.0;

    if (application == NULL || application->graph_viewport_restored ||
        application->session == NULL || application->main_window == NULL)
        return;

    dao = graph_node_position_dao_new(
        investigation_session_get_database(application->session), &error);
    if (dao != NULL && graph_node_position_dao_load_viewport(
            dao, &zoom, &offset_x, &offset_y, &found, &error) && found)
        main_window_set_graph_view_transform(
            application->main_window, zoom, offset_x, offset_y);
    else if (error != NULL)
        g_warning("Impossible de restaurer le cadrage du graphe : %s",
            error->message);

    application->graph_viewport_restored = TRUE;
    graph_node_position_dao_free(dao);
    g_clear_error(&error);
}

static void application_present_error(
    Application *application,
    const char *title,
    const char *message
);

static void application_extraction_drop_context_free(
    ApplicationExtractionDropContext *context)
{
    if (context == NULL) return;
    extraction_drop_info_free(context->info);
    g_free(context->target_entity_identifier);
    g_free(context);
}

static void application_on_extraction_choice_finished(
    GObject *source_object, GAsyncResult *result, gpointer user_data)
{
    ApplicationExtractionDropContext *context = user_data;
    Application *application = context != NULL ? context->application : NULL;
    GtkAlertDialog *dialog = GTK_ALERT_DIALOG(source_object);
    const InvestigationProject *project = NULL;
    Database *database = NULL;
    GError *error = NULL;
    int choice = gtk_alert_dialog_choose_finish(dialog, result, &error);
    gboolean success = FALSE;

    if (application == NULL || application->session == NULL) goto cleanup;
    if (error != NULL || choice == 0)
    {
        main_window_set_status(application->main_window,
            "Dépôt de l'extraction annulé.");
        goto cleanup;
    }
    database = investigation_session_get_database(application->session);
    if (choice == 1)
        success = extraction_drop_service_create_entity(database,
            context->info, NULL, &error);
    else if (choice == 2 && context->target_entity_identifier != NULL)
        success = extraction_drop_service_attach(database, context->info,
            context->target_entity_identifier, &error);
    else
        g_set_error_literal(&error, EXTRACTION_DROP_SERVICE_ERROR,
            EXTRACTION_DROP_SERVICE_ERROR_INVALID_ARGUMENT,
            "Déposez l'extraction directement sur une entité pour la rattacher.");

    if (!success)
    {
        application_present_error(application,
            "Intégration de l'extraction impossible",
            error != NULL ? error->message : "L'association n'a pas été créée.");
        goto cleanup;
    }
    main_window_set_status(application->main_window,
        choice == 1 ? "Entité créée depuis l'extraction."
                    : "Extraction rattachée à l'entité.");
    project = investigation_session_get_project(application->session);
    if (project != NULL)
        application_start_graph_loading(application,
            investigation_project_get_database_path(project));

cleanup:
    g_clear_error(&error);
    application_extraction_drop_context_free(context);
}

static void application_on_extraction_dropped(
    const char *file_path,
    const char *target_entity_identifier,
    gpointer user_data)
{
    Application *application = user_data;
    ApplicationExtractionDropContext *context = NULL;
    const InvestigationProject *project = NULL;
    GtkAlertDialog *dialog = NULL;
    const char *buttons[] = {
        "Annuler", "Créer une entité", "Rattacher à l'entité", NULL
    };
    char *details = NULL;
    char *content_preview = NULL;
    GError *error = NULL;

    if (application == NULL || application->session == NULL) return;
    project = investigation_session_get_project(application->session);
    context = g_new0(ApplicationExtractionDropContext, 1);
    context->application = application;
    context->target_entity_identifier = g_strdup(target_entity_identifier);
    context->info = extraction_drop_service_prepare(
        investigation_project_get_root_path(project), file_path, &error);
    if (context->info == NULL)
    {
        application_present_error(application, "Dépôt refusé",
            error != NULL ? error->message : "Extraction invalide.");
        g_clear_error(&error);
        application_extraction_drop_context_free(context);
        return;
    }
    {
        const char *content = extraction_drop_info_get_content(context->info);
        const char *preview_end = content;
        guint line_count = 0U;

        while (preview_end != NULL && *preview_end != '\0' &&
               (gsize) (preview_end - content) < 800U &&
               line_count < 12U)
        {
            if (*preview_end == '\n') line_count++;
            preview_end = g_utf8_next_char(preview_end);
        }
        content_preview = g_strndup(content,
            preview_end != NULL ? (gsize) (preview_end - content) : 0U);
        if (preview_end != NULL && *preview_end != '\0')
        {
            char *truncated_preview = g_strconcat(content_preview,
                "\n\n[… aperçu tronqué, le fichier complet sera conservé]",
                NULL);
            g_free(content_preview);
            content_preview = truncated_preview;
        }
    }
    details = g_strdup_printf("Fichier : %s\nSource : %s\n\n%s",
        extraction_drop_info_get_file_name(context->info),
        extraction_drop_info_get_source(context->info),
        content_preview != NULL ? content_preview : "");
    dialog = gtk_alert_dialog_new("Intégrer cette extraction au graphe ?");
    gtk_alert_dialog_set_detail(dialog, details);
    gtk_alert_dialog_set_buttons(dialog, buttons);
    gtk_alert_dialog_set_cancel_button(dialog, 0);
    gtk_alert_dialog_set_default_button(dialog, 0);
    gtk_alert_dialog_choose(dialog,
        main_window_get_window(application->main_window), NULL,
        application_on_extraction_choice_finished, context);
    g_object_unref(dialog);
    g_free(details);
    g_free(content_preview);
}

static void application_present_next_batch_metadata(
    ApplicationEvidenceBatchContext *context
);

static void application_evidence_batch_context_free(
    ApplicationEvidenceBatchContext *context
);

/** @brief Libère les données de révision possédées par le dialogue. */
static void application_osint_review_context_free(gpointer user_data)
{
    ApplicationOsintReviewContext *context = user_data;
    if (context == NULL) return;
    g_clear_pointer(&context->proposals, g_ptr_array_unref);
    g_free(context->execution_identifier);
    g_free(context->source_entity_identifier);
    g_free(context);
}

/** @brief Démarre ou abandonne la préparation après confirmation globale. */
static void application_on_batch_selection_confirmed(
    gboolean confirmed, gpointer user_data
)
{
    ApplicationEvidenceBatchContext *context = user_data;
    if (context == NULL) return;
    if (confirmed) application_present_next_batch_metadata(context);
    else
    {
        main_window_set_import_evidence_enabled(
            context->application->main_window, TRUE);
        main_window_set_status(context->application->main_window,
            "Import groupé annulé avant toute copie.");
        application_evidence_batch_context_free(context);
    }
}

/** @brief Intègre les propositions confirmées puis recharge le graphe. */
static void application_on_osint_integration_confirmed(
    GPtrArray *selected_proposals,
    gpointer user_data
)
{
    ApplicationOsintReviewContext *review_context = user_data;
    Application *application = review_context != NULL
        ? review_context->application : NULL;
    const InvestigationProject *project = NULL;
    Database *database = NULL;
    const char *database_path = NULL;
    guint inserted_count = 0U;
    guint skipped_count = 0U;
    guint inserted_relation_count = 0U;
    guint skipped_relation_count = 0U;
    char *message = NULL;
    GError *error = NULL;

    if (application == NULL || review_context->source_entity_identifier == NULL ||
        application->session == NULL ||
        application->main_window == NULL)
    {
        return;
    }

    database = investigation_session_get_database(application->session);
    project = investigation_session_get_project(application->session);
    database_path = project != NULL
        ? investigation_project_get_database_path(project) : NULL;
    if (!osint_dns_integration_apply(
            database, review_context->source_entity_identifier,
            review_context->execution_identifier,
            selected_proposals, &inserted_count, &skipped_count,
            &inserted_relation_count, &skipped_relation_count, &error
        ))
    {
        application_present_error(
            application,
            "Intégration DNS impossible",
            error != NULL ? error->message
                          : "La transaction DNS a échoué."
        );
        g_clear_error(&error);
        return;
    }

    message = g_strdup_printf(
        "%u entité(s) créée(s), %u entité(s) réutilisée(s) ou ignorée(s).\n"
        "%u relation(s) créée(s), %u relation(s) ignorée(s).\n\n"
        "Les objets créés ou réutilisés sont liés à l'exécution OSINT %s.",
        inserted_count, skipped_count,
        inserted_relation_count, skipped_relation_count,
        review_context->execution_identifier
    );
    application_message_dialog_present(
        main_window_get_window(application->main_window),
        APPLICATION_MESSAGE_DIALOG_INFORMATION,
        "Intégration DNS terminée",
        message
    );
    g_free(message);
    if (database_path != NULL && database_path[0] != '\0')
        application_start_graph_loading(application, database_path);
}

/** @brief Affiche les propositions et demande une sélection explicite. */
static void application_on_osint_prepare_integration(gpointer user_data)
{
    ApplicationOsintReviewContext *context = user_data;
    if (context == NULL || context->application == NULL ||
        context->application->main_window == NULL || context->proposals == NULL)
        return;
    osint_dns_review_dialog_present(
        main_window_get_window(context->application->main_window),
        context->proposals,
        application_on_osint_integration_confirmed,
        context
    );
}

/**
 * @brief Libère le contexte d'une action OSINT.
 */
static void application_osint_action_context_free(
    gpointer user_data
)
{
    ApplicationOsintActionContext *context = user_data;

    if (context == NULL)
    {
        return;
    }

    g_free(context->target_value);
    g_free(context->target_identifier);
    g_free(context->action_identifier);
    g_free(context->started_at);
    g_free(context);
}

/** @brief Extrait un pseudo final depuis une URL de profil social. */
static char *application_osint_search_target(const char *action_identifier,
    const char *target_value)
{
    char *target = g_strdup(target_value != NULL ? target_value : "");
    char *query = NULL;
    char *slash = NULL;
    if (target == NULL) return NULL;
    if (g_str_has_prefix(action_identifier, "social-"))
    {
        query = strchr(target, '?');
        if (query != NULL) *query = '\0';
        slash = strrchr(target, '/');
        if (slash != NULL && slash[1] != '\0')
        {
            char *username = g_strdup(slash + 1);
            g_free(target);
            target = username;
        }
    }
    return target;
}

/** @brief Présente et archive la sortie d'une recherche sociale/email. */
static void application_on_osint_search_completed(BackgroundTask *task,
    gpointer user_data)
{
    ApplicationOsintActionContext *context = user_data;
    const ToolTaskResult *task_result = NULL;
    const ToolProcessResult *process_result = NULL;
    GBytes *stdout_bytes = NULL;
    GBytes *stderr_bytes = NULL;
    char *stdout_text = NULL;
    char *stderr_text = NULL;
    char *details = NULL;
    char *output_directory = NULL;
    char *output_name = NULL;
    char *output_path = NULL;
    guint output_suffix = 0;
    const InvestigationProject *project = NULL;
    GError *error = NULL;
    if (context == NULL || context->application == NULL) return;
    if (background_task_get_state(task) == BACKGROUND_TASK_STATE_CANCELLED)
    {
        main_window_set_status(context->application->main_window,
            "Recherche OSINT annulée.");
        return;
    }
    if (background_task_get_state(task) != BACKGROUND_TASK_STATE_COMPLETED)
    {
        error = background_task_dup_error(task);
        application_present_error(context->application, "Recherche OSINT impossible",
            error != NULL ? error->message : "L'outil OSINT a échoué.");
        g_clear_error(&error);
        return;
    }
    task_result = tool_task_result_from_background_task(task);
    process_result = tool_task_result_get_process_result(task_result);
    stdout_bytes = tool_process_result_ref_stdout(process_result);
    stderr_bytes = tool_process_result_ref_stderr(process_result);
    stdout_text = application_osint_output_to_utf8(stdout_bytes);
    stderr_text = application_osint_output_to_utf8(stderr_bytes);
    project = investigation_session_get_project(context->application->session);
    output_directory = project != NULL ? g_build_filename(
        investigation_project_get_root_path(project), "02_Preuves_Traitees",
        "Extractions", "OSINT", NULL) : NULL;
    if (output_directory == NULL || g_mkdir_with_parents(output_directory, 0750) != 0)
        goto failure;
    output_name = g_strdup_printf("%s-%s.txt", context->target_identifier,
        context->action_identifier);
    output_path = g_build_filename(output_directory, output_name, NULL);
    while (g_file_test(output_path, G_FILE_TEST_EXISTS))
    {
        char *unique_name = g_strdup_printf("%s-%s (%u).txt",
            context->target_identifier, context->action_identifier,
            ++output_suffix);
        g_free(output_name);
        g_free(output_path);
        output_name = unique_name;
        output_path = g_build_filename(output_directory, output_name, NULL);
    }
    details = g_strdup_printf("Cible : %s\nAction : %s\n\n%s%s%s",
        context->target_value, context->action_identifier,
        stdout_text != NULL ? stdout_text : "",
        stderr_text != NULL && stderr_text[0] != '\0' ? "\n\nErreur :\n" : "",
        stderr_text != NULL ? stderr_text : "");
    if (!g_file_set_contents(output_path, details, -1, &error)) goto failure;
    {
        ExtractionDao *extraction_dao = extraction_dao_new(
            investigation_session_get_database(context->application->session),
            &error);
        char *extraction_id = g_uuid_string_random();
        char *created_at = application_osint_create_timestamp();
        if (extraction_dao == NULL || extraction_id == NULL || created_at == NULL ||
            !extraction_dao_insert(extraction_dao, extraction_id, NULL, "entity",
                context->target_identifier, context->action_identifier,
                created_at, &error))
        {
            extraction_dao_free(extraction_dao);
            g_free(extraction_id); g_free(created_at);
            goto failure;
        }
        extraction_dao_free(extraction_dao);
        g_free(extraction_id); g_free(created_at);
    }
    application_message_dialog_present_details_action(
        main_window_get_window(context->application->main_window),
        APPLICATION_MESSAGE_DIALOG_INFORMATION, "Résultat de la recherche OSINT",
        "La sortie publique a été archivée dans les preuves traitées.",
        details, NULL, NULL, NULL, NULL);
    goto cleanup;
failure:
    application_present_error(context->application, "Archivage OSINT impossible",
        error != NULL ? error->message : "La sortie n'a pas pu être conservée.");
cleanup:
    g_clear_error(&error); g_clear_pointer(&stdout_bytes, g_bytes_unref);
    g_clear_pointer(&stderr_bytes, g_bytes_unref); g_free(stdout_text);
    g_free(stderr_text); g_free(details); g_free(output_directory);
    g_free(output_name); g_free(output_path);
}

/** @brief Lance Sherlock, Maigret ou Holehe selon l'action choisie. */
static void application_start_osint_search(Application *application,
    const char *action_identifier, const char *target_identifier,
    const char *target_value)
{
    const char *tool_identifier = NULL;
    const char *arguments[4] = { NULL, NULL, NULL, NULL };
    char *search_target = NULL;
    ToolTask *tool_task = NULL;
    BackgroundTask *background_task = NULL;
    ApplicationOsintActionContext *context = NULL;
    GError *error = NULL;
    if (g_strcmp0(action_identifier, "social-username-sherlock") == 0)
    { tool_identifier = "osint.sherlock"; arguments[0] = "--print-found";
      arguments[1] = "--no-color"; }
    else if (g_strcmp0(action_identifier, "social-username-maigret") == 0)
    { tool_identifier = "osint.maigret"; arguments[0] = "--json";
      arguments[1] = "simple"; }
    else if (g_strcmp0(action_identifier, "email-account-holehe") == 0)
    { tool_identifier = "osint.holehe"; arguments[0] = "--no-color"; }
    else return;
    search_target = application_osint_search_target(action_identifier, target_value);
    arguments[2] = search_target;
    tool_task = tool_task_new(tool_initializer_get_registry(application->tool_initializer),
        tool_identifier, "Recherche OSINT", arguments, NULL, &error);
    if (tool_task == NULL) goto failure;
    context = g_new0(ApplicationOsintActionContext, 1);
    context->application = application;
    context->action_identifier = g_strdup(action_identifier);
    context->target_identifier = g_strdup(target_identifier);
    context->target_value = g_strdup(search_target);
    context->started_at = application_osint_create_timestamp();
    background_task = tool_task_get_background_task(tool_task);
    if (context->action_identifier == NULL || context->target_identifier == NULL ||
        context->target_value == NULL || context->started_at == NULL ||
        !task_manager_add(application->task_manager, background_task, &error) ||
        !tool_task_start(tool_task, application_on_osint_search_completed, context,
            application_osint_action_context_free, &error)) goto failure;
    context = NULL;
    main_window_set_status(application->main_window,
        "Recherche OSINT lancée ; progression disponible dans les tâches.");
    goto cleanup;
failure:
    application_osint_action_context_free(context);
    application_present_error(application, "Recherche OSINT impossible",
        error != NULL ? error->message : "Impossible de démarrer l'outil.");
cleanup:
    g_clear_error(&error); tool_task_free(tool_task); g_free(search_target);
}

/**
 * @brief Libère le contexte du dialogue de métadonnées.
 */
static void application_evidence_dialog_context_free(
    gpointer user_data
)
{
    ApplicationEvidenceDialogContext *context =
        user_data;

    if (context == NULL)
    {
        return;
    }

    g_free(
        context->file_path
    );

    g_free(
        context
    );
}

/**
 * @brief Libère le contexte d’un import asynchrone.
 */
static void application_evidence_import_context_free(
    gpointer user_data
)
{
    ApplicationEvidenceImportContext *context =
        user_data;

    if (context == NULL)
    {
        return;
    }

    g_free(
        context->investigation_root_path
    );

    g_free(
        context
    );
}

/** @brief Libère l'état possédé d'un import groupé. */
static void application_evidence_batch_context_free(
    ApplicationEvidenceBatchContext *context
)
{
    if (context == NULL) return;
    g_clear_pointer(&context->file_paths, g_ptr_array_unref);
    g_clear_pointer(&context->evidence_types, g_ptr_array_unref);
    g_clear_pointer(&context->failures, g_ptr_array_unref);
    g_free(context);
}

/** @brief Affiche le bilan final puis libère l'import groupé. */
static void application_finish_evidence_batch(
    ApplicationEvidenceBatchContext *context
)
{
    GString *details = NULL;
    char *message = NULL;
    if (context == NULL) return;
    details = g_string_new(NULL);
    for (guint index = 0U; index < context->failures->len; index++)
        g_string_append_printf(details, "- %s\n",
            (const char *) g_ptr_array_index(context->failures, index));
    message = g_strdup_printf(
        "%u preuve(s) importée(s), %u ignorée(s), %u échec(s).",
        context->success_count, context->skipped_count, context->failures->len);
    application_message_dialog_present_details(
        main_window_get_window(context->application->main_window),
        context->failures->len == 0U
            ? APPLICATION_MESSAGE_DIALOG_INFORMATION
            : APPLICATION_MESSAGE_DIALOG_WARNING,
        "Import groupé terminé", message,
        details->len > 0U ? details->str : "Tous les fichiers ont été importés.");
    main_window_set_import_evidence_enabled(
        context->application->main_window, TRUE);
    g_free(message); g_string_free(details, TRUE);
    application_evidence_batch_context_free(context);
}

/**
 * @brief Libère le contexte d'une vérification d'intégrité.
 */
static void application_evidence_integrity_context_free(
    gpointer user_data
)
{
    ApplicationEvidenceIntegrityContext *context =
        user_data;

    if (context == NULL)
    {
        return;
    }

    g_free(
        context->original_name
    );

    g_free(
        context->evidence_identifier
    );

    g_free(
        context->database_path
    );

    g_free(
        context->investigation_root_path
    );

    g_free(
        context
    );
}

/**
 * @brief Libère le contexte d'un chargement de graphe.
 */
static void application_graph_load_context_free(
    gpointer user_data
)
{
    g_free(
        user_data
    );
}

/**
 * @brief Annule et détache le chargement de graphe courant.
 *
 * Chaque appel invalide les résultats appartenant à la génération
 * précédente, même lorsqu'aucune tâche n'est encore active.
 */
static void application_cancel_graph_loading(
    Application *application
)
{
    InvestigationGraphLoadTask *load_task =
        NULL;

    if (application == NULL)
    {
        return;
    }

    application->graph_load_generation++;

    load_task =
        application->graph_load_task;

    application->graph_load_task =
        NULL;

    if (load_task == NULL)
    {
        return;
    }

    investigation_graph_load_task_cancel(
        load_task
    );

    investigation_graph_load_task_free(
        load_task
    );
}

/**
 * @brief Détache puis libère le graphe possédé par Application.
 */
static void application_clear_graph(
    Application *application
)
{
    InvestigationGraphModel *graph_model =
        NULL;

    InvestigationGraphLayout *graph_layout =
        NULL;

    if (application == NULL)
    {
        return;
    }

    if (application->main_window != NULL)
    {
        main_window_clear_graph(
            application->main_window
        );
    }

    graph_model =
        application->graph_model;

    graph_layout =
        application->graph_layout;

    application->graph_model =
        NULL;

    application->graph_layout =
        NULL;

    investigation_graph_model_free(
        graph_model
    );

    investigation_graph_layout_free(
        graph_layout
    );
}

/**
 * @brief Traite le résultat d'un chargement asynchrone de graphe.
 *
 * Le callback est exécuté sur le contexte principal GLib.
 */
static void application_on_graph_loaded(
    InvestigationGraphLoadTask *load_task,
    InvestigationGraphModel *graph_model,
    const GError *error,
    gpointer user_data
)
{
    ApplicationGraphLoadContext *context =
        user_data;

    Application *application =
        NULL;

    InvestigationGraphLayout *graph_layout =
        NULL;

    char *status_message =
        NULL;

    gboolean is_current_result =
        FALSE;

    if (context != NULL)
    {
        application =
            context->application;
    }

    graph_layout =
        investigation_graph_load_task_take_layout(
            load_task
        );

    if (application != NULL)
    {
        is_current_result =
            load_task ==
                application->graph_load_task &&
            context->generation ==
                application->graph_load_generation;
    }

    /*
     * Un résultat appartenant à une ancienne enquête ne doit jamais
     * modifier l'interface actuelle.
     */
    if (!is_current_result)
    {
        investigation_graph_model_free(
            graph_model
        );

        investigation_graph_layout_free(
            graph_layout
        );

        investigation_graph_load_task_free(
            load_task
        );

        return;
    }

    application->graph_load_task =
        NULL;

    if (error != NULL)
    {
        investigation_graph_model_free(
            graph_model
        );

        investigation_graph_layout_free(
            graph_layout
        );

        main_window_set_graph_error(
            application->main_window,
            error->message
        );

        main_window_set_status(
            application->main_window,
            "Le graphe de l'enquête n'a pas pu être chargé."
        );

        investigation_graph_load_task_free(
            load_task
        );

        return;
    }

    if (graph_model == NULL ||
        graph_layout == NULL)
    {
        investigation_graph_model_free(
            graph_model
        );

        investigation_graph_layout_free(
            graph_layout
        );

        main_window_set_graph_error(
            application->main_window,
            "Le chargement s'est terminé sans fournir "
            "un graphe et une disposition valides."
        );

        main_window_set_status(
            application->main_window,
            "Le graphe de l'enquête est indisponible."
        );

        investigation_graph_load_task_free(
            load_task
        );

        return;
    }

    /*
     * MainWindow et Workspace doivent être détachés de l'ancien modèle
     * avant sa libération.
     */
    application_clear_graph(
        application
    );

    application->graph_model =
        graph_model;

    application->graph_layout =
        graph_layout;

    main_window_set_graph(
        application->main_window,
        application->graph_model,
        application->graph_layout
    );

    application_restore_graph_viewport(application);

    if (application->pending_relation_selection_identifier != NULL)
    {
        main_window_select_graph_relation(application->main_window,
            application->pending_relation_selection_identifier);
        g_clear_pointer(&application->pending_relation_selection_identifier,
            g_free);
    }
    if (application->pending_entity_selection_identifier != NULL)
    {
        main_window_select_graph_entity(application->main_window,
            application->pending_entity_selection_identifier);
        g_clear_pointer(&application->pending_entity_selection_identifier,
            g_free);
    }

    status_message =
        g_strdup_printf(
            "Graphe chargé : %" G_GUINT64_FORMAT
            " entité(s), %" G_GUINT64_FORMAT
            " relation(s), %u position(s) restaurée(s).",
            investigation_graph_model_get_entity_count(
                application->graph_model
            ),
            investigation_graph_model_get_relation_count(
                application->graph_model
            ),
            investigation_graph_layout_get_count(
                application->graph_layout
            )
        );

    main_window_set_status(
        application->main_window,
        status_message != NULL
            ? status_message
            : "Graphe chargé."
    );

    g_free(
        status_message
    );

    investigation_graph_load_task_free(
        load_task
    );
}

/**
 * @brief Démarre le chargement asynchrone du graphe d'une enquête.
 */
static void application_start_graph_loading(
    Application *application,
    const char *database_path
)
{
    InvestigationGraphLoadTask *load_task =
        NULL;

    ApplicationGraphLoadContext *context =
        NULL;

    GError *error =
        NULL;

    if (application == NULL ||
        application->main_window == NULL)
    {
        return;
    }

    /*
     * Cette opération invalide l'ancienne génération et libère
     * l'ancien chargement avant d'en créer un nouveau.
     */
    application_cancel_graph_loading(
        application
    );

    application_clear_graph(
        application
    );

    if (database_path == NULL ||
        database_path[0] == '\0')
    {
        main_window_set_graph_error(
            application->main_window,
            "Le chemin de la base SQLite est invalide."
        );

        return;
    }

    main_window_set_graph_loading(
        application->main_window
    );

    load_task =
        investigation_graph_load_task_new(
            database_path,
            &error
        );

    if (load_task == NULL)
    {
        main_window_set_graph_error(
            application->main_window,
            error != NULL
                ? error->message
                : "Impossible de préparer le chargement du graphe."
        );

        g_clear_error(
            &error
        );

        return;
    }

    context =
        g_try_new0(
            ApplicationGraphLoadContext,
            1
        );

    if (context == NULL)
    {
        investigation_graph_load_task_free(
            load_task
        );

        main_window_set_graph_error(
            application->main_window,
            "Impossible d'allouer le contexte de chargement."
        );

        return;
    }

    context->application =
        application;

    context->generation =
        application->graph_load_generation;

    application->graph_load_task =
        load_task;

    if (!investigation_graph_load_task_start(
            load_task,
            application_on_graph_loaded,
            context,
            application_graph_load_context_free,
            &error
        ))
    {
        /*
         * En cas d'échec immédiat, la tâche n'a pas pris possession
         * du contexte fourni.
         */
        application->graph_load_task =
            NULL;

        application_graph_load_context_free(
            context
        );

        investigation_graph_load_task_free(
            load_task
        );

        main_window_set_graph_error(
            application->main_window,
            error != NULL
                ? error->message
                : "Impossible de démarrer le chargement du graphe."
        );

        g_clear_error(
            &error
        );
    }
}

/**
 * @brief Vérifie que l’enquête active correspond à un chemin racine.
 */
static gboolean application_session_matches_root(
    const Application *application,
    const char *expected_root_path
)
{
    const InvestigationProject *project = NULL;
    const char *current_root_path = NULL;

    if (application == NULL ||
        application->session == NULL ||
        expected_root_path == NULL)
    {
        return FALSE;
    }

    project =
        investigation_session_get_project(
            application->session
        );

    if (project == NULL)
    {
        return FALSE;
    }

    current_root_path =
        investigation_project_get_root_path(
            project
        );

    return g_strcmp0(
        current_root_path,
        expected_root_path
    ) == 0;
}

/**
 * @brief Mémorise l'identifiant de la preuve actuellement affichée.
 */
static void application_set_selected_evidence_identifier(
    Application *application,
    const char *evidence_identifier
)
{
    char *identifier_copy =
        NULL;

    if (application == NULL)
    {
        return;
    }

    if (evidence_identifier != NULL &&
        g_uuid_string_is_valid(
            evidence_identifier
        ))
    {
        identifier_copy =
            g_strdup(
                evidence_identifier
            );
    }

    g_free(
        application->selected_evidence_identifier
    );

    application->selected_evidence_identifier =
        identifier_copy;
}

static void application_present_error(
    Application *application,
    const char *title,
    const char *message
);

/**
 * @brief Publie dans l'interface les états du registre d'outils.
 */
static void application_publish_osint_tool_states(
    Application *application
)
{
    ToolRegistry *tool_registry = NULL;
    gsize tool_index = 0;

    if (application == NULL || application->main_window == NULL ||
        application->tool_initializer == NULL)
    {
        return;
    }

    tool_registry = tool_initializer_get_registry(application->tool_initializer);
    for (tool_index = 0;
         tool_registry != NULL && tool_index < tool_registry_get_count(tool_registry);
         tool_index++)
    {
        const ToolInfo *tool_info = tool_registry_get_tool(tool_registry, tool_index);
        OsintActionToolState state = OSINT_ACTION_TOOL_STATE_UNKNOWN;
        if (tool_info_get_availability(tool_info) == TOOL_AVAILABILITY_AVAILABLE)
            state = OSINT_ACTION_TOOL_STATE_AVAILABLE;
        else if (tool_info_get_availability(tool_info) == TOOL_AVAILABILITY_MISSING)
            state = OSINT_ACTION_TOOL_STATE_MISSING;
        main_window_set_osint_tool_state(
            application->main_window,
            tool_info_get_identifier(tool_info),
            state,
            tool_info_get_detected_version(tool_info)
        );
    }
}

/**
 * @brief Traite la fin de l’initialisation des outils externes.
 *
 * Ce callback est exécuté sur le contexte principal GLib.
 *
 * @param tool_initializer Initialiseur ayant terminé.
 * @param final_state État final de la tâche.
 * @param summary Résumé emprunté en cas de réussite.
 * @param error Erreur empruntée en cas d’échec.
 * @param user_data Pointeur emprunté vers Application.
 */
static void application_on_tool_initialization_completed(
    ToolInitializer *tool_initializer,
    BackgroundTaskState final_state,
    const ToolInitializationSummary *summary,
    const GError *error,
    gpointer user_data
)
{
    Application *application = user_data;

    if (application == NULL ||
        tool_initializer == NULL)
    {
        return;
    }

    if (tool_initializer !=
        application->tool_initializer)
    {
        g_warning(
            "Notification reçue depuis un initialiseur inconnu."
        );

        return;
    }

    switch (final_state)
    {
        case BACKGROUND_TASK_STATE_COMPLETED:
            if (summary == NULL)
            {
                g_warning(
                    "L’initialisation des outils est terminée "
                    "sans résumé valide."
                );

                return;
            }

            g_message(
                "Outils externes initialisés : "
                "%" G_GSIZE_FORMAT " disponibles, "
                "%" G_GSIZE_FORMAT " absents, "
                "%" G_GSIZE_FORMAT " versions détectées, "
                "%" G_GSIZE_FORMAT " versions non détectées.",
                summary->available_count,
                summary->missing_count,
                summary->version_detected_count,
                summary->version_failed_count
            );

            break;

        case BACKGROUND_TASK_STATE_CANCELLED:
            g_message(
                "L’initialisation des outils externes a été annulée."
            );

            break;

        case BACKGROUND_TASK_STATE_FAILED:
            g_warning(
                "L’initialisation des outils externes a échoué : %s",
                error != NULL
                    ? error->message
                    : "erreur inconnue"
            );

            application_present_error(
                application,
                "Initialisation des outils impossible",
                error != NULL
                    ? error->message
                    : "Les outils externes n’ont pas pu être initialisés."
            );

            break;

        case BACKGROUND_TASK_STATE_PENDING:
        case BACKGROUND_TASK_STATE_RUNNING:
        default:
            g_warning(
                "Notification de fin reçue avec un état invalide : %d.",
                (int) final_state
            );

            break;
    }

    application_publish_osint_tool_states(application);
}

/**
 * @brief Démarre la détection asynchrone des outils externes.
 *
 * Une erreur empêche seulement l’initialisation des outils.
 * Elle ne doit pas fermer l’application.
 *
 * @param application Application concernée.
 */
static void application_start_tool_initialization(
    Application *application
)
{
    GError *error = NULL;

    if (application == NULL ||
        application->tool_initializer == NULL)
    {
        return;
    }

    if (!tool_initializer_start(
        application->tool_initializer,
        &error
    ))
    {
        g_warning(
            "Impossible d’initialiser les outils externes : %s",
            error != NULL
            ? error->message
            : "erreur inconnue"
        );

        application_present_error(
            application,
            "Initialisation des outils impossible",
            error != NULL
            ? error->message
            : "Les outils externes n’ont pas pu être initialisés."
        );

        g_clear_error(
            &error
        );
    }
}

/**
 * @brief Convertit une sortie binaire d'outil en texte UTF-8 affichable.
 *
 * @param bytes Octets empruntés, ou NULL.
 *
 * @return Nouvelle chaîne UTF-8, jamais NULL.
 */
static char *application_osint_output_to_utf8(
    GBytes *bytes
)
{
    gconstpointer data = NULL;
    gsize data_size = 0;

    if (bytes == NULL)
    {
        return g_strdup("");
    }

    data = g_bytes_get_data(bytes, &data_size);
    if (data == NULL || data_size == 0U)
    {
        return g_strdup("");
    }

    return g_utf8_make_valid(data, (gssize) data_size);
}

/** @brief Crée une date UTC au format persistant du projet. */
static char *application_osint_create_timestamp(void)
{
    GDateTime *now = g_date_time_new_now_utc();
    char *timestamp = now != NULL
        ? g_date_time_format(now, "%Y-%m-%dT%H:%M:%SZ") : NULL;
    g_clear_pointer(&now, g_date_time_unref);
    return timestamp;
}

/** @brief Persiste une exécution DNS terminée et retourne son UUID. */
static char *application_persist_dns_execution(
    ApplicationOsintActionContext *context,
    const char *final_state,
    gboolean has_exit_code,
    gint exit_code,
    GBytes *stdout_raw,
    GBytes *stderr_raw,
    GError **error
)
{
    Application *application = context != NULL ? context->application : NULL;
    ToolRegistry *registry = NULL;
    const ToolInfo *tool_info = NULL;
    Database *database = NULL;
    OsintExecutionDao *dao = NULL;
    OsintExecutionRecord *record = NULL;
    char *identifier = NULL;
    char *finished_at = NULL;
    char *arguments = NULL;
    char *sha256 = NULL;
    gboolean inserted = FALSE;
    if (application == NULL || application->session == NULL) return NULL;
    database = investigation_session_get_database(application->session);
    registry = tool_initializer_get_registry(application->tool_initializer);
    tool_info = tool_registry_find(registry, "dns.dig");
    identifier = g_uuid_string_random();
    finished_at = application_osint_create_timestamp();
    arguments = g_strdup_printf(
        "[\"+noall\",\"+answer\",\"%s\"]", context->target_value
    );
    sha256 = osint_execution_integrity_calculate(stdout_raw, stderr_raw);
    record = osint_execution_record_new(
        identifier, "dns.dig",
        tool_info != NULL ? tool_info_get_detected_version(tool_info) : NULL,
        "dns-preview", context->target_identifier, "entity",
        context->target_value, arguments, context->started_at, finished_at,
        has_exit_code, exit_code, final_state, stdout_raw, stderr_raw, sha256,
        error
    );
    dao = osint_execution_dao_new(database, error);
    if (record != NULL && dao != NULL)
        inserted = osint_execution_dao_insert(dao, record, error);
    osint_execution_dao_free(dao);
    osint_execution_record_free(record);
    g_free(finished_at); g_free(arguments); g_free(sha256);
    if (!inserted) g_clear_pointer(&identifier, g_free);
    return identifier;
}

/**
 * @brief Présente le résultat final d'une résolution DNS.
 */
static void application_on_dns_lookup_completed(
    BackgroundTask *task,
    gpointer user_data
)
{
    ApplicationOsintActionContext *context = user_data;
    Application *application = NULL;
    const ToolTaskResult *task_result = NULL;
    const ToolProcessResult *process_result = NULL;
    GBytes *stdout_bytes = NULL;
    GBytes *stderr_bytes = NULL;
    char *stdout_text = NULL;
    char *stderr_text = NULL;
    char *details = NULL;
    char *message = NULL;
    char *execution_identifier = NULL;
    GPtrArray *proposals = NULL;
    ApplicationOsintReviewContext *review_context = NULL;
    GError *error = NULL;
    const ToolInfo *dns_tool_info = NULL;

    if (task == NULL || context == NULL || context->application == NULL)
    {
        return;
    }

    application = context->application;
    if (application->main_window == NULL)
    {
        return;
    }

    dns_tool_info = tool_registry_find(
        tool_initializer_get_registry(application->tool_initializer),
        "dns.dig"
    );

    if (background_task_get_state(task) == BACKGROUND_TASK_STATE_CANCELLED)
    {
        GBytes *empty_output = g_bytes_new_static("", 0U);
        execution_identifier = application_persist_dns_execution(
            context, "cancelled", FALSE, -1, empty_output, empty_output, &error
        );
        g_bytes_unref(empty_output);
        application_message_dialog_present(
            main_window_get_window(application->main_window),
            APPLICATION_MESSAGE_DIALOG_INFORMATION,
            "Résolution DNS annulée",
            execution_identifier != NULL
                ? "La tâche a été annulée et sa provenance a été enregistrée."
                : "La tâche a été annulée, mais sa provenance n'a pas pu être enregistrée."
        );
        g_free(execution_identifier);
        g_clear_error(&error);
        return;
    }

    if (background_task_get_state(task) != BACKGROUND_TASK_STATE_COMPLETED)
    {
        GBytes *empty_output = g_bytes_new_static("", 0U);
        execution_identifier = application_persist_dns_execution(
            context, "failed", FALSE, -1, empty_output, empty_output, NULL
        );
        g_bytes_unref(empty_output);
        error = background_task_dup_error(task);
        application_present_error(
            application,
            "Résolution DNS impossible",
            error != NULL
                ? error->message
                : "L'exécution de dig a été annulée ou a échoué."
        );
        g_free(execution_identifier);
        g_clear_error(&error);
        return;
    }

    task_result = tool_task_result_from_background_task(task);
    process_result = tool_task_result_get_process_result(task_result);
    if (process_result == NULL)
    {
        application_present_error(
            application,
            "Résolution DNS incomplète",
            "La tâche s'est terminée sans résultat exploitable."
        );
        return;
    }

    stdout_bytes = tool_process_result_ref_stdout(process_result);
    stderr_bytes = tool_process_result_ref_stderr(process_result);
    execution_identifier = application_persist_dns_execution(
        context, "completed", TRUE,
        tool_process_result_get_exit_status(process_result),
        stdout_bytes, stderr_bytes, &error
    );
    if (execution_identifier == NULL)
    {
        application_present_error(
            application,
            "Conservation OSINT impossible",
            error != NULL ? error->message
                          : "La sortie brute n'a pas pu être enregistrée."
        );
        g_clear_error(&error);
        g_clear_pointer(&stdout_bytes, g_bytes_unref);
        return;
    }
    stdout_text = application_osint_output_to_utf8(stdout_bytes);
    stderr_text = application_osint_output_to_utf8(stderr_bytes);

    if (stdout_text != NULL && stdout_text[0] != '\0' &&
        stderr_text != NULL && stderr_text[0] != '\0')
    {
        details = g_strdup_printf(
            "Sortie standard :\n%s\n\nSortie d'erreur :\n%s",
            stdout_text,
            stderr_text
        );
    }
    else if (stdout_text != NULL && stdout_text[0] != '\0')
    {
        details = g_strdup(stdout_text);
    }
    else if (stderr_text != NULL && stderr_text[0] != '\0')
    {
        details = g_strdup(stderr_text);
    }
    else
    {
        details = g_strdup("Aucun enregistrement DNS retourné.");
    }

    proposals = osint_dns_proposal_parse(context->target_value, stdout_text);
    if (tool_process_result_is_success(process_result) &&
        proposals != NULL && proposals->len > 0U)
    {
        review_context = g_try_new0(ApplicationOsintReviewContext, 1);
        if (review_context != NULL)
        {
            review_context->application = application;
            review_context->source_entity_identifier = g_strdup(
                context->target_identifier
            );
            review_context->execution_identifier = g_strdup(
                execution_identifier
            );
            review_context->proposals = g_ptr_array_ref(proposals);
        }
        if (review_context == NULL || review_context->proposals == NULL ||
            review_context->source_entity_identifier == NULL ||
            review_context->execution_identifier == NULL)
        {
            application_osint_review_context_free(review_context);
            review_context = NULL;
        }
    }

    message = g_strdup_printf(
        "Cible : %s\nOutil : dns.dig%s%s\nDébut : %s\nCode de sortie : %d\n"
        "Exécution : %s\nSortie brute enregistrée avec son empreinte SHA-256.",
        context->target_value,
        dns_tool_info != NULL &&
            tool_info_get_detected_version(dns_tool_info) != NULL ? " — " : "",
        dns_tool_info != NULL &&
            tool_info_get_detected_version(dns_tool_info) != NULL
                ? tool_info_get_detected_version(dns_tool_info) : "",
        context->started_at,
        tool_process_result_get_exit_status(process_result),
        execution_identifier
    );

    application_message_dialog_present_details_action(
        main_window_get_window(application->main_window),
        tool_process_result_is_success(process_result)
            ? APPLICATION_MESSAGE_DIALOG_INFORMATION
            : APPLICATION_MESSAGE_DIALOG_WARNING,
        "Résultat de la résolution DNS",
        message,
        details,
        review_context != NULL ? "Préparer l'intégration" : NULL,
        review_context != NULL
            ? application_on_osint_prepare_integration
            : NULL,
        review_context,
        application_osint_review_context_free
    );

    g_clear_pointer(&stdout_bytes, g_bytes_unref);
    g_clear_pointer(&stderr_bytes, g_bytes_unref);
    g_free(stdout_text);
    g_free(stderr_text);
    g_free(details);
    g_free(message);
    g_free(execution_identifier);
    g_clear_pointer(&proposals, g_ptr_array_unref);
}

/**
 * @brief Prépare et démarre une résolution DNS avec dig.
 */
static void application_start_dns_lookup(
    Application *application,
    const char *target_identifier,
    const char *target_value
)
{
    ToolRegistry *tool_registry = NULL;
    ToolTask *tool_task = NULL;
    BackgroundTask *background_task = NULL;
    ApplicationOsintActionContext *context = NULL;
    const char *arguments[] = {"+noall", "+answer", target_value, NULL};
    GError *error = NULL;

    if (application == NULL || application->task_manager == NULL ||
        application->tool_initializer == NULL || target_value == NULL ||
        target_identifier == NULL || !g_uuid_string_is_valid(target_identifier) ||
        !osint_dns_query_is_valid_target(target_value))
    {
        if (application != NULL)
        {
            application_present_error(
                application,
                "Résolution DNS impossible",
                "Le nom de domaine sélectionné est invalide."
            );
        }
        return;
    }

    tool_registry = tool_initializer_get_registry(application->tool_initializer);
    tool_task = tool_task_new(
        tool_registry,
        "dns.dig",
        "Résolution DNS",
        arguments,
        NULL,
        &error
    );

    if (tool_task == NULL)
    {
        application_present_error(
            application,
            "Résolution DNS impossible",
            error != NULL ? error->message : "Impossible de préparer dig."
        );
        g_clear_error(&error);
        return;
    }

    context = g_try_new0(ApplicationOsintActionContext, 1);
    if (context != NULL)
    {
        context->application = application;
        context->target_identifier = g_strdup(target_identifier);
        context->target_value = g_strdup(target_value);
        context->started_at = application_osint_create_timestamp();
    }

    if (context == NULL || context->target_identifier == NULL ||
        context->target_value == NULL || context->started_at == NULL)
    {
        application_osint_action_context_free(context);
        tool_task_free(tool_task);
        application_present_error(
            application,
            "Résolution DNS impossible",
            "Impossible de conserver le contexte de l'action."
        );
        return;
    }

    background_task = tool_task_get_background_task(tool_task);
    if (!task_manager_add(application->task_manager, background_task, &error) ||
        !tool_task_start(
            tool_task,
            application_on_dns_lookup_completed,
            context,
            application_osint_action_context_free,
            &error
        ))
    {
        task_manager_remove(application->task_manager, background_task);
        application_osint_action_context_free(context);
        application_present_error(
            application,
            "Résolution DNS impossible",
            error != NULL ? error->message : "Impossible de démarrer dig."
        );
        g_clear_error(&error);
        tool_task_free(tool_task);
        return;
    }

    tool_task_free(tool_task);
}

/** @brief Charge et présente l'historique OSINT d'une sélection. */
static void application_present_osint_history(
    Application *application,
    const char *selection_kind,
    const char *selection_identifier
)
{
    Database *database = NULL;
    OsintExecutionDao *dao = NULL;
    GPtrArray *records = NULL;
    GHashTable *linked_objects = NULL;
    GError *error = NULL;
    if (application == NULL || application->session == NULL ||
        application->main_window == NULL) return;
    database = investigation_session_get_database(application->session);
    dao = osint_execution_dao_new(database, &error);
    if (dao != NULL) records = osint_execution_dao_list_by_selection(
        dao, selection_kind, selection_identifier, &error);
    linked_objects = g_hash_table_new_full(
        g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_ptr_array_unref);
    for (guint index = 0U; records != NULL && index < records->len; index++)
    {
        const OsintExecutionRecord *record = g_ptr_array_index(records, index);
        GPtrArray *objects = osint_execution_dao_list_linked_objects(
            dao, osint_execution_record_get_identifier(record), &error);
        if (objects == NULL) break;
        g_hash_table_insert(linked_objects,
            g_strdup(osint_execution_record_get_identifier(record)), objects);
    }
    osint_execution_dao_free(dao);
    if (error != NULL)
    {
        application_present_error(application, "Historique OSINT indisponible",
            error->message);
        g_clear_error(&error);
    }
    else if (records == NULL || records->len == 0U)
    {
        application_message_dialog_present(
            main_window_get_window(application->main_window),
            APPLICATION_MESSAGE_DIALOG_INFORMATION,
            "Historique OSINT",
            "Aucune exécution OSINT n'est enregistrée pour cette sélection."
        );
    }
    else
    {
        osint_execution_history_dialog_present(
            main_window_get_window(application->main_window),
            records, linked_objects);
    }
    g_clear_pointer(&records, g_ptr_array_unref);
    g_hash_table_unref(linked_objects);
}

/**
 * @brief Traite une action OSINT relayée par la fenêtre principale.
 */
static void application_on_osint_action_requested(
    const char *action_identifier,
    const char *target_identifier,
    const char *target_value,
    gpointer user_data
)
{
    Application *application = user_data;

    if (g_strcmp0(action_identifier, "history-entity") == 0 ||
        g_strcmp0(action_identifier, "history-relation") == 0)
    {
        application_present_osint_history(
            application,
            g_strcmp0(action_identifier, "history-relation") == 0
                ? "relation" : "entity",
            target_identifier
        );
        return;
    }

    if (g_strcmp0(action_identifier, "dns-preview") == 0)
    {
        application_start_dns_lookup(
            application, target_identifier, target_value
        );
        return;
    }

    if (g_strcmp0(action_identifier, "social-username-sherlock") == 0 ||
        g_strcmp0(action_identifier, "social-username-maigret") == 0 ||
        g_strcmp0(action_identifier, "email-account-holehe") == 0)
    {
        application_start_osint_search(application, action_identifier,
            target_identifier, target_value);
        return;
    }

    application_present_error(
        application,
        "Action OSINT inconnue",
        "Cette action n'est pas encore prise en charge."
    );
}

/**
 * @brief Affiche une erreur dans une fenêtre GTK.
 *
 * @param application Application propriétaire de la fenêtre principale.
 * @param title Titre compréhensible par l'utilisateur.
 * @param message Description de l'erreur.
 */
static void application_present_error(
    Application *application,
    const char *title,
    const char *message
)
{
    GtkWindow *parent_window = NULL;

    if (application != NULL &&
        application->main_window != NULL)
    {
        parent_window = main_window_get_window(
            application->main_window
        );
    }

    application_message_dialog_present(
        parent_window,
        APPLICATION_MESSAGE_DIALOG_ERROR,
        title,
        message
    );
}

static void application_on_tool_initialization_completed(
    ToolInitializer *tool_initializer,
    BackgroundTaskState final_state,
    const ToolInitializationSummary *summary,
    const GError *error,
    gpointer user_data
);

static void application_present_error(
    Application *application,
    const char *title,
    const char *message
);

/**
 * @brief Charge les preuves de la session et construit leurs modèles GTK.
 *
 * Les nouveaux modèles sont entièrement préparés avant de remplacer
 * ceux actuellement affichés.
 *
 * En cas d'échec, les anciens modèles restent la propriété de
 * l'application et ne sont pas modifiés.
 */
static gboolean application_refresh_evidence_models(
    Application *application,
    GError **error
)
{
    Database *database = NULL;

    EvidenceDao *evidence_dao = NULL;
    EvidenceTypeDao *evidence_type_dao = NULL;

    GPtrArray *evidence_records = NULL;
    GPtrArray *evidence_types = NULL;

    GHashTable *type_labels = NULL;

    EvidenceListModel *new_evidence_list_model =
        NULL;

    EvidenceCategoryModel *new_evidence_category_model =
        NULL;

    GError *local_error = NULL;

    guint type_index = 0;

    gboolean refreshed = FALSE;

    g_return_val_if_fail(
        error == NULL || *error == NULL,
        FALSE
    );

    if (application == NULL ||
        application->main_window == NULL ||
        application->session == NULL)
    {
        g_set_error_literal(
            error,
            APPLICATION_OPEN_ERROR,
            APPLICATION_OPEN_ERROR_EVIDENCE,
            "L'application ou la session d'enquête est invalide."
        );

        return FALSE;
    }

    database =
        investigation_session_get_database(
            application->session
        );

    if (database == NULL)
    {
        g_set_error_literal(
            error,
            APPLICATION_OPEN_ERROR,
            APPLICATION_OPEN_ERROR_EVIDENCE,
            "La session ne fournit aucune connexion SQLite."
        );

        return FALSE;
    }

    evidence_dao =
        evidence_dao_new(
            database,
            &local_error
        );

    if (evidence_dao == NULL)
    {
        if (local_error != NULL)
        {
            if (error != NULL)
            {
                g_propagate_prefixed_error(
                    error,
                    local_error,
                    "Impossible de créer le DAO des preuves : "
                );

                local_error = NULL;
            }
            else
            {
                g_clear_error(
                    &local_error
                );
            }
        }
        else
        {
            g_set_error_literal(
                error,
                APPLICATION_OPEN_ERROR,
                APPLICATION_OPEN_ERROR_EVIDENCE,
                "Impossible de créer le DAO des preuves."
            );
        }

        goto cleanup;
    }

    evidence_records =
        evidence_dao_list_all(
            evidence_dao,
            &local_error
        );

    if (evidence_records == NULL)
    {
        if (local_error != NULL)
        {
            if (error != NULL)
            {
                g_propagate_prefixed_error(
                    error,
                    local_error,
                    "Impossible de charger les preuves : "
                );

                local_error = NULL;
            }
            else
            {
                g_clear_error(
                    &local_error
                );
            }
        }
        else
        {
            g_set_error_literal(
                error,
                APPLICATION_OPEN_ERROR,
                APPLICATION_OPEN_ERROR_EVIDENCE,
                "Impossible de charger les preuves."
            );
        }

        goto cleanup;
    }

    evidence_type_dao =
        evidence_type_dao_new(
            database,
            &local_error
        );

    if (evidence_type_dao == NULL)
    {
        if (local_error != NULL)
        {
            if (error != NULL)
            {
                g_propagate_prefixed_error(
                    error,
                    local_error,
                    "Impossible de créer le DAO des types de preuve : "
                );

                local_error = NULL;
            }
            else
            {
                g_clear_error(
                    &local_error
                );
            }
        }
        else
        {
            g_set_error_literal(
                error,
                APPLICATION_OPEN_ERROR,
                APPLICATION_OPEN_ERROR_EVIDENCE,
                "Impossible de créer le DAO des types de preuve."
            );
        }

        goto cleanup;
    }

    evidence_types =
        evidence_type_dao_list_all(
            evidence_type_dao,
            &local_error
        );

    if (evidence_types == NULL)
    {
        if (local_error != NULL)
        {
            if (error != NULL)
            {
                g_propagate_prefixed_error(
                    error,
                    local_error,
                    "Impossible de charger les types de preuve : "
                );

                local_error = NULL;
            }
            else
            {
                g_clear_error(
                    &local_error
                );
            }
        }
        else
        {
            g_set_error_literal(
                error,
                APPLICATION_OPEN_ERROR,
                APPLICATION_OPEN_ERROR_EVIDENCE,
                "Impossible de charger les types de preuve."
            );
        }

        goto cleanup;
    }

    type_labels =
        g_hash_table_new_full(
            g_str_hash,
            g_str_equal,
            g_free,
            g_free
        );

    if (type_labels == NULL)
    {
        g_set_error_literal(
            error,
            APPLICATION_OPEN_ERROR,
            APPLICATION_OPEN_ERROR_EVIDENCE,
            "Impossible d'allouer la table des libellés."
        );

        goto cleanup;
    }

    for (type_index = 0;
         type_index < evidence_types->len;
         type_index++)
    {
        const EvidenceType *evidence_type =
            NULL;

        const char *type_code = NULL;
        const char *type_label = NULL;

        evidence_type =
            g_ptr_array_index(
                evidence_types,
                type_index
            );

        if (evidence_type == NULL)
        {
            continue;
        }

        type_code =
            evidence_type_get_code(
                evidence_type
            );

        type_label =
            evidence_type_get_label(
                evidence_type
            );

        if (type_code == NULL ||
            type_code[0] == '\0' ||
            type_label == NULL ||
            type_label[0] == '\0')
        {
            continue;
        }

        g_hash_table_replace(
            type_labels,
            g_strdup(
                type_code
            ),
            g_strdup(
                type_label
            )
        );
    }

    new_evidence_list_model =
        evidence_list_model_new();

    new_evidence_category_model =
        evidence_category_model_new();

    if (new_evidence_list_model == NULL ||
        new_evidence_category_model == NULL)
    {
        g_set_error_literal(
            error,
            APPLICATION_OPEN_ERROR,
            APPLICATION_OPEN_ERROR_EVIDENCE,
            "Impossible d'allouer les modèles d'affichage des preuves."
        );

        goto cleanup;
    }

    if (!evidence_list_model_replace(
            new_evidence_list_model,
            evidence_records,
            &local_error
        ))
    {
        if (local_error != NULL)
        {
            if (error != NULL)
            {
                g_propagate_prefixed_error(
                    error,
                    local_error,
                    "Impossible de préparer la liste des preuves : "
                );

                local_error = NULL;
            }
            else
            {
                g_clear_error(
                    &local_error
                );
            }
        }

        goto cleanup;
    }

    if (!evidence_category_model_replace(
            new_evidence_category_model,
            evidence_list_model_get_list_model(
                new_evidence_list_model
            ),
            type_labels,
            &local_error
        ))
    {
        if (local_error != NULL)
        {
            if (error != NULL)
            {
                g_propagate_prefixed_error(
                    error,
                    local_error,
                    "Impossible de regrouper les preuves : "
                );

                local_error = NULL;
            }
            else
            {
                g_clear_error(
                    &local_error
                );
            }
        }

        goto cleanup;
    }

    /*
     * La vue doit être détachée avant la libération de son ancien modèle.
     */
    main_window_set_evidence_model(
        application->main_window,
        NULL
    );

    evidence_category_model_free(
        application->evidence_category_model
    );

    evidence_list_model_free(
        application->evidence_list_model
    );

    application->evidence_list_model =
        new_evidence_list_model;

    application->evidence_category_model =
        new_evidence_category_model;

    new_evidence_list_model =
        NULL;

    new_evidence_category_model =
        NULL;

    main_window_set_evidence_model(
        application->main_window,
        application->evidence_category_model
    );

    refreshed = TRUE;

cleanup:

    g_clear_error(
        &local_error
    );

    evidence_category_model_free(
        new_evidence_category_model
    );

    evidence_list_model_free(
        new_evidence_list_model
    );

    if (type_labels != NULL)
    {
        g_hash_table_unref(
            type_labels
        );
    }

    if (evidence_types != NULL)
    {
        g_ptr_array_unref(
            evidence_types
        );
    }

    if (evidence_records != NULL)
    {
        g_ptr_array_unref(
            evidence_records
        );
    }

    evidence_type_dao_free(
        evidence_type_dao
    );

    evidence_dao_free(
        evidence_dao
    );

    return refreshed;
}

/**
 * @brief Installe une nouvelle session et son arbre dans l'application.
 *
 * En cas de succès, Application devient propriétaire de new_session
 * et de new_tree_model.
 *
 * En cas d'échec, le code appelant conserve la propriété des deux objets.
 *
 * @param application Application à mettre à jour.
 * @param new_session Nouvelle session valide.
 * @param new_tree_model Nouvel arbre valide.
 *
 * @return TRUE si l'installation réussit, sinon FALSE.
 */
static gboolean application_install_session(
    Application *application,
    InvestigationSession *new_session,
    InvestigationTreeModel *new_tree_model
)
{
    const InvestigationProject *project = NULL;
    const InvestigationRecord *record = NULL;

    const char *root_path = NULL;
    const char *database_path = NULL;
    const char *investigation_name = NULL;

    GError *evidence_error = NULL;

    if (application == NULL ||
        application->main_window == NULL ||
        new_session == NULL ||
        new_tree_model == NULL)
    {
        return FALSE;
    }

    project = investigation_session_get_project(
        new_session
    );

    record = investigation_session_get_record(
        new_session
    );

    if (project == NULL ||
        record == NULL)
    {
        return FALSE;
    }

    root_path = investigation_project_get_root_path(
        project
    );

    database_path =
        investigation_project_get_database_path(
            project
        );

    investigation_name = investigation_record_get_name(
        record
    );

    if (root_path == NULL ||
        root_path[0] == '\0' ||
        database_path == NULL ||
        database_path[0] == '\0' ||
        investigation_name == NULL ||
        investigation_name[0] == '\0')
    {
        return FALSE;
    }

    application_set_selected_evidence_identifier(
        application,
        NULL
    );

    main_window_set_selected_evidence(
        application->main_window,
        NULL
    );

    /*
     * Les nouveaux objets sont entièrement valides.
     * Les anciens peuvent maintenant être libérés.
     */
    investigation_tree_model_free(
        application->tree_model
    );

    if (application->graph_viewport_save_source_id != 0U)
    {
        g_source_remove(application->graph_viewport_save_source_id);
        application->graph_viewport_save_source_id = 0U;
    }
    application_save_graph_viewport(application);
    task_manager_cancel_all(application->task_manager);
    investigation_session_close(
        application->session
    );

    application->tree_model = new_tree_model;
    application->session = new_session;
    application->session_generation++;
    application->graph_viewport_restored = FALSE;

    main_window_set_tree_model(
        application->main_window,
        application->tree_model
    );

    main_window_set_investigation(
        application->main_window,
        investigation_name,
        root_path
    );

    main_window_set_import_evidence_enabled(
        application->main_window,
        TRUE
    );

    main_window_set_add_social_account_enabled(
        application->main_window,
        TRUE
    );
    main_window_set_add_person_enabled(application->main_window, TRUE);

    application_start_graph_loading(
        application,
        database_path
    );

    /*
     * L'ancienne liste ne doit jamais rester affichée après
     * un changement d'enquête.
     */
    main_window_set_evidence_model(
        application->main_window,
        NULL
    );

    evidence_category_model_free(
        application->evidence_category_model
    );

    evidence_list_model_free(
        application->evidence_list_model
    );

    application->evidence_category_model =
        NULL;

    application->evidence_list_model =
        NULL;

    if (!application_refresh_evidence_models(
            application,
            &evidence_error
        ))
    {
        g_warning(
            "Impossible de charger les preuves de l'enquête : %s",
            evidence_error != NULL
                ? evidence_error->message
                : "erreur inconnue"
        );

        application_present_error(
            application,
            "Preuves indisponibles",
            evidence_error != NULL
                ? evidence_error->message
                : "Les preuves enregistrées n'ont pas pu être chargées."
        );

        g_clear_error(
            &evidence_error
        );
    }

    return TRUE;
}

/**
 * @brief Ouvre une enquête et l'installe dans l'application.
 *
 * En cas de succès, Application devient propriétaire de la nouvelle
 * session et du nouvel arbre.
 *
 * En cas d'échec, l'état précédent de l'application reste inchangé.
 *
 * @param application Application à mettre à jour.
 * @param root_path Chemin racine de l'enquête.
 * @param error Emplacement facultatif pour l'erreur.
 *
 * @return TRUE si l'enquête est ouverte et installée, sinon FALSE.
 */
static gboolean application_open_and_install_investigation(
    Application *application,
    const char *root_path,
    GError **error
)
{
    InvestigationSession *new_session = NULL;
    InvestigationTreeModel *new_tree_model = NULL;

    const InvestigationProject *project = NULL;
    const char *canonical_root_path = NULL;

    GError *session_error = NULL;

    g_return_val_if_fail(
        error == NULL || *error == NULL,
        FALSE
    );

    if (application == NULL ||
        application->main_window == NULL)
    {
        g_set_error_literal(
            error,
            APPLICATION_OPEN_ERROR,
            APPLICATION_OPEN_ERROR_INVALID_ARGUMENT,
            "L'application ou sa fenêtre principale est invalide."
        );

        return FALSE;
    }

    if (root_path == NULL ||
        root_path[0] == '\0')
    {
        g_set_error_literal(
            error,
            APPLICATION_OPEN_ERROR,
            APPLICATION_OPEN_ERROR_INVALID_ARGUMENT,
            "Le chemin racine de l'enquête est invalide."
        );

        return FALSE;
    }

    new_session = investigation_session_open(
        root_path,
        &session_error
    );

    if (new_session == NULL)
    {
        if (session_error != NULL)
        {
            if (error != NULL)
            {
                g_propagate_prefixed_error(
                    error,
                    session_error,
                    "Impossible d'ouvrir la session : "
                );
            }
            else
            {
                g_clear_error(
                    &session_error
                );
            }
        }
        else
        {
            g_set_error_literal(
                error,
                APPLICATION_OPEN_ERROR,
                APPLICATION_OPEN_ERROR_INVALID_PROJECT,
                "Impossible d'ouvrir la session de l'enquête."
            );
        }

        return FALSE;
    }

    project = investigation_session_get_project(
        new_session
    );

    if (project == NULL)
    {
        g_set_error_literal(
            error,
            APPLICATION_OPEN_ERROR,
            APPLICATION_OPEN_ERROR_INVALID_PROJECT,
            "La session ne fournit aucun projet valide."
        );

        investigation_session_close(
            new_session
        );

        return FALSE;
    }

    canonical_root_path =
        investigation_project_get_root_path(
            project
        );

    if (canonical_root_path == NULL ||
        canonical_root_path[0] == '\0')
    {
        g_set_error_literal(
            error,
            APPLICATION_OPEN_ERROR,
            APPLICATION_OPEN_ERROR_INVALID_PROJECT,
            "Le projet ne fournit aucun chemin racine valide."
        );

        investigation_session_close(
            new_session
        );

        return FALSE;
    }

    new_tree_model = investigation_tree_builder_build(
        canonical_root_path
    );

    if (new_tree_model == NULL)
    {
        g_set_error(
            error,
            APPLICATION_OPEN_ERROR,
            APPLICATION_OPEN_ERROR_TREE_BUILD,
            "Impossible de construire l'arborescence de l'enquête "
            "située dans '%s'.",
            canonical_root_path
        );

        investigation_session_close(
            new_session
        );

        return FALSE;
    }

    if (!application_install_session(
            application,
            new_session,
            new_tree_model
        ))
    {
        g_set_error_literal(
            error,
            APPLICATION_OPEN_ERROR,
            APPLICATION_OPEN_ERROR_INSTALL,
            "Impossible d'installer la session dans l'application."
        );

        investigation_tree_model_free(
            new_tree_model
        );

        investigation_session_close(
            new_session
        );

        return FALSE;
    }

    /*
     * La propriété de new_session et new_tree_model a été
     * transférée à Application.
     */
    return TRUE;
}

/**
 * @brief Traite le dossier d'enquête sélectionné par l'utilisateur.
 *
 * @param folder_path Chemin sélectionné, ou NULL en cas d'annulation.
 * @param user_data Pointeur vers Application.
 */
static void application_on_folder_selected(
    const char *folder_path,
    gpointer user_data
)
{
    Application *application = user_data;
    GError *error = NULL;

    if (application == NULL)
    {
        return;
    }

    /*
     * L'annulation du sélecteur ne constitue pas une erreur.
     */
    if (folder_path == NULL)
    {
        return;
    }

    if (!application_open_and_install_investigation(
            application,
            folder_path,
            &error
        ))
    {
        g_warning(
            "Impossible d'ouvrir l'enquête '%s' : %s",
            folder_path,
            error != NULL
                ? error->message
                : "erreur inconnue"
        );

        application_present_error(
            application,
            "Ouverture impossible",
            error != NULL
                ? error->message
                : "L'enquête sélectionnée n'a pas pu être ouverte."
        );

        g_clear_error(
            &error
        );
    }
}

/**
 * @brief Traite la demande de création d'une nouvelle enquête.
 *
 * @param parent_directory Dossier dans lequel créer l'enquête.
 * @param investigation_name Nom nettoyé de l'enquête.
 * @param user_data Pointeur vers Application.
 */
static void application_on_create_investigation(
    const char *parent_directory,
    const char *investigation_name,
    gpointer user_data
)
{
    Application *application = user_data;

    char *created_root_path = NULL;
    char *user_message = NULL;

    GError *error = NULL;

    if (application == NULL)
    {
        return;
    }

    /*
     * Une annulation du dialogue transmet deux pointeurs NULL.
     */
    if (parent_directory == NULL ||
        investigation_name == NULL)
    {
        return;
    }

    created_root_path = investigation_project_create(
        parent_directory,
        investigation_name
    );

    if (created_root_path == NULL)
    {
        g_warning(
            "Impossible de créer l'enquête '%s' dans '%s'.",
            investigation_name,
            parent_directory
        );

        user_message = g_strdup_printf(
            "L'enquête « %s » n'a pas pu être créée dans :\n"
            "%s\n\n"
            "Vérifiez que le dossier existe et que vous disposez "
            "des droits d'écriture nécessaires.",
            investigation_name,
            parent_directory
        );

        application_present_error(
            application,
            "Création impossible",
            user_message
        );

        g_free(
            user_message
        );

        return;
    }

    if (!application_open_and_install_investigation(
            application,
            created_root_path,
            &error
        ))
    {
        g_warning(
            "L'enquête a été créée dans '%s', mais son "
            "ouverture a échoué : %s",
            created_root_path,
            error != NULL
                ? error->message
                : "erreur inconnue"
        );

        user_message = g_strdup_printf(
            "L'enquête a bien été créée sur le disque dans :\n"
            "%s\n\n"
            "Labfy Investigation n'a cependant pas pu l'ouvrir :\n"
            "%s",
            created_root_path,
            error != NULL
                ? error->message
                : "Aucun détail supplémentaire n'est disponible."
        );

        application_present_error(
            application,
            "Enquête créée mais non ouverte",
            user_message
        );

        g_free(
            user_message
        );

        g_clear_error(
            &error
        );
    }
    g_free(
        created_root_path
    );
}

/**
 * @brief Ouvre le dialogue de création d'une enquête.
 *
 * @param user_data Pointeur vers Application.
 */
static void application_on_new_investigation_requested(
    gpointer user_data
)
{
    Application *application = user_data;

    if (application == NULL ||
        application->main_window == NULL)
    {
        return;
    }

    create_investigation_dialog_present(
        main_window_get_window(
            application->main_window
        ),
        application_on_create_investigation,
        application
    );
}

/**
 * @brief Ouvre le sélecteur d'une enquête existante.
 *
 * @param user_data Pointeur vers Application.
 */
static void application_on_open_investigation_requested(
    gpointer user_data
)
{
    Application *application = user_data;

    if (application == NULL ||
        application->main_window == NULL)
    {
        return;
    }

    folder_dialog_select_folder(
        main_window_get_window(
            application->main_window
        ),
        application_on_folder_selected,
        application
    );
}

/**
 * @brief Reconstruit et remplace l’arborescence active.
 *
 * Le nouveau modèle est entièrement construit avant que l’ancien
 * soit détaché et libéré.
 *
 * @param application Application concernée.
 * @param investigation_root_path Racine à parcourir.
 *
 * @return TRUE si le remplacement a réussi.
 */
static gboolean application_refresh_investigation_tree(
    Application *application,
    const char *investigation_root_path
)
{
    InvestigationTreeModel *new_tree_model = NULL;
    InvestigationTreeModel *old_tree_model = NULL;

    if (application == NULL ||
        application->main_window == NULL ||
        investigation_root_path == NULL ||
        investigation_root_path[0] == '\0')
    {
        return FALSE;
    }

    new_tree_model =
        investigation_tree_builder_build(
            investigation_root_path
        );

    if (new_tree_model == NULL)
    {
        return FALSE;
    }

    old_tree_model =
        application->tree_model;

    /*
     * MainWindow transmet le nouveau modèle à la Sidebar.
     *
     * InvestigationTreeView détache d’abord son ancien modèle GTK,
     * puis construit le nouveau. L’ancien modèle métier reste vivant
     * pendant toute cette opération.
     */
    main_window_set_tree_model(
        application->main_window,
        new_tree_model
    );

    application->tree_model =
        new_tree_model;

    /*
     * La vue ne référence plus les anciens nœuds.
     */
    investigation_tree_model_free(
        old_tree_model
    );

    return TRUE;
}

/**
 * @brief Traite la fin d’une tâche d’import.
 *
 * @param task Tâche d’import terminée.
 * @param user_data Contexte ApplicationEvidenceImportContext.
 */
static void application_on_evidence_import_completed(
    BackgroundTask *task,
    gpointer user_data
)
{
    ApplicationEvidenceImportContext *context =
        user_data;

    Application *application = NULL;

    BackgroundTaskState state;

    EvidenceRecord *evidence_record = NULL;

    const char *original_name = NULL;

    char *status_message = NULL;

    GError *error = NULL;

    GError *evidence_refresh_error =
        NULL;

    gboolean tree_refreshed =
        FALSE;

    gboolean evidence_refreshed =
        FALSE;

    ApplicationEvidenceBatchContext *batch_context = NULL;

    if (task == NULL ||
        context == NULL)
    {
        return;
    }

    application =
        context->application;

    batch_context = context->batch_context;

    if (application == NULL ||
        application->main_window == NULL)
    {
        return;
    }

    if (batch_context == NULL)
        main_window_set_import_evidence_enabled(
            application->main_window, application->session != NULL);

    state =
        background_task_get_state(
            task
        );

    if (state ==
        BACKGROUND_TASK_STATE_COMPLETED)
    {
        evidence_record =
            background_task_get_result(
                task
            );

        if (evidence_record == NULL)
        {
            if (batch_context != NULL)
            {
                g_ptr_array_add(batch_context->failures, g_strdup(
                    "Tâche terminée sans preuve exploitable."));
                batch_context->current_index++;
                application_present_next_batch_metadata(batch_context);
                return;
            }
            application_present_error(
                application,
                "Import incomplet",
                "La tâche est terminée sans fournir de preuve."
            );

            return;
        }

        original_name =
            evidence_record_get_original_name(
                evidence_record
            );

        /*
         * L'utilisateur peut avoir changé d'enquête pendant
         * l'exécution asynchrone de l'import.
         *
         * Dans ce cas, la preuve reste correctement importée dans
         * l'ancienne enquête, mais l'interface actuelle ne doit pas
         * être rafraîchie avec ses données.
         */
        if (application_session_matches_root(
                application,
                context->investigation_root_path
            ))
        {
            tree_refreshed =
                application_refresh_investigation_tree(
                    application,
                    context->investigation_root_path
                );

            evidence_refreshed =
                application_refresh_evidence_models(
                    application,
                    &evidence_refresh_error
                );

            if (!tree_refreshed)
            {
                g_warning(
                    "La preuve a été importée, mais l'arborescence de '%s' "
                    "n'a pas pu être reconstruite.",
                    context->investigation_root_path
                );
            }

            if (!evidence_refreshed)
            {
                g_warning(
                    "La preuve a été importée, mais la liste des preuves "
                    "n'a pas pu être actualisée : %s",
                    evidence_refresh_error != NULL
                        ? evidence_refresh_error->message
                        : "erreur inconnue"
                );
            }

            if (tree_refreshed &&
                evidence_refreshed)
            {
                status_message =
                    g_strdup_printf(
                        "Preuve importée : %s",
                        original_name != NULL &&
                        original_name[0] != '\0'
                            ? original_name
                            : "(nom indisponible)"
                    );
            }
            else if (!tree_refreshed &&
                     evidence_refreshed)
            {
                status_message =
                    g_strdup_printf(
                        "Preuve importée : %s — "
                        "arborescence non actualisée",
                        original_name != NULL &&
                        original_name[0] != '\0'
                            ? original_name
                            : "(nom indisponible)"
                    );
            }
            else if (tree_refreshed &&
                     !evidence_refreshed)
            {
                status_message =
                    g_strdup_printf(
                        "Preuve importée : %s — "
                        "liste des preuves non actualisée",
                        original_name != NULL &&
                        original_name[0] != '\0'
                            ? original_name
                            : "(nom indisponible)"
                    );
            }
            else
            {
                status_message =
                    g_strdup_printf(
                        "Preuve importée : %s — "
                        "interface non actualisée",
                        original_name != NULL &&
                        original_name[0] != '\0'
                            ? original_name
                            : "(nom indisponible)"
                    );
            }

            main_window_set_status(
                application->main_window,
                status_message
            );

            g_clear_error(
                &evidence_refresh_error
            );
        }

        g_message(
            "Preuve importée dans '%s' : %s",
            context->investigation_root_path,
            original_name != NULL &&
            original_name[0] != '\0'
                ? original_name
                : "(nom indisponible)"
        );

        g_free(
            status_message
        );

        if (batch_context != NULL)
        {
            batch_context->success_count++;
            batch_context->current_index++;
            application_present_next_batch_metadata(batch_context);
        }

        return;
    }

    if (state ==
        BACKGROUND_TASK_STATE_CANCELLED)
    {
        if (batch_context != NULL)
        {
            batch_context->skipped_count++;
            batch_context->current_index++;
            application_present_next_batch_metadata(batch_context);
            return;
        }
        if (application_session_matches_root(
                application,
                context->investigation_root_path
            ))
        {
            main_window_set_status(
                application->main_window,
                "Import de preuve annulé."
            );
        }

        return;
    }

    error =
        background_task_dup_error(
            task
        );

    g_warning(
        "L’import de la preuve a échoué : %s",
        error != NULL
            ? error->message
            : "erreur inconnue"
    );

    if (batch_context != NULL)
    {
        const char *path = batch_context->current_index <
                batch_context->file_paths->len
            ? g_ptr_array_index(batch_context->file_paths,
                batch_context->current_index) : "fichier inconnu";
        char *failure = g_strdup_printf("%s : %s", path,
            error != NULL ? error->message : "échec de l'import");
        g_ptr_array_add(batch_context->failures, failure);
        batch_context->current_index++;
        application_present_next_batch_metadata(batch_context);
    }
    else
        application_present_error(
            application, "Import impossible",
            error != NULL ? error->message
                          : "La preuve n’a pas pu être importée.");

    g_clear_error(
        &error
    );
}

/**
 * @brief Retourne le dossier de stockage associé à un type de preuve.
 *
 * La chaîne retournée est statique et ne doit pas être libérée.
 */
static const char *application_get_evidence_subdirectory(
    const char *type_identifier
)
{
    if (g_strcmp0(
            type_identifier,
            "screenshot"
        ) == 0)
    {
        return "Captures_Ecran";
    }

    if (g_strcmp0(
            type_identifier,
            "photo"
        ) == 0)
    {
        return "Photos";
    }

    if (g_strcmp0(
            type_identifier,
            "video"
        ) == 0)
    {
        return "Videos";
    }

    if (g_strcmp0(
            type_identifier,
            "email"
        ) == 0)
    {
        return "Emails";
    }

    if (g_strcmp0(
            type_identifier,
            "audio"
        ) == 0)
    {
        return "Audios";
    }

    if (g_strcmp0(
            type_identifier,
            "archive"
        ) == 0)
    {
        return "Archives";
    }

    if (g_strcmp0(
            type_identifier,
            "conversation"
        ) == 0)
    {
        return "Conversations";
    }

    /*
     * Documents, textes, autres types et types inconnus.
     */
    return "Documents";
}

/** @brief Libère le contexte d'édition des métadonnées. */
static void application_evidence_metadata_context_free(
    ApplicationEvidenceMetadataContext *context
)
{
    if (context == NULL) return;
    g_free(context->evidence_identifier); g_free(context);
}

/** @brief Actualise les vues après la destruction du dialogue d'édition. */
static gboolean application_refresh_after_evidence_reclassification(
    gpointer user_data
)
{
    ApplicationEvidenceRefreshContext *context = user_data;
    GError *error = NULL;
    if (context != NULL && context->application != NULL &&
        context->application->main_window != NULL)
    {
        application_refresh_investigation_tree(
            context->application, context->root_path);
        application_refresh_evidence_models(context->application, &error);
        main_window_set_selected_evidence(
            context->application->main_window, NULL);
        application_message_dialog_present(
            main_window_get_window(context->application->main_window),
            APPLICATION_MESSAGE_DIALOG_INFORMATION, "Preuve reclassée",
            "Les métadonnées et le dossier ont été mis à jour. Le SHA-256 est inchangé.");
    }
    g_clear_error(&error);
    if (context != NULL) { g_free(context->root_path); g_free(context); }
    return G_SOURCE_REMOVE;
}

/** @brief Applique le reclassement confirmé puis actualise les vues. */
static void application_on_evidence_metadata_edited(
    EvidenceMetadataDialogResult *result, gpointer user_data
)
{
    ApplicationEvidenceMetadataContext *context = user_data;
    Application *application = context != NULL ? context->application : NULL;
    const InvestigationProject *project = NULL;
    const char *root_path = NULL; const char *subdirectory = NULL;
    char *relative_directory = NULL; GError *error = NULL;
    if (result == NULL)
    {
        application_evidence_metadata_context_free(context);
        return;
    }
    if (application == NULL || application->session == NULL) goto cleanup;
    project = investigation_session_get_project(application->session);
    root_path = project != NULL ? investigation_project_get_root_path(project) : NULL;
    subdirectory = application_get_evidence_subdirectory(
        evidence_metadata_dialog_result_get_type_identifier(result));
    relative_directory = g_build_filename(
        APPLICATION_EVIDENCE_ROOT_DIRECTORY, subdirectory, NULL);
    if (!evidence_reclassification_apply(
            investigation_session_get_database(application->session), root_path,
            context->evidence_identifier,
            evidence_metadata_dialog_result_get_type_identifier(result),
            relative_directory,
            evidence_metadata_dialog_result_get_source(result),
            evidence_metadata_dialog_result_get_description(result), &error))
    {
        application_present_error(application, "Modification impossible",
            error != NULL ? error->message : "Le reclassement a échoué.");
        g_clear_error(&error); goto cleanup;
    }
    {
        ApplicationEvidenceRefreshContext *refresh_context =
            g_new0(ApplicationEvidenceRefreshContext, 1);
        refresh_context->application = application;
        refresh_context->root_path = g_strdup(root_path);
        g_timeout_add(50U,
            application_refresh_after_evidence_reclassification,
            refresh_context);
    }
cleanup:
    g_free(relative_directory);
    evidence_metadata_dialog_result_free(result);
    application_evidence_metadata_context_free(context);
}

/** @brief Charge et présente les métadonnées éditables d'une preuve. */
static void application_on_edit_evidence_requested(
    const char *evidence_identifier, gpointer user_data
)
{
    Application *application = user_data; Database *database = NULL;
    EvidenceDao *evidence_dao = NULL; EvidenceTypeDao *type_dao = NULL;
    EvidenceRecord *record = NULL; GPtrArray *types = NULL;
    ApplicationEvidenceMetadataContext *context = NULL; GError *error = NULL;
    if (application == NULL || application->session == NULL ||
        evidence_identifier == NULL) return;
    database = investigation_session_get_database(application->session);
    evidence_dao = evidence_dao_new(database, &error);
    type_dao = evidence_type_dao_new(database, &error);
    if (evidence_dao != NULL)
        record = evidence_dao_find_by_identifier(
            evidence_dao, evidence_identifier, &error);
    if (type_dao != NULL) types = evidence_type_dao_list_all(type_dao, &error);
    if (record == NULL || types == NULL || types->len == 0U)
    {
        application_present_error(application, "Modification impossible",
            error != NULL ? error->message : "Les métadonnées sont indisponibles.");
        goto cleanup;
    }
    context = g_new0(ApplicationEvidenceMetadataContext, 1);
    context->application = application;
    context->evidence_identifier = g_strdup(evidence_identifier);
    if (!evidence_metadata_dialog_present(
            main_window_get_window(application->main_window), record, types,
            application_on_evidence_metadata_edited, context))
    {
        application_evidence_metadata_context_free(context);
        context = NULL;
        application_present_error(application, "Modification impossible",
            "Le dialogue de métadonnées n'a pas pu être créé.");
    }
cleanup:
    g_clear_error(&error); g_clear_pointer(&types, g_ptr_array_unref);
    evidence_record_free(record); evidence_type_dao_free(type_dao);
    evidence_dao_free(evidence_dao);
}

/** @brief Libère le contexte de révision EML. */
static void application_eml_review_context_free(ApplicationEmlReviewContext *context)
{
    if (context == NULL) return;
    g_free(context->evidence_identifier);
    g_free(context->evidence_name);
    g_free(context->relative_path);
    g_free(context->source_sha256);
    g_free(context->staging_directory);
    g_free(context);
}

/** @brief Supprime récursivement une zone de staging créée par l'application. */
static void application_remove_staging_directory(const char *path)
{
    if (path == NULL) return;
    GFile *directory = g_file_new_for_path(path);
    GError *error = NULL;
    GFileEnumerator *enumerator = g_file_enumerate_children(directory,
        G_FILE_ATTRIBUTE_STANDARD_NAME "," G_FILE_ATTRIBUTE_STANDARD_TYPE,
        G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, &error);
    if (enumerator != NULL)
    {
        GFileInfo *info = NULL;
        while ((info = g_file_enumerator_next_file(
                    enumerator, NULL, &error)) != NULL)
        {
            GFile *child = g_file_get_child(directory,
                g_file_info_get_name(info));
            char *child_path = g_file_get_path(child);
            if (g_file_info_get_file_type(info) == G_FILE_TYPE_DIRECTORY)
                application_remove_staging_directory(child_path);
            else
                (void) g_file_delete(child, NULL, NULL);
            g_free(child_path);
            g_object_unref(child);
            g_object_unref(info);
        }
        g_object_unref(enumerator);
    }
    g_clear_error(&error);
    (void) g_file_delete(directory, NULL, NULL);
    g_object_unref(directory);
}

/** @brief Intègre la sélection EML puis actualise le graphe. */
static void application_on_eml_selection_completed(
    GPtrArray *proposals, gpointer user_data)
{
    ApplicationEmlReviewContext *context = user_data;
    Application *application = context != NULL ? context->application : NULL;
    const InvestigationProject *project = NULL;
    GError *error = NULL; guint observations = 0, created = 0, reused = 0;
    char *message = NULL;
    if (proposals == NULL)
    {
        application_remove_staging_directory(context != NULL
            ? context->staging_directory : NULL);
        application_eml_review_context_free(context);
        return;
    }
    if (application == NULL || application->session == NULL ||
        !eml_integration_apply(investigation_session_get_database(application->session),
            context->evidence_identifier, proposals, &observations,
            &created, &reused, &error))
        application_present_error(application, "Intégration EML impossible",
            error != NULL ? error->message : "La transaction a échoué.");
    else
    {
        message = g_strdup_printf(
            "%u observation(s) conservée(s), %u entité(s) créée(s), "
            "%u réutilisée(s).", observations, created, reused);
        application_message_dialog_present(main_window_get_window(application->main_window),
            APPLICATION_MESSAGE_DIALOG_INFORMATION, "Analyse EML intégrée", message);
        if (created + reused > 0)
        {
            project = investigation_session_get_project(application->session);
            application_start_graph_loading(application,
                investigation_project_get_database_path(project));
        }
        (void) application_refresh_evidence_models(application, NULL);
        application_on_evidence_selected(context->evidence_identifier,
            application);
    }
    g_free(message); g_clear_error(&error); g_ptr_array_unref(proposals);
    application_remove_staging_directory(context != NULL
        ? context->staging_directory : NULL);
    application_eml_review_context_free(context);
}

/** @brief Termine le pipeline EML sur le contexte GTK principal. */
static void application_on_eml_pipeline_completed(
    BackgroundTask *task,
    gpointer user_data)
{
    ApplicationEmlReviewContext *context = user_data;
    Application *application = context != NULL ? context->application : NULL;
    BackgroundTaskState state = background_task_get_state(task);
    if (application == NULL || application->main_window == NULL ||
        application->session == NULL ||
        application->session != context->expected_session)
    {
        application_remove_staging_directory(context != NULL
            ? context->staging_directory : NULL);
        application_eml_review_context_free(context);
        return;
    }
    if (state == BACKGROUND_TASK_STATE_CANCELLED)
    {
        main_window_set_status(application->main_window,
            "Analyse de l’e-mail annulée.");
        application_remove_staging_directory(context->staging_directory);
        application_eml_review_context_free(context);
        return;
    }
    if (state != BACKGROUND_TASK_STATE_COMPLETED)
    {
        GError *error = background_task_dup_error(task);
        application_present_error(application, "Analyse EML impossible",
            error != NULL ? error->message : "Le pipeline EML a échoué.");
        g_clear_error(&error);
        application_remove_staging_directory(context->staging_directory);
        application_eml_review_context_free(context);
        return;
    }
    EmlPipelineResult *result = background_task_get_result(task);
    if (result == NULL)
    {
        application_present_error(application, "Analyse EML impossible",
            "Le pipeline n’a produit aucun résultat.");
        application_remove_staging_directory(context->staging_directory);
        application_eml_review_context_free(context);
        return;
    }
    eml_analysis_dialog_present_pipeline(
        main_window_get_window(application->main_window),
        result, context->evidence_name, context->relative_path,
        context->source_sha256, application_on_eml_selection_completed,
        context);
}

/** @brief Vérifie la preuve puis lance le pipeline EML en arrière-plan. */
static void application_on_analyze_eml_requested(
    const char *evidence_identifier, gpointer user_data)
{
    Application *application = user_data;
    const InvestigationProject *project = NULL;
    EvidenceDao *dao = NULL;
    EvidenceRecord *record = NULL;
    ApplicationEmlReviewContext *context = NULL;
    BackgroundTask *task = NULL;
    char *root = NULL;
    char *candidate = NULL;
    char *source_path = NULL;
    char *current_sha256 = NULL;
    guint64 current_size = 0;
    char *staging = NULL;
    GError *error = NULL;
    if (application == NULL || application->session == NULL ||
        evidence_identifier == NULL) return;
    dao = evidence_dao_new(
        investigation_session_get_database(application->session), &error);
    if (dao != NULL) record = evidence_dao_find_by_identifier(
        dao, evidence_identifier, &error);
    project = investigation_session_get_project(application->session);
    if (record == NULL || project == NULL) goto failure;
    root = g_canonicalize_filename(
        investigation_project_get_root_path(project), NULL);
    candidate = g_build_filename(root,
        evidence_record_get_relative_path(record), NULL);
    source_path = g_canonicalize_filename(candidate, NULL);
    const char *name = evidence_record_get_original_name(record);
    char *lower = name != NULL ? g_ascii_strdown(name, -1) : NULL;
    gboolean is_eml = lower != NULL && g_str_has_suffix(lower, ".eml");
    g_free(lower);
    if (!is_eml || source_path == NULL ||
        !g_str_has_prefix(source_path, root) ||
        (source_path[strlen(root)] != G_DIR_SEPARATOR &&
         source_path[strlen(root)] != '\0') ||
        !g_file_test(source_path, G_FILE_TEST_IS_REGULAR))
    {
        g_set_error_literal(&error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
            "La preuve sélectionnée n’est pas un fichier EML exploitable.");
        goto failure;
    }
    if (!file_hash_compute_sha256(source_path, NULL, &current_sha256,
            &current_size, &error) ||
        g_strcmp0(current_sha256, evidence_record_get_sha256(record)) != 0)
    {
        if (error == NULL)
            g_set_error_literal(&error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
                "L’empreinte SHA-256 de la preuve diverge de "
                "l’empreinte enregistrée. L’analyse est bloquée.");
        goto failure;
    }
    staging = g_dir_make_tmp("labfy-eml-staging-XXXXXX", &error);
    if (staging == NULL) goto failure;
    context = g_new0(ApplicationEmlReviewContext, 1);
    context->application = application;
    context->expected_session = application->session;
    context->evidence_identifier = g_strdup(evidence_identifier);
    context->evidence_name = g_strdup(name);
    context->relative_path = g_strdup(
        evidence_record_get_relative_path(record));
    context->source_sha256 = g_strdup(current_sha256);
    context->staging_directory = staging;
    staging = NULL;
    DocumentAnalysisTools tools = {
        .exiftool = "exiftool", .tesseract = "tesseract",
        .pdfinfo = "pdfinfo", .pdftotext = "pdftotext",
        .pdftoppm = "pdftoppm"
    };
    task = eml_pipeline_task_start(source_path, context->staging_directory,
        evidence_identifier, &tools, application_on_eml_pipeline_completed,
        context, NULL);
    if (task == NULL)
        goto failure;
    context = NULL;
    if (!task_manager_add(application->task_manager, task, &error))
    {
        background_task_cancel(task);
        goto cleanup;
    }
    main_window_set_status(application->main_window,
        "Analyse de l’e-mail lancée en arrière-plan.");
    background_task_unref(task);
    task = NULL;
    goto cleanup;

failure:
    if (task != NULL)
        background_task_cancel(task);
    if (context != NULL)
        application_remove_staging_directory(context->staging_directory);
    else
        application_remove_staging_directory(staging);
    if (context != NULL)
        application_eml_review_context_free(context);
    if (application != NULL)
        application_present_error(application, "Analyse EML impossible",
            error != NULL ? error->message :
            "La preuve n’a pas pu être analysée.");
cleanup:
    background_task_unref(task);
    g_free(staging);
    g_free(current_sha256);
    g_free(source_path);
    g_free(candidate);
    g_free(root);
    evidence_record_free(record);
    evidence_dao_free(dao);
    g_clear_error(&error);
}

/** @brief Contexte possédé pendant la révision OCR d'un RIB. */
typedef struct { Application *application; char *evidence_identifier;
    char *ocr_text; char *tool_version; } ApplicationRibOcrContext;
/** @brief Libère le contexte OCR d'un RIB. */
static void application_rib_ocr_context_free(ApplicationRibOcrContext *context)
{
    if (context == NULL) return;
    g_free(context->evidence_identifier); g_free(context->ocr_text);
    g_free(context->tool_version); g_free(context);
}
/** @brief Crée ou réutilise l'entité IBAN confirmée et la lie à la preuve. */
static void application_on_rib_ocr_confirmed(const char *iban,
    gpointer user_data)
{
    ApplicationRibOcrContext *context = user_data;
    Application *application = context != NULL ? context->application : NULL;
    Database *database = NULL; EntityDao *entity_dao = NULL;
    EvidenceEntityDao *link_dao = NULL; GPtrArray *entities = NULL;
    EntityRecord *record = NULL; const char *entity_identifier = NULL;
    char *new_identifier = NULL; char *timestamp = NULL; char *description = NULL;
    GDateTime *now = NULL; GError *error = NULL; gboolean active = FALSE;
    const InvestigationProject *project = NULL;
    if (iban == NULL || application == NULL || application->session == NULL)
        goto cleanup;
    database = investigation_session_get_database(application->session);
    entity_dao = entity_dao_new(database, &error);
    if (entity_dao == NULL) goto failure;
    entities = entity_dao_list_all(entity_dao, &error);
    if (entities == NULL) goto failure;
    for (guint index = 0; index < entities->len; index++)
    {
        EntityRecord *candidate = g_ptr_array_index(entities, index);
        if (g_strcmp0(entity_record_get_type_identifier(candidate), "iban") == 0 &&
            g_strcmp0(entity_record_get_value(candidate), iban) == 0)
            entity_identifier = entity_record_get_identifier(candidate);
    }
    if (!database_transaction_begin(database)) goto failure;
    active = TRUE;
    if (entity_identifier == NULL)
    {
        new_identifier = g_uuid_string_random(); now = g_date_time_new_now_utc();
        timestamp = now != NULL ? g_date_time_format(now,
            "%Y-%m-%dT%H:%M:%SZ") : NULL;
        description = g_strdup_printf("IBAN extrait localement par OCR (%s).",
            context->tool_version != NULL ? context->tool_version : "Tesseract");
        record = entity_record_new(new_identifier, "iban", iban, "IBAN extrait du RIB",
            description, 70, timestamp, timestamp, ENTITY_STATUS_ACTIVE, &error);
        if (record == NULL || !entity_dao_insert(entity_dao, record, &error))
            goto failure;
        entity_identifier = new_identifier;
    }
    link_dao = evidence_entity_dao_new(database, &error);
    if (link_dao == NULL) goto failure;
    if (!evidence_entity_dao_link(link_dao, context->evidence_identifier,
            entity_identifier, &error)) goto failure;
    if (!database_transaction_commit(database)) goto failure;
    active = FALSE; project = investigation_session_get_project(application->session);
    g_free(application->pending_entity_selection_identifier);
    application->pending_entity_selection_identifier =
        g_strdup(entity_identifier);
    main_window_set_status(application->main_window,
        "Entité IBAN créée et reliée à la preuve.");
    application_start_graph_loading(application,
        investigation_project_get_database_path(project)); goto cleanup;
failure:
    if (active) database_transaction_rollback(database);
    application_present_error(application, "Intégration du RIB impossible",
        error != NULL ? error->message : "La transaction a échoué.");
cleanup:
    g_clear_error(&error); entity_record_free(record);
    g_clear_pointer(&entities, g_ptr_array_unref); entity_dao_free(entity_dao);
    evidence_entity_dao_free(link_dao); g_free(new_identifier);
    g_free(timestamp); g_free(description); g_clear_pointer(&now, g_date_time_unref);
    application_rib_ocr_context_free(context);
}
/** @brief Exécute localement Tesseract sur la preuve image sélectionnée. */
static void application_on_analyze_rib_requested(
    const char *evidence_identifier, gpointer user_data)
{
    Application *application = user_data; const InvestigationProject *project = NULL;
    EvidenceDao *dao = NULL; EvidenceRecord *record = NULL;
    ApplicationRibOcrContext *context = NULL; GPtrArray *ibans = NULL;
    char *candidate_path = NULL; char *canonical_root = NULL; char *path = NULL;
    char *output_path = NULL; GError *error = NULL;
    char *work_copy_path = NULL; GFile *source_file = NULL; GFile *copy_file = NULL;
    if (application == NULL || application->session == NULL) return;
    dao = evidence_dao_new(investigation_session_get_database(application->session), &error);
    if (dao != NULL) record = evidence_dao_find_by_identifier(dao,
        evidence_identifier, &error);
    project = investigation_session_get_project(application->session);
    if (record == NULL || project == NULL) goto failure;
    canonical_root = g_canonicalize_filename(
        investigation_project_get_root_path(project), NULL);
    candidate_path = g_build_filename(canonical_root,
        evidence_record_get_relative_path(record), NULL);
    path = g_canonicalize_filename(candidate_path, NULL);
    if (path == NULL || !g_str_has_prefix(path, canonical_root) ||
        (path[strlen(canonical_root)] != G_DIR_SEPARATOR &&
         path[strlen(canonical_root)] != '\0')) goto failure;
    work_copy_path = g_strdup_printf("%s/02_Preuves_Traitees/OCR/%s-%s",
        canonical_root, evidence_identifier,
        evidence_record_get_original_name(record));
    source_file = g_file_new_for_path(path);
    copy_file = g_file_new_for_path(work_copy_path);
    if (!g_file_copy(source_file, copy_file, G_FILE_COPY_OVERWRITE,
            NULL, NULL, NULL, &error)) goto failure;
    context = g_new0(ApplicationRibOcrContext, 1);
    context->application = application;
    context->evidence_identifier = g_strdup(evidence_identifier);
    if (!rib_ocr_extract_text(work_copy_path, &context->ocr_text,
            &context->tool_version, &error)) goto failure;
    output_path = g_strdup_printf("%s/02_Preuves_Traitees/OCR/%s-ocr.txt",
        canonical_root, evidence_identifier);
    if (!g_file_set_contents(output_path, context->ocr_text, -1, &error))
        goto failure;
    ibans = iban_analyzer_extract(context->ocr_text);
    rib_ocr_review_dialog_present(main_window_get_window(application->main_window),
        context->ocr_text, ibans->len > 0 ? g_ptr_array_index(ibans, 0) : NULL,
        application_on_rib_ocr_confirmed, context);
    context = NULL; goto cleanup;
failure:
    application_rib_ocr_context_free(context); context = NULL;
    application_present_error(application, "Analyse OCR impossible",
        error != NULL ? error->message :
        "La preuve n'a pas pu être analysée par Tesseract.");
cleanup:
    g_clear_error(&error); g_clear_pointer(&ibans, g_ptr_array_unref);
    g_free(output_path); g_free(path); g_free(candidate_path); g_free(canonical_root);
    g_free(work_copy_path); g_clear_object(&source_file); g_clear_object(&copy_file);
    evidence_record_free(record); evidence_dao_free(dao);
}

/** @brief Analyse avec ExifTool une copie de travail de la preuve. */
static void application_on_extract_metadata_requested(
    const char *evidence_identifier, gpointer user_data)
{
    Application *application = user_data;
    const InvestigationProject *project = NULL;
    EvidenceDao *dao = NULL;
    EvidenceRecord *record = NULL;
    char *canonical_root = NULL;
    char *candidate_path = NULL;
    char *source_path = NULL;
    char *output_directory = NULL;
    char *copy_name = NULL;
    char *copy_path = NULL;
    char *json_name = NULL;
    char *json_path = NULL;
    char *summary = NULL;
    char *json = NULL;
    char *version = NULL;
    GFile *source_file = NULL;
    GFile *copy_file = NULL;
    GError *error = NULL;

    if (application == NULL || application->session == NULL ||
        evidence_identifier == NULL) return;
    dao = evidence_dao_new(
        investigation_session_get_database(application->session), &error);
    if (dao != NULL)
        record = evidence_dao_find_by_identifier(dao, evidence_identifier,
            &error);
    project = investigation_session_get_project(application->session);
    if (record == NULL || project == NULL) goto failure;
    canonical_root = g_canonicalize_filename(
        investigation_project_get_root_path(project), NULL);
    candidate_path = g_build_filename(canonical_root,
        evidence_record_get_relative_path(record), NULL);
    source_path = g_canonicalize_filename(candidate_path, NULL);
    if (source_path == NULL || !g_str_has_prefix(source_path, canonical_root) ||
        (source_path[strlen(canonical_root)] != G_DIR_SEPARATOR &&
         source_path[strlen(canonical_root)] != '\0'))
    {
        g_set_error_literal(&error, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,
            "Le chemin de la preuve sort du dossier de l'enquête.");
        goto failure;
    }
    output_directory = g_build_filename(canonical_root,
        "02_Preuves_Traitees", "Extractions", "Metadata", NULL);
    if (g_mkdir_with_parents(output_directory, 0750) != 0)
    {
        g_set_error(&error, G_IO_ERROR, g_io_error_from_errno(errno),
            "Impossible de créer le dossier des métadonnées : %s",
            g_strerror(errno));
        goto failure;
    }
    copy_name = g_strdup_printf("%s-%s", evidence_identifier,
        evidence_record_get_original_name(record));
    copy_path = g_build_filename(output_directory, copy_name, NULL);
    source_file = g_file_new_for_path(source_path);
    copy_file = g_file_new_for_path(copy_path);
    if (!g_file_copy(source_file, copy_file, G_FILE_COPY_OVERWRITE,
            NULL, NULL, NULL, &error)) goto failure;
    if (!exiftool_metadata_extract(copy_path, &summary, &json, &version,
            &error)) goto failure;
    json_name = g_strdup_printf("%s-exiftool.json", evidence_identifier);
    json_path = g_build_filename(output_directory, json_name, NULL);
    if (!g_file_set_contents(json_path, json, -1, &error)) goto failure;
    metadata_analysis_dialog_present(
        main_window_get_window(application->main_window), summary, json_path,
        version);
    main_window_set_status(application->main_window,
        "Métadonnées extraites localement et sortie JSON conservée.");
    goto cleanup;
failure:
    application_present_error(application, "Extraction impossible",
        error != NULL ? error->message :
        "La preuve n'a pas pu être analysée avec ExifTool.");
cleanup:
    g_clear_error(&error);
    g_clear_object(&source_file);
    g_clear_object(&copy_file);
    g_free(canonical_root);
    g_free(candidate_path);
    g_free(source_path);
    g_free(output_directory);
    g_free(copy_name);
    g_free(copy_path);
    g_free(json_name);
    g_free(json_path);
    g_free(summary);
    g_free(json);
    g_free(version);
    evidence_record_free(record);
    evidence_dao_free(dao);
}

/** @brief Contexte conservé pendant la tâche de récupération PDF. */
typedef struct
{
    Application *application;
    char *copy_path;
    char *output_directory;
    char *evidence_identifier;
} ApplicationPdfRecoveryContext;

/** @brief Libère le contexte d'une récupération PDF. */
static void application_pdf_recovery_context_free(gpointer data)
{
    ApplicationPdfRecoveryContext *context = data;
    if (context == NULL) return;
    g_free(context->copy_path);
    g_free(context->output_directory);
    g_free(context->evidence_identifier);
    g_free(context);
}

/** @brief Contexte secret utilisé pour créer la copie PDF déverrouillée. */
typedef struct
{
    Application *application;
    char *password;
    char *copy_path;
    char *unlocked_path;
} ApplicationPdfDecryptContext;

/** @brief Efface le mot de passe puis libère le contexte de déchiffrement. */
static void application_pdf_decrypt_context_free(gpointer data)
{
    ApplicationPdfDecryptContext *context = data;
    if (context == NULL) return;
    if (context->password != NULL)
        memset(context->password, 0, strlen(context->password));
    g_free(context->password);
    g_free(context->copy_path);
    g_free(context->unlocked_path);
    g_free(context);
}

/** @brief Crée avec qpdf la copie déverrouillée demandée explicitement. */
static void application_on_pdf_decrypt_requested(gpointer user_data)
{
    ApplicationPdfDecryptContext *context = user_data;
    GSubprocess *process = NULL;
    char *password_path = NULL;
    char *password_argument = NULL;
    char *stderr_text = NULL;
    int descriptor = -1;
    GError *error = NULL;
    const char *arguments[6] = { "qpdf", NULL, "--decrypt", NULL, NULL, NULL };
    gssize password_length = 0;

    if (context == NULL || context->application == NULL) return;
    descriptor = g_file_open_tmp("labfy-qpdf-password-XXXXXX",
        &password_path, &error);
    password_length = context->password != NULL ?
        (gssize) strlen(context->password) : 0;
    if (descriptor < 0 || password_length == 0 ||
        write(descriptor, context->password, (size_t) password_length) !=
            password_length)
        goto failure;
    close(descriptor);
    descriptor = -1;
    password_argument = g_strdup_printf("--password-file=%s", password_path);
    arguments[1] = password_argument;
    arguments[3] = context->copy_path;
    arguments[4] = context->unlocked_path;
    process = g_subprocess_newv(arguments,
        G_SUBPROCESS_FLAGS_STDOUT_SILENCE | G_SUBPROCESS_FLAGS_STDERR_PIPE,
        &error);
    if (process == NULL || !g_subprocess_communicate_utf8(process, NULL, NULL,
            NULL, &stderr_text, &error) || !g_subprocess_get_successful(process))
    {
        if (error == NULL)
            g_set_error(&error, G_IO_ERROR, G_IO_ERROR_FAILED,
                "qpdf a échoué : %s", stderr_text != NULL ? stderr_text :
                "aucun détail disponible");
        goto failure;
    }
    application_message_dialog_present(
        main_window_get_window(context->application->main_window),
        APPLICATION_MESSAGE_DIALOG_INFORMATION, "PDF déverrouillé",
        "La copie déverrouillée a été créée dans les preuves traitées.");
    main_window_set_status(context->application->main_window,
        "Copie PDF déverrouillée créée.");
    goto cleanup;
failure:
    application_present_error(context->application,
        "Déverrouillage impossible", error != NULL ? error->message :
        "qpdf n'a pas pu créer la copie déverrouillée.");
cleanup:
    if (descriptor >= 0) close(descriptor);
    if (password_path != NULL) g_unlink(password_path);
    g_clear_error(&error);
    g_clear_object(&process);
    g_free(password_path);
    g_free(password_argument);
    g_free(stderr_text);
}

/** @brief Présente le résultat final d'une récupération PDF. */
static void application_on_pdf_recovery_completed(BackgroundTask *task,
    gpointer user_data)
{
    ApplicationPdfRecoveryContext *context = user_data;
    const PdfPasswordRecoveryResult *result = NULL;
    const char *password = NULL;
    ApplicationPdfDecryptContext *decrypt_context = NULL;
    char *details = NULL;
    char *unlocked_name = NULL;
    GError *error = NULL;

    if (context == NULL || context->application == NULL) return;
    if (background_task_get_state(task) == BACKGROUND_TASK_STATE_CANCELLED)
    {
        main_window_set_status(context->application->main_window,
            "Récupération du mot de passe PDF annulée.");
        return;
    }
    if (background_task_get_state(task) != BACKGROUND_TASK_STATE_COMPLETED)
    {
        error = background_task_dup_error(task);
        application_present_error(context->application,
            "Récupération PDF impossible", error != NULL ? error->message :
            "John the Ripper a échoué.");
        g_clear_error(&error);
        return;
    }
    result = pdf_password_recovery_get_result(task);
    if (!pdf_password_recovery_result_is_recovered(result))
    {
        application_message_dialog_present(
            main_window_get_window(context->application->main_window),
            APPLICATION_MESSAGE_DIALOG_WARNING, "Mot de passe non trouvé",
            "Aucun candidat n'a correspondu. Essayez un dictionnaire enrichi "
            "ou un masque plus précis.");
        return;
    }
    password = pdf_password_recovery_result_get_password(result);
    decrypt_context = g_new0(ApplicationPdfDecryptContext, 1);
    decrypt_context->application = context->application;
    decrypt_context->password = g_strdup(password);
    decrypt_context->copy_path = g_strdup(context->copy_path);
    unlocked_name = g_strdup_printf("%s-unlocked.pdf",
        context->evidence_identifier);
    decrypt_context->unlocked_path = g_build_filename(
        context->output_directory, unlocked_name, NULL);
    details = g_strdup_printf("Mot de passe retrouvé : %s\n\n"
        "Il est uniquement conservé en mémoire. Utilisez l'action ci-dessous "
        "pour créer une copie déverrouillée.", password);
    application_message_dialog_present_details_action(
        main_window_get_window(context->application->main_window),
        APPLICATION_MESSAGE_DIALOG_INFORMATION, "Mot de passe PDF retrouvé",
        "La recherche locale a réussi.", details,
        "Créer la copie déverrouillée", application_on_pdf_decrypt_requested,
        decrypt_context, application_pdf_decrypt_context_free);
    g_free(details);
    g_free(unlocked_name);
}

/** @brief Prépare la copie PDF puis démarre la tâche choisie. */
static void application_on_pdf_recovery_configured(
    PdfPasswordRecoveryMethod method, const char *parameter,
    gpointer user_data)
{
    Application *application = user_data;
    const InvestigationProject *project = NULL;
    EvidenceDao *dao = NULL;
    EvidenceRecord *record = NULL;
    ApplicationPdfRecoveryContext *context = NULL;
    char *root = NULL;
    char *candidate = NULL;
    char *source_path = NULL;
    char *copy_name = NULL;
    GFile *source_file = NULL;
    GFile *copy_file = NULL;
    GError *error = NULL;

    if (application == NULL || application->session == NULL ||
        application->selected_evidence_identifier == NULL) return;
    dao = evidence_dao_new(
        investigation_session_get_database(application->session), &error);
    if (dao != NULL)
        record = evidence_dao_find_by_identifier(dao,
            application->selected_evidence_identifier, &error);
    project = investigation_session_get_project(application->session);
    if (record == NULL || project == NULL) goto failure;
    root = g_canonicalize_filename(investigation_project_get_root_path(project),
        NULL);
    candidate = g_build_filename(root,
        evidence_record_get_relative_path(record), NULL);
    source_path = g_canonicalize_filename(candidate, NULL);
    if (source_path == NULL || !g_str_has_prefix(source_path, root) ||
        (source_path[strlen(root)] != G_DIR_SEPARATOR &&
         source_path[strlen(root)] != '\0')) goto failure;
    context = g_new0(ApplicationPdfRecoveryContext, 1);
    context->application = application;
    context->evidence_identifier = g_strdup(
        application->selected_evidence_identifier);
    context->output_directory = g_build_filename(root,
        "02_Preuves_Traitees", "Extractions", "PDF", NULL);
    if (g_mkdir_with_parents(context->output_directory, 0750) != 0) goto failure;
    copy_name = g_strdup_printf("%s-locked.pdf", context->evidence_identifier);
    context->copy_path = g_build_filename(context->output_directory,
        copy_name, NULL);
    source_file = g_file_new_for_path(source_path);
    copy_file = g_file_new_for_path(context->copy_path);
    if (!g_file_copy(source_file, copy_file, G_FILE_COPY_OVERWRITE,
            NULL, NULL, NULL, &error)) goto failure;
    if (pdf_password_recovery_start(application->task_manager,
            context->copy_path, context->output_directory,
            context->evidence_identifier, method, parameter,
            application_on_pdf_recovery_completed, context,
            application_pdf_recovery_context_free, &error) == NULL)
        goto failure;
    context = NULL;
    main_window_set_status(application->main_window,
        "Récupération PDF lancée ; progression disponible dans les tâches.");
    goto cleanup;
failure:
    application_pdf_recovery_context_free(context);
    application_present_error(application, "Récupération PDF impossible",
        error != NULL ? error->message :
        "La copie de travail n'a pas pu être préparée.");
cleanup:
    g_clear_error(&error); g_clear_object(&source_file);
    g_clear_object(&copy_file); g_free(root); g_free(candidate);
    g_free(source_path); g_free(copy_name); evidence_record_free(record);
    evidence_dao_free(dao);
}

/** @brief Ouvre la configuration de récupération pour le PDF sélectionné. */
static void application_on_recover_pdf_password_requested(
    const char *evidence_identifier, gpointer user_data)
{
    Application *application = user_data;
    if (application == NULL || evidence_identifier == NULL) return;
    g_free(application->selected_evidence_identifier);
    application->selected_evidence_identifier = g_strdup(evidence_identifier);
    pdf_password_dialog_present(
        main_window_get_window(application->main_window),
        application_on_pdf_recovery_configured, application);
}

/**
 * @brief Prépare et démarre l’import asynchrone d’un fichier.
 */
static void application_start_evidence_import(
    Application *application,
    const char *file_path,
    const char *type_identifier,
    const char *collected_at,
    const char *source,
    const char *description,
    ApplicationEvidenceBatchContext *batch_context
)
{
    const InvestigationProject *project = NULL;

    const char *root_path = NULL;
    const char *database_path = NULL;

    const char *evidence_subdirectory = NULL;

    char *relative_directory = NULL;

    EvidenceImportTaskRequest request =
        {0};

    ApplicationEvidenceImportContext *context =
        NULL;

    BackgroundTask *task = NULL;

    char *destination_directory = NULL;
    char *source_name = NULL;
    char *status_message = NULL;

    GError *error = NULL;

    if (application == NULL ||
        application->main_window == NULL ||
        application->session == NULL ||
        application->task_manager == NULL ||
        file_path == NULL ||
        file_path[0] == '\0' ||
        type_identifier == NULL ||
        type_identifier[0] == '\0' ||
        collected_at == NULL ||
        collected_at[0] == '\0')
    {
        return;
    }

    project =
        investigation_session_get_project(
            application->session
        );

    if (project == NULL)
    {
        application_present_error(
            application,
            "Import impossible",
            "La session ne fournit aucun projet d’enquête."
        );

        return;
    }

    root_path =
        investigation_project_get_root_path(
            project
        );

    database_path =
        investigation_project_get_database_path(
            project
        );

    if (root_path == NULL ||
        root_path[0] == '\0' ||
        database_path == NULL ||
        database_path[0] == '\0')
    {
        application_present_error(
            application,
            "Import impossible",
            "Les chemins de l’enquête sont invalides."
        );

        return;
    }

    evidence_subdirectory =
        application_get_evidence_subdirectory(
            type_identifier
        );

    relative_directory =
        g_build_filename(
            APPLICATION_EVIDENCE_ROOT_DIRECTORY,
            evidence_subdirectory,
            NULL
        );

    if (relative_directory == NULL)
    {
        application_present_error(
            application,
            "Import impossible",
            "Impossible de construire le chemin relatif de la preuve."
        );

        return;
    }

    destination_directory =
        g_build_filename(
            root_path,
            relative_directory,
            NULL
        );

    if (destination_directory == NULL)
    {
        application_present_error(
            application,
            "Import impossible",
            "Impossible de construire le dossier de destination."
        );

        g_free(
            relative_directory
        );

        return;
    }

    /*
     * Le dossier devrait exister dans une enquête normale.
     * Cette création rend néanmoins l’import robuste face à un dossier
     * supprimé accidentellement.
     */
    if (g_mkdir_with_parents(
            destination_directory,
            0700
        ) != 0)
    {
        status_message =
            g_strdup_printf(
                "Impossible de préparer le dossier '%s' : %s",
                destination_directory,
                g_strerror(errno)
            );

        application_present_error(
            application,
            "Import impossible",
            status_message
        );

        g_free(
            status_message
        );

        g_free(
            destination_directory
        );

        return;
    }

    context =
        g_try_new0(
            ApplicationEvidenceImportContext,
            1
        );

    if (context == NULL)
    {
        application_present_error(
            application,
            "Import impossible",
            "Impossible d’allouer le contexte de la tâche."
        );

        g_free(
            destination_directory
        );

        return;
    }

    context->application =
        application;

    context->batch_context = batch_context;

    context->investigation_root_path =
        g_strdup(
            root_path
        );

    if (context->investigation_root_path == NULL)
    {
        application_evidence_import_context_free(
            context
        );

        g_free(
            destination_directory
        );

        application_present_error(
            application,
            "Import impossible",
            "Impossible de conserver le chemin de l’enquête."
        );

        return;
    }

    request.database_path =
        database_path;

    request.source_path =
        file_path;

    request.destination_directory =
        destination_directory;

    request.relative_directory =
        relative_directory;

    request.type_identifier =
        type_identifier;

    request.collected_at =
        collected_at;

    request.source =
        source;

    request.description =
        description;

    task =
        evidence_import_task_start(
            application->task_manager,
            &request,
            application_on_evidence_import_completed,
            context,
            application_evidence_import_context_free,
            &error
        );

    if (task == NULL)
    {
        /*
         * La tâche n’a pas pris possession du contexte.
         */
        application_evidence_import_context_free(
            context
        );

        application_present_error(
            application,
            "Import impossible",
            error != NULL
                ? error->message
                : "La tâche d’import n’a pas pu être démarrée."
        );

        g_clear_error(
            &error
        );

        g_free(
            destination_directory
        );

        g_free(
            relative_directory
        );

        return;
    }

    /*
     * Le TaskManager et le worker conservent désormais leurs références.
     */
    background_task_unref(
        task
    );

    main_window_set_import_evidence_enabled(
        application->main_window,
        FALSE
    );

    source_name =
        g_path_get_basename(
            file_path
        );

    status_message =
        g_strdup_printf(
            "Import en cours : %s",
            source_name != NULL
                ? source_name
                : file_path
        );

    main_window_set_status(
        application->main_window,
        status_message
    );

    g_free(
        status_message
    );

    g_free(
        source_name
    );

    g_free(
        destination_directory
    );

    g_free(
        relative_directory
    );
}

/**
 * @brief Traite la validation ou l'annulation des métadonnées.
 *
 * @param result Résultat possédé par ce callback, ou NULL.
 * @param user_data Contexte ApplicationEvidenceDialogContext.
 */
static void application_on_evidence_metadata_completed(
    EvidenceImportDialogResult *result,
    gpointer user_data
)
{
    ApplicationEvidenceDialogContext *context =
        user_data;

    Application *application = NULL;

    if (context == NULL)
    {
        evidence_import_dialog_result_free(
            result
        );

        return;
    }

    application =
        context->application;

    if (application == NULL ||
        application->main_window == NULL)
    {
        evidence_import_dialog_result_free(
            result
        );

        application_evidence_dialog_context_free(
            context
        );

        return;
    }

    /*
     * Une annulation du dialogue ne doit lancer aucune tâche.
     */
    if (result == NULL)
    {
        main_window_set_status(
            application->main_window,
            "Import de preuve annulé."
        );

        application_evidence_dialog_context_free(
            context
        );

        return;
    }

    application_start_evidence_import(
        application,
        context->file_path,
        evidence_import_dialog_result_get_type_identifier(
            result
        ),
        evidence_import_dialog_result_get_collected_at(
            result
        ),
        evidence_import_dialog_result_get_source(
            result
        ),
        evidence_import_dialog_result_get_description(
            result
        ),
        NULL
    );

    evidence_import_dialog_result_free(
        result
    );

    application_evidence_dialog_context_free(
        context
    );
}

/**
 * @brief Traite le fichier de preuve sélectionné.
 *
 * @param file_path Chemin local sélectionné, ou NULL.
 * @param error Erreur de sélection, ou NULL.
 * @param user_data Pointeur vers Application.
 */
static void application_on_evidence_file_selected(
    const char *file_path,
    const GError *error,
    gpointer user_data
)
{
    Application *application =
        user_data;

    if (application == NULL ||
        application->main_window == NULL)
    {
        return;
    }

    /*
     * Une annulation ne constitue pas une erreur.
     */
    if (file_path == NULL &&
        error == NULL)
    {
        main_window_set_status(
            application->main_window,
            "Import de preuve annulé."
        );

        return;
    }

    if (error != NULL)
    {
        g_warning(
            "Impossible de sélectionner le fichier : %s",
            error->message
        );

        application_present_error(
            application,
            "Sélection impossible",
            error->message
        );

        return;
    }

    if (file_path == NULL ||
        file_path[0] == '\0')
    {
        application_present_error(
            application,
            "Sélection impossible",
            "Le chemin du fichier sélectionné est invalide."
        );

        return;
    }

    Database *database = NULL;
    EvidenceTypeDao *evidence_type_dao = NULL;
    GPtrArray *evidence_types = NULL;

    ApplicationEvidenceDialogContext *dialog_context =
        NULL;

    GError *dialog_error = NULL;

    database =
        investigation_session_get_database(
            application->session
        );

    if (database == NULL)
    {
        application_present_error(
            application,
            "Import impossible",
            "La session ne fournit aucune connexion SQLite."
        );

        return;
    }

    evidence_type_dao =
        evidence_type_dao_new(
            database,
            &dialog_error
        );

    if (evidence_type_dao == NULL)
    {
        application_present_error(
            application,
            "Types de preuve indisponibles",
            dialog_error != NULL
            ? dialog_error->message
            : "Impossible de créer le DAO des types de preuve."
        );

        g_clear_error(
            &dialog_error
        );

        return;
    }

    evidence_types =
        evidence_type_dao_list_all(
            evidence_type_dao,
            &dialog_error
        );

    evidence_type_dao_free(
        evidence_type_dao
    );

    if (evidence_types == NULL)
    {
        application_present_error(
            application,
            "Types de preuve indisponibles",
            dialog_error != NULL
            ? dialog_error->message
            : "Impossible de lire les types de preuve."
        );

        g_clear_error(
            &dialog_error
        );

        return;
    }

    if (evidence_types->len == 0)
    {
        application_present_error(
            application,
            "Types de preuve indisponibles",
            "Aucun type de preuve n'est enregistré dans la base."
        );

        g_ptr_array_unref(
            evidence_types
        );

        return;
    }

    dialog_context =
        g_try_new0(
            ApplicationEvidenceDialogContext,
            1
        );

    if (dialog_context == NULL)
    {
        application_present_error(
            application,
            "Import impossible",
            "Impossible d'allouer le contexte du dialogue."
        );

        g_ptr_array_unref(
            evidence_types
        );

        return;
    }

    dialog_context->application =
        application;

    dialog_context->file_path =
        g_strdup(
            file_path
        );

    if (dialog_context->file_path == NULL)
    {
        application_present_error(
            application,
            "Import impossible",
            "Impossible de conserver le chemin du fichier."
        );

        application_evidence_dialog_context_free(
            dialog_context
        );

        g_ptr_array_unref(
            evidence_types
        );

        return;
    }

    if (!evidence_import_dialog_present(
        main_window_get_window(
            application->main_window
        ),
        dialog_context->file_path,
        evidence_types,
        application_on_evidence_metadata_completed,
        dialog_context,
        &dialog_error
    ))
    {
        application_present_error(
            application,
            "Dialogue d'import impossible",
            dialog_error != NULL
            ? dialog_error->message
            : "Le dialogue de métadonnées n'a pas pu être ouvert."
        );

        g_clear_error(
            &dialog_error
        );

        application_evidence_dialog_context_free(
            dialog_context
        );
    }

    g_ptr_array_unref(
        evidence_types
    );
}

/** @brief Traite les métadonnées du fichier courant d'un import groupé. */
static void application_on_batch_metadata_completed(
    EvidenceImportDialogResult *result, gpointer user_data
)
{
    ApplicationEvidenceBatchContext *context = user_data;
    const char *file_path = NULL;
    if (context == NULL) { evidence_import_dialog_result_free(result); return; }
    if (result == NULL)
    {
        context->skipped_count++;
        context->current_index++;
        application_present_next_batch_metadata(context);
        return;
    }
    file_path = g_ptr_array_index(context->file_paths, context->current_index);
    application_start_evidence_import(
        context->application, file_path,
        evidence_import_dialog_result_get_type_identifier(result),
        evidence_import_dialog_result_get_collected_at(result),
        evidence_import_dialog_result_get_source(result),
        evidence_import_dialog_result_get_description(result), context);
    evidence_import_dialog_result_free(result);
}

/** @brief Présente les métadonnées du prochain fichier, ou le bilan final. */
static void application_present_next_batch_metadata(
    ApplicationEvidenceBatchContext *context
)
{
    GError *error = NULL;
    const char *file_path = NULL;
    char *status = NULL;
    if (context == NULL) return;
    if (context->current_index >= context->file_paths->len)
    {
        application_finish_evidence_batch(context);
        return;
    }
    file_path = g_ptr_array_index(context->file_paths, context->current_index);
    status = g_strdup_printf("Préparation %u/%u : %s",
        context->current_index + 1U, context->file_paths->len, file_path);
    main_window_set_status(context->application->main_window, status);
    g_free(status);
    if (!evidence_import_dialog_present(
            main_window_get_window(context->application->main_window),
            file_path, context->evidence_types,
            application_on_batch_metadata_completed, context, &error))
    {
        char *failure = g_strdup_printf("%s : %s", file_path,
            error != NULL ? error->message : "dialogue indisponible");
        g_ptr_array_add(context->failures, failure);
        g_clear_error(&error);
        context->current_index++;
        application_present_next_batch_metadata(context);
    }
}

/** @brief Prépare un import groupé depuis les chemins sélectionnés. */
static void application_on_evidence_files_selected(
    const GPtrArray *paths, const GError *error, gpointer user_data
)
{
    Application *application = user_data;
    ApplicationEvidenceBatchContext *context = NULL;
    EvidenceTypeDao *dao = NULL;
    GPtrArray *types = NULL;
    GError *local_error = NULL;
    if (application == NULL || application->main_window == NULL) return;
    if (error != NULL)
    {
        application_present_error(application, "Sélection impossible", error->message);
        return;
    }
    if (paths == NULL || paths->len == 0U)
    {
        main_window_set_status(application->main_window, "Import de preuve annulé.");
        return;
    }
    if (paths->len == 1U)
    {
        application_on_evidence_file_selected(
            g_ptr_array_index((GPtrArray *) paths, 0U), NULL, application);
        return;
    }
    dao = evidence_type_dao_new(
        investigation_session_get_database(application->session), &local_error);
    if (dao != NULL) types = evidence_type_dao_list_all(dao, &local_error);
    evidence_type_dao_free(dao);
    if (types == NULL || types->len == 0U)
    {
        application_present_error(application, "Types de preuve indisponibles",
            local_error != NULL ? local_error->message
                                : "Aucun type de preuve n'est disponible.");
        g_clear_error(&local_error);
        g_clear_pointer(&types, g_ptr_array_unref);
        return;
    }
    context = g_new0(ApplicationEvidenceBatchContext, 1);
    context->application = application;
    context->file_paths = g_ptr_array_new_with_free_func(g_free);
    context->evidence_types = types;
    context->failures = g_ptr_array_new_with_free_func(g_free);
    for (guint index = 0U; index < paths->len; index++)
        g_ptr_array_add(context->file_paths,
            g_strdup(g_ptr_array_index((GPtrArray *) paths, index)));
    main_window_set_import_evidence_enabled(application->main_window, FALSE);
    {
        char *message = g_strdup_printf(
            "%u fichiers ont été sélectionnés. Chaque fichier sera révisé "
            "puis importé séparément avec sa propre empreinte SHA-256.",
            paths->len);
        application_message_dialog_present_confirmation(
            main_window_get_window(application->main_window),
            APPLICATION_MESSAGE_DIALOG_INFORMATION,
            "Préparer l'import groupé", message, "Continuer",
            application_on_batch_selection_confirmed, context);
        g_free(message);
    }
}

/**
 * @brief Traite la demande d'import d'une preuve.
 *
 * Le sélecteur de fichier sera ajouté à l'étape suivante.
 *
 * @param user_data Pointeur vers Application.
 */
static void application_on_import_evidence_requested(
    gpointer user_data
)
{
    Application *application = user_data;

    if (application == NULL ||
        application->main_window == NULL)
    {
        return;
    }

    if (application->session == NULL)
    {
        main_window_set_import_evidence_enabled(
            application->main_window,
            FALSE
        );

        return;
    }

    file_dialog_select_files(
        main_window_get_window(
            application->main_window
        ),
        application_on_evidence_files_selected,
        application
    );
}

/** @brief Persiste le résultat validé du dialogue de compte social. */
static void application_on_social_account_completed(
    CreateSocialAccountDialogResult *result, gpointer user_data)
{
    Application *application = user_data;
    SocialAccountInput input = {0};
    const InvestigationProject *project = NULL;
    Database *database = NULL;
    GError *error = NULL;
    char *identifier = NULL;
    if (result == NULL || application == NULL || application->session == NULL)
    {
        create_social_account_dialog_result_free(result);
        return;
    }
    input.platform = create_social_account_dialog_result_get_platform(result);
    input.profile_url = create_social_account_dialog_result_get_profile_url(result);
    input.username = create_social_account_dialog_result_get_username(result);
    input.platform_identifier = create_social_account_dialog_result_get_platform_identifier(result);
    input.first_observed_at = create_social_account_dialog_result_get_first_observed_at(result);
    input.account_state = create_social_account_dialog_result_get_account_state(result);
    input.notes = create_social_account_dialog_result_get_notes(result);
    input.evidence_identifier = create_social_account_dialog_result_get_evidence_identifier(result);
    database = investigation_session_get_database(application->session);
    if (!social_account_service_create(database, &input, &identifier, &error))
    {
        application_present_error(application, "Compte social non créé",
            error != NULL ? error->message : "L'écriture dans l'enquête a échoué.");
    }
    else
    {
        project = investigation_session_get_project(application->session);
        application_message_dialog_present(
            main_window_get_window(application->main_window),
            APPLICATION_MESSAGE_DIALOG_INFORMATION,
            "Compte social ajouté",
            "Le profil et son éventuelle preuve associée ont été ajoutés au graphe.");
        application_start_graph_loading(application,
            investigation_project_get_database_path(project));
    }
    g_clear_error(&error);
    g_free(identifier);
    create_social_account_dialog_result_free(result);
}

/** @brief Charge les preuves puis ouvre le formulaire de compte social. */
static void application_on_add_social_account_requested(gpointer user_data)
{
    Application *application = user_data;
    Database *database = NULL;
    EvidenceDao *dao = NULL;
    GPtrArray *evidence_records = NULL;
    GError *error = NULL;
    if (application == NULL || application->main_window == NULL ||
        application->session == NULL) return;
    database = investigation_session_get_database(application->session);
    dao = evidence_dao_new(database, &error);
    if (dao != NULL) evidence_records = evidence_dao_list_all(dao, &error);
    if (evidence_records == NULL)
    {
        application_present_error(application, "Formulaire indisponible",
            error != NULL ? error->message : "Impossible de charger les preuves.");
    }
    else
    {
        create_social_account_dialog_present(
            main_window_get_window(application->main_window), evidence_records,
            application_on_social_account_completed, application);
    }
    g_clear_pointer(&evidence_records, g_ptr_array_unref);
    evidence_dao_free(dao);
    g_clear_error(&error);
}

/** @brief Persiste une personne validée puis recharge le graphe. */
static void application_on_person_creation_task_completed(
    BackgroundTask *task, gpointer user_data)
{
    ApplicationPersonCreationTaskContext *context = user_data;
    Application *application = context != NULL ? context->application : NULL;
    const InvestigationProject *project = application != NULL &&
        application->session != NULL
        ? investigation_session_get_project(application->session) : NULL;
    gboolean session_matches = project != NULL &&
        application->session_generation == context->generation &&
        g_strcmp0(investigation_project_get_root_path(project),
            context->root_path) == 0 &&
        g_strcmp0(investigation_project_get_database_path(project),
            context->database_path) == 0;
    if (!session_matches) return;
    if (background_task_get_state(task) != BACKGROUND_TASK_STATE_COMPLETED) {
        GError *error = background_task_dup_error(task);
        application_present_error(application, "Personne non créée",
            error != NULL ? error->message : "L’écriture a échoué.");
        g_clear_error(&error);
        return;
    }
    main_window_set_status(application->main_window,
        "Personne et preuves ajoutées. Actualisation du graphe…");
    application_start_graph_loading(application, context->database_path);
}
static void application_on_person_completed(
    CreatePersonDialogResult *result, gpointer user_data)
{
    ApplicationPersonDialogContext *context = user_data;
    Application *application = context != NULL ? context->application : NULL;
    const PersonEntityInput *input = NULL;
    const InvestigationProject *project = NULL;
    GError *error = NULL;
    PersonCreationTaskRequest *request = NULL;
    BackgroundTask *task = NULL;
    ApplicationPersonCreationTaskContext *task_context = NULL;
    const char *active_root = NULL, *active_database = NULL;
    if (result == NULL) {
        return;
    }
    input = create_person_dialog_result_get_input(result);
    if (application == NULL || application->session == NULL)
        goto changed_session;
    project = investigation_session_get_project(application->session);
    active_root = investigation_project_get_root_path(project);
    active_database = investigation_project_get_database_path(project);
    if (!person_creation_guard_matches(context->guard, TRUE,
            application->session_generation, active_root, active_database))
        goto changed_session;
    request = person_creation_task_request_new(active_database, active_root,
        input, create_person_dialog_result_get_evidence_selection(result));
    task_context = g_new0(ApplicationPersonCreationTaskContext, 1);
    task_context->application = application;
    task_context->generation = application->session_generation;
    task_context->root_path = g_strdup(active_root);
    task_context->database_path = g_strdup(active_database);
    task_context->staging =
        create_person_dialog_result_steal_staging(result);
    task = person_creation_task_start(application->task_manager, request,
        application_on_person_creation_task_completed, task_context,
        application_person_creation_task_context_free, &error);
    if (task == NULL) {
        application_person_creation_task_context_free(task_context);
        application_present_error(application, "Personne non créée",
            error != NULL ? error->message : "L'écriture a échoué.");
    } else {
        main_window_set_status(application->main_window,
            "Création et import des preuves en cours…");
        background_task_unref(task);
    }
    person_creation_task_request_free(request);
    g_clear_error(&error);
    create_person_dialog_result_free(result);
    return;
changed_session:
    application_present_error(application, "Personne non créée",
        "L'enquête active a changé depuis l'ouverture de l'assistant.");
    create_person_dialog_result_free(result);
}

static gboolean application_person_dialog_session_matches(gpointer user_data)
{
    ApplicationPersonDialogContext *context = user_data;
    Application *application = context != NULL ? context->application : NULL;
    const InvestigationProject *project;
    if (application == NULL || application->session == NULL) return FALSE;
    project = investigation_session_get_project(application->session);
    return person_creation_guard_matches(context->guard, TRUE,
        application->session_generation,
        investigation_project_get_root_path(project),
        investigation_project_get_database_path(project));
}

/** @brief Charge les preuves puis ouvre le formulaire d'une personne. */
static void application_on_add_person_requested(gpointer user_data)
{
    Application *application = user_data;
    EvidenceDao *dao = NULL;
    GPtrArray *records = NULL;
    ApplicationPersonDialogContext *context = NULL;
    const InvestigationProject *project = NULL;
    GError *error = NULL;
    if (application == NULL || application->session == NULL) return;
    dao = evidence_dao_new(
        investigation_session_get_database(application->session), &error);
    if (dao != NULL) records = evidence_dao_list_all(dao, &error);
    if (records == NULL)
        application_present_error(application, "Formulaire indisponible",
            error != NULL ? error->message : "Impossible de charger les preuves.");
    else {
        project = investigation_session_get_project(application->session);
        context = g_new0(ApplicationPersonDialogContext, 1);
        context->application = application;
        context->guard = person_creation_guard_new(
            application->session_generation,
            investigation_project_get_root_path(project),
            investigation_project_get_database_path(project));
        create_person_dialog_present(main_window_get_window(application->main_window),
            records, investigation_project_get_root_path(project),
            application->task_manager,
            application_person_dialog_session_matches,
            application_on_person_completed, context,
            (GDestroyNotify) application_person_dialog_context_free);
    }
    g_clear_pointer(&records, g_ptr_array_unref);
    evidence_dao_free(dao); g_clear_error(&error);
}

/**
 * @brief Traite la sélection d'un nœud dans l'arborescence.
 *
 * @param node Nœud sélectionné, ou NULL si aucune sélection.
 * @param user_data Pointeur vers Application.
 */
static void application_on_tree_node_selected(
    const InvestigationNode *node,
    gpointer user_data
)
{
    Application *application = user_data;
    const char *node_name = NULL;
    InvestigationNodeType node_type;

    if (application == NULL)
    {
        return;
    }

    main_window_set_selected_node(
        application->main_window,
        node
    );

    if (node == NULL)
    {
        g_print("Aucun nœud sélectionné.\n");
        return;
    }

    node_name = investigation_node_get_name(
        node
    );

    node_type = investigation_node_get_type(
        node
    );

    g_print(
        "Nœud sélectionné : %s\n",
        node_name != NULL
            ? node_name
            : "(sans nom)"
    );

    if (node_type == INVESTIGATION_NODE_DIRECTORY)
    {
        g_print("Type : dossier\n");
    }
    else
    {
        g_print("Type : fichier\n");
        main_window_set_evidence_preview(
            application->main_window,
            investigation_node_get_path(node), node_name);
    }
}

/**
 * @brief Traite la sélection d'une preuve dans la Sidebar.
 *
 * L'identifiant est emprunté uniquement pendant cet appel.
 * La preuve complète est relue depuis SQLite avant d'être transmise
 * au Workspace.
 *
 * @param evidence_identifier UUID de la preuve, ou NULL.
 * @param user_data Pointeur vers Application.
 */
static void application_on_evidence_selected(
    const char *evidence_identifier,
    gpointer user_data
)
{
    Application *application =
        user_data;

    Database *database =
        NULL;

    EvidenceDao *evidence_dao =
        NULL;

    EvidenceRecord *evidence_record =
        NULL;

    const char *original_name =
        NULL;

    const InvestigationProject *project = NULL;
    const char *investigation_root = NULL;

    char *status_message =
        NULL;

    GError *error =
        NULL;

    if (application == NULL ||
        application->main_window == NULL)
    {
        return;
    }

    /*
     * Une catégorie ou une sélection vide transmet NULL.
     */
    if (evidence_identifier == NULL ||
        evidence_identifier[0] == '\0')
    {
        application_set_selected_evidence_identifier(
            application,
            NULL
        );

        main_window_set_selected_evidence(
            application->main_window,
            NULL
        );

        application_set_selected_evidence_identifier(
            application,
            NULL
        );

        return;
    }

    if (application->session == NULL)
    {
        main_window_set_selected_evidence(
            application->main_window,
            NULL
        );

        return;
    }

    database =
        investigation_session_get_database(
            application->session
        );

    if (database == NULL)
    {
        main_window_set_selected_evidence(
            application->main_window,
            NULL
        );

        application_present_error(
            application,
            "Preuve indisponible",
            "La session ne fournit aucune connexion SQLite."
        );

        return;
    }

    evidence_dao =
        evidence_dao_new(
            database,
            &error
        );

    if (evidence_dao == NULL)
    {
        g_warning(
            "Impossible de créer le DAO des preuves : %s",
            error != NULL
                ? error->message
                : "erreur inconnue"
        );

        main_window_set_selected_evidence(
            application->main_window,
            NULL
        );

        application_present_error(
            application,
            "Preuve indisponible",
            error != NULL
                ? error->message
                : "Impossible d'accéder aux preuves enregistrées."
        );

        g_clear_error(
            &error
        );

        return;
    }

    evidence_record =
        evidence_dao_find_by_identifier(
            evidence_dao,
            evidence_identifier,
            &error
        );

    evidence_dao_free(
        evidence_dao
    );

    if (error != NULL)
    {
        g_warning(
            "Impossible de charger la preuve '%s' : %s",
            evidence_identifier,
            error->message
        );

        main_window_set_selected_evidence(
            application->main_window,
            NULL
        );

        application_present_error(
            application,
            "Preuve indisponible",
            error->message
        );

        g_clear_error(
            &error
        );

        return;
    }

    /*
     * Une preuve absente retourne NULL sans erreur.
     */
    if (evidence_record == NULL)
    {
        g_warning(
            "La preuve '%s' n'existe plus dans la base.",
            evidence_identifier
        );

        main_window_set_selected_evidence(
            application->main_window,
            NULL
        );

        main_window_set_status(
            application->main_window,
            "La preuve sélectionnée est introuvable."
        );

        return;
    }

    application_set_selected_evidence_identifier(
        application,
        evidence_identifier
    );

    /*
     * Workspace copie immédiatement les valeurs dans ses widgets GTK.
     */
    main_window_set_selected_evidence(
        application->main_window,
        evidence_record
    );
    {
        EvidenceEntityDao *observation_dao =
            evidence_entity_dao_new(database, &error);
        GPtrArray *observations = observation_dao != NULL
            ? evidence_entity_dao_list_observations(observation_dao,
                evidence_identifier, &error) : NULL;
        if (error == NULL)
            main_window_set_evidence_observations(application->main_window,
                observations);
        else
            g_warning("Observations EML indisponibles : %s", error->message);
        g_clear_error(&error);
        g_clear_pointer(&observations, g_ptr_array_unref);
        evidence_entity_dao_free(observation_dao);
    }

    project = investigation_session_get_project(application->session);
    investigation_root = project != NULL
        ? investigation_project_get_root_path(project) : NULL;
    gboolean eml_analysis_available = FALSE;
    if (investigation_root != NULL) {
        const char *selected_name =
            evidence_record_get_original_name(evidence_record);
        char *lower_name = selected_name != NULL
            ? g_ascii_strdown(selected_name, -1) : NULL;
        eml_analysis_available = lower_name != NULL &&
            g_str_has_suffix(lower_name, ".eml");
        g_free(lower_name);
        main_window_show_evidence_preview(application->main_window,
            investigation_root, evidence_record);
    }
    main_window_set_eml_analysis_available(
        application->main_window, eml_analysis_available);

    original_name =
        evidence_record_get_original_name(
            evidence_record
        );

    status_message =
        g_strdup_printf(
            "Preuve sélectionnée : %s",
            original_name != NULL &&
            original_name[0] != '\0'
                ? original_name
                : "(sans nom)"
        );

    main_window_set_status(
        application->main_window,
        status_message
    );

    g_free(
        status_message
    );

    evidence_record_free(
        evidence_record
    );
}


/**
 * @brief Traite la validation ou l'annulation du dialogue de relation.
 *
 * Cette première étape valide le parcours complet de l'interface.
 * L'écriture SQLite sera branchée après validation de la compilation.
 */
static void application_on_create_relation_completed(
    CreateRelationDialogResult *result,
    gpointer user_data
)
{
    Application *application =
        user_data;

    const InvestigationProject *project =
        NULL;

    Database *database =
        NULL;

    RelationService *relation_service =
        NULL;

    RelationRecord *relation_record =
        NULL;

    GDateTime *current_date_time =
        NULL;

    const char *source_identifier =
        NULL;

    const char *target_identifier =
        NULL;

    const char *relation_type =
        NULL;

    const char *database_path =
        NULL;

    char *relation_identifier =
        NULL;

    char *timestamp =
        NULL;

    GError *error =
        NULL;

    gboolean relation_created =
        FALSE;
    gint64 relation_type_identifier = 0;

    if (application == NULL ||
        application->main_window == NULL)
    {
        create_relation_dialog_result_free(
            result
        );

        return;
    }

    if (result == NULL)
    {
        main_window_set_status(
            application->main_window,
            "Ajout de relation annulé."
        );

        return;
    }

    if (application->session == NULL)
    {
        application_present_error(
            application,
            "Ajout de relation impossible",
            "Aucune enquête n'est actuellement ouverte."
        );

        goto cleanup;
    }

    source_identifier =
        create_relation_dialog_result_get_source_identifier(
            result
        );

    target_identifier =
        create_relation_dialog_result_get_target_identifier(
            result
        );

    relation_type =
        create_relation_dialog_result_get_relation_type(
            result
        );

    database =
        investigation_session_get_database(
            application->session
        );

    project =
        investigation_session_get_project(
            application->session
        );

    if (database == NULL ||
        project == NULL)
    {
        application_present_error(
            application,
            "Ajout de relation impossible",
            "La session d'enquête est invalide."
        );

        goto cleanup;
    }

    database_path =
        investigation_project_get_database_path(
            project
        );

    if (database_path == NULL ||
        database_path[0] == '\0')
    {
        application_present_error(
            application,
            "Ajout de relation impossible",
            "Le chemin de la base SQLite est invalide."
        );

        goto cleanup;
    }

    relation_identifier =
        g_uuid_string_random();

    current_date_time =
        g_date_time_new_now_utc();

    if (current_date_time != NULL)
    {
        timestamp =
            g_date_time_format(
                current_date_time,
                "%Y-%m-%dT%H:%M:%SZ"
            );
    }

    if (relation_identifier == NULL ||
        timestamp == NULL)
    {
        application_present_error(
            application,
            "Ajout de relation impossible",
            "Impossible de préparer l'identifiant ou la date "
            "de la nouvelle relation."
        );

        goto cleanup;
    }

    relation_type_identifier =
        create_relation_dialog_result_get_relation_type_identifier(result);
    if (relation_type_identifier == 0)
    {
        RelationTypeService *type_service =
            relation_type_service_new(database, &error);
        if (type_service == NULL ||
            !relation_type_service_create_custom(type_service, relation_type,
                NULL, &relation_type_identifier, &error))
        {
            relation_type_service_free(type_service);
            application_present_error(application,
                "Création du type impossible",
                error != NULL ? error->message :
                "Le nouveau type n'a pas pu être créé.");
            goto cleanup;
        }
        relation_type_service_free(type_service);
    }

    relation_record =
        relation_record_new_canonical(
            relation_identifier,
            source_identifier,
            target_identifier,
            relation_type_identifier,
            create_relation_dialog_result_get_relation_type_code(result),
            relation_type,
            create_relation_dialog_result_get_label(
                result
            ),
            create_relation_dialog_result_get_justification(
                result
            ),
            create_relation_dialog_result_get_confidence(
                result
            ),
            timestamp,
            timestamp,
            RELATION_STATUS_ACTIVE,
            &error
        );

    if (relation_record == NULL)
    {
        application_present_error(
            application,
            "Relation invalide",
            error != NULL
                ? error->message
                : "Les informations de la relation sont invalides."
        );

        g_clear_error(
            &error
        );

        goto cleanup;
    }

    relation_service =
        relation_service_new(
            database,
            &error
        );

    if (relation_service == NULL)
    {
        application_present_error(
            application,
            "Ajout de relation impossible",
            error != NULL
                ? error->message
                : "Impossible de préparer le service des relations."
        );

        g_clear_error(
            &error
        );

        goto cleanup;
    }

    /*
     * Aucune preuve n'est associée pendant ce premier parcours.
     * Le service accepte donc un tableau NULL.
     */
    if (!relation_service_create(
            relation_service,
            relation_record,
            create_relation_dialog_result_get_evidence_identifiers(result),
            &error
        ))
    {
        g_warning(
            "Impossible d'enregistrer la relation '%s' : %s",
            relation_identifier,
            error != NULL
                ? error->message
                : "erreur inconnue"
        );

        application_present_error(
            application,
            "Enregistrement de la relation impossible",
            error != NULL
                ? error->message
                : "La relation n'a pas pu être enregistrée."
        );

        g_clear_error(
            &error
        );

        goto cleanup;
    }

    relation_created =
        TRUE;

    g_message(
        "Relation enregistrée : %s -> %s (%s), identifiant %s.",
        source_identifier,
        target_identifier,
        relation_type,
        relation_identifier
    );

    main_window_set_status(
        application->main_window,
        "Relation enregistrée. Actualisation du graphe…"
    );

    /*
     * Le graphe n'est rechargé qu'après le COMMIT réussi.
     * En cas d'échec SQLite, l'affichage courant reste intact.
     */
    application_start_graph_loading(
        application,
        database_path
    );

cleanup:

    if (!relation_created &&
        application->main_window != NULL)
    {
        main_window_set_status(
            application->main_window,
            "La relation n'a pas été enregistrée."
        );
    }

    relation_service_free(
        relation_service
    );

    relation_record_free(
        relation_record
    );

    if (current_date_time != NULL)
    {
        g_date_time_unref(
            current_date_time
        );
    }

    g_free(
        timestamp
    );

    g_free(
        relation_identifier
    );

    create_relation_dialog_result_free(
        result
    );
}

/**
 * @brief Ouvre le dialogue de création depuis la fiche d'une entité.
 */
/** @brief Contexte conservé pendant l'édition d'une relation. */
typedef struct
{
    Application *application;
    char *relation_identifier;
} ApplicationEditRelationContext;

/** @brief Contexte possédé pendant la confirmation de suppression. */
typedef struct
{
    Application *application;
    char *relation_identifier;
} ApplicationDeleteRelationContext;

/** @brief Libère un contexte de suppression de relation. */
static void application_delete_relation_context_free(
    ApplicationDeleteRelationContext *context)
{
    if (context == NULL) return;
    g_free(context->relation_identifier);
    g_free(context);
}

/** @brief Supprime la relation après confirmation explicite. */
static void application_on_delete_relation_confirmed(gboolean confirmed,
    gpointer user_data)
{
    ApplicationDeleteRelationContext *context = user_data;
    Application *application = context != NULL ? context->application : NULL;
    Database *database = NULL;
    RelationDao *relation_dao = NULL;
    const InvestigationProject *project = NULL;
    GError *error = NULL;
    gboolean transaction_active = FALSE;
    if (!confirmed || application == NULL || application->session == NULL)
        goto cleanup;
    database = investigation_session_get_database(application->session);
    project = investigation_session_get_project(application->session);
    relation_dao = relation_dao_new(database, &error);
    if (relation_dao == NULL || !database_transaction_begin(database))
        goto failure;
    transaction_active = TRUE;
    if (!relation_dao_delete(relation_dao, context->relation_identifier,
            &error) || !database_transaction_commit(database))
        goto failure;
    transaction_active = FALSE;
    main_window_set_status(application->main_window,
        "Relation supprimée. Actualisation du graphe…");
    application_start_graph_loading(application,
        investigation_project_get_database_path(project));
    goto cleanup;
failure:
    if (transaction_active) database_transaction_rollback(database);
    application_present_error(application, "Suppression impossible",
        error != NULL ? error->message :
        "La relation n'a pas pu être supprimée.");
cleanup:
    g_clear_error(&error);
    relation_dao_free(relation_dao);
    application_delete_relation_context_free(context);
}

/** @brief Prépare la confirmation de suppression d'une relation. */
static void application_on_delete_relation_requested(
    const char *relation_identifier, gpointer user_data)
{
    Application *application = user_data;
    Database *database = NULL;
    RelationDao *relation_dao = NULL;
    EntityDao *entity_dao = NULL;
    RelationRecord *relation = NULL;
    EntityRecord *source = NULL;
    EntityRecord *target = NULL;
    ApplicationDeleteRelationContext *context = NULL;
    char *message = NULL;
    GError *error = NULL;
    if (application == NULL || application->session == NULL ||
        relation_identifier == NULL) return;
    database = investigation_session_get_database(application->session);
    relation_dao = relation_dao_new(database, &error);
    if (relation_dao != NULL) relation = relation_dao_find_by_identifier(
        relation_dao, relation_identifier, &error);
    entity_dao = entity_dao_new(database, &error);
    if (relation != NULL && entity_dao != NULL)
    {
        source = entity_dao_find_by_identifier(entity_dao,
            relation_record_get_source_entity_identifier(relation), &error);
        target = entity_dao_find_by_identifier(entity_dao,
            relation_record_get_target_entity_identifier(relation), &error);
    }
    if (relation == NULL || source == NULL || target == NULL) goto failure;
    context = g_new0(ApplicationDeleteRelationContext, 1);
    context->application = application;
    context->relation_identifier = g_strdup(relation_identifier);
    message = g_strdup_printf(
        "Supprimer définitivement la relation :\n\n%s → %s\n\n"
        "Les entités et les preuves resteront dans l’enquête.",
        entity_record_get_label(source) != NULL
            ? entity_record_get_label(source) : entity_record_get_value(source),
        entity_record_get_label(target) != NULL
            ? entity_record_get_label(target) : entity_record_get_value(target));
    if (context->relation_identifier == NULL || message == NULL) goto failure;
    application_message_dialog_present_confirmation(
        main_window_get_window(application->main_window),
        APPLICATION_MESSAGE_DIALOG_WARNING, "Supprimer la relation", message,
        "Supprimer", application_on_delete_relation_confirmed, context);
    context = NULL;
    goto cleanup;
failure:
    application_delete_relation_context_free(context); context = NULL;
    application_present_error(application, "Suppression impossible",
        error != NULL ? error->message :
        "La relation sélectionnée n'a pas pu être chargée.");
cleanup:
    g_free(message);
    g_clear_error(&error);
    entity_record_free(source); entity_record_free(target);
    relation_record_free(relation);
    entity_dao_free(entity_dao); relation_dao_free(relation_dao);
}

/** @brief Enregistre la catégorie choisie depuis la fiche personne. */
static void application_on_person_role_changed(const char *entity_identifier,
    PersonRole role, gpointer user_data)
{
    Application *application = user_data;
    Database *database = NULL;
    const InvestigationProject *project = NULL;
    GError *error = NULL;
    if (application == NULL || application->session == NULL) return;
    database = investigation_session_get_database(application->session);
    project = investigation_session_get_project(application->session);
    if (!person_entity_service_update_role(database, entity_identifier,
            role, &error))
    {
        application_present_error(application, "Catégorie non enregistrée",
            error != NULL ? error->message :
            "Impossible de catégoriser cette personne.");
        g_clear_error(&error);
        return;
    }
    g_free(application->pending_entity_selection_identifier);
    application->pending_entity_selection_identifier =
        g_strdup(entity_identifier);
    main_window_set_status(application->main_window,
        "Catégorie enregistrée. Actualisation du graphe…");
    application_start_graph_loading(application,
        investigation_project_get_database_path(project));
}

/** @brief Enregistre la confiance choisie dans la fiche personne. */
static void application_on_person_confidence_changed(
    const char *entity_identifier, gint confidence, gpointer user_data)
{
    Application *application = user_data;
    Database *database = NULL;
    const InvestigationProject *project = NULL;
    GError *error = NULL;
    if (application == NULL || application->session == NULL) return;
    database = investigation_session_get_database(application->session);
    project = investigation_session_get_project(application->session);
    if (!person_entity_service_update_confidence(database, entity_identifier,
            confidence, &error))
    {
        application_present_error(application, "Confiance non enregistrée",
            error != NULL ? error->message :
            "Impossible de modifier la confiance de cette personne.");
        g_clear_error(&error);
        return;
    }
    g_free(application->pending_entity_selection_identifier);
    application->pending_entity_selection_identifier =
        g_strdup(entity_identifier);
    main_window_set_status(application->main_window,
        "Confiance enregistrée. Actualisation du graphe…");
    application_start_graph_loading(application,
        investigation_project_get_database_path(project));
}

/** @brief Enregistre le nom affiché choisi dans la fiche personne. */
static void application_on_person_name_changed(const char *entity_identifier,
    const char *display_name, gpointer user_data)
{
    Application *application = user_data;
    Database *database = NULL;
    const InvestigationProject *project = NULL;
    GError *error = NULL;
    if (application == NULL || application->session == NULL) return;
    database = investigation_session_get_database(application->session);
    project = investigation_session_get_project(application->session);
    if (!person_entity_service_update_display_name(database, entity_identifier,
            display_name, &error))
    {
        application_present_error(application, "Nom non enregistré",
            error != NULL ? error->message :
            "Impossible de modifier le nom affiché de cette personne.");
        g_clear_error(&error);
        return;
    }
    g_free(application->pending_entity_selection_identifier);
    application->pending_entity_selection_identifier =
        g_strdup(entity_identifier);
    main_window_set_status(application->main_window,
        "Nom enregistré. Actualisation du graphe…");
    application_start_graph_loading(application,
        investigation_project_get_database_path(project));
}

/** @brief Charge et affiche les preuves liées à l'entité sélectionnée. */
static void application_on_entity_selected(const char *entity_identifier,
    gpointer user_data)
{
    Application *application = user_data; Database *database = NULL;
    EvidenceEntityDao *link_dao = NULL; EvidenceDao *evidence_dao = NULL;
    GPtrArray *identifiers = NULL; GPtrArray *records = NULL;
    GError *error = NULL;
    if (application == NULL || application->session == NULL ||
        entity_identifier == NULL) return;
    database = investigation_session_get_database(application->session);
    link_dao = evidence_entity_dao_new(database, &error);
    if (link_dao == NULL) goto cleanup;
    evidence_dao = evidence_dao_new(database, &error);
    if (evidence_dao == NULL) goto cleanup;
    identifiers = evidence_entity_dao_list_evidence_identifiers(link_dao,
        entity_identifier, &error);
    if (identifiers == NULL) goto cleanup;
    records = g_ptr_array_new_with_free_func((GDestroyNotify)
        evidence_record_free);
    for (guint index = 0; index < identifiers->len; index++)
    {
        EvidenceRecord *record = evidence_dao_find_by_identifier(evidence_dao,
            g_ptr_array_index(identifiers, index), &error);
        if (record == NULL) goto cleanup;
        g_ptr_array_add(records, record);
    }
    main_window_set_person_evidences(application->main_window, records);
cleanup:
    if (error != NULL)
        main_window_set_person_evidences(application->main_window, NULL);
    g_clear_error(&error); g_clear_pointer(&records, g_ptr_array_unref);
    g_clear_pointer(&identifiers, g_ptr_array_unref);
    evidence_dao_free(evidence_dao); evidence_entity_dao_free(link_dao);
}

/** @brief Contexte possédé par la gestion des preuves d'une personne. */
typedef struct { Application *application; char *entity_identifier; }
    ApplicationPersonEvidenceContext;
/** @brief Libère le contexte de gestion des preuves. */
static void application_person_evidence_context_free(
    ApplicationPersonEvidenceContext *context)
{
    if (context == NULL) return;
    g_free(context->entity_identifier); g_free(context);
}
/** @brief Synchronise atomiquement les preuves choisies. */
static void application_on_person_evidences_selected(GPtrArray *selected,
    gpointer user_data)
{
    ApplicationPersonEvidenceContext *context = user_data;
    Application *application = context != NULL ? context->application : NULL;
    Database *database = NULL; EvidenceEntityDao *dao = NULL;
    GPtrArray *existing = NULL; GError *error = NULL;
    gboolean active = FALSE;
    if (selected == NULL || application == NULL || application->session == NULL)
        goto cleanup;
    database = investigation_session_get_database(application->session);
    dao = evidence_entity_dao_new(database, &error);
    if (dao == NULL || !database_transaction_begin(database)) goto failure;
    active = TRUE;
    existing = evidence_entity_dao_list_evidence_identifiers(dao,
        context->entity_identifier, &error);
    if (existing == NULL) goto failure;
    for (guint index = 0; index < existing->len; index++)
    {
        const char *identifier = g_ptr_array_index(existing, index);
        gboolean retained = FALSE;
        for (guint wanted = 0; wanted < selected->len; wanted++)
            if (g_strcmp0(identifier, g_ptr_array_index(selected, wanted)) == 0)
                retained = TRUE;
        if (!retained && !evidence_entity_dao_unlink(dao, identifier,
                context->entity_identifier, &error)) goto failure;
    }
    for (guint index = 0; index < selected->len; index++)
    {
        const char *identifier = g_ptr_array_index(selected, index);
        if (!evidence_entity_dao_link(dao, identifier,
                context->entity_identifier, &error)) goto failure;
    }
    if (!database_transaction_commit(database)) goto failure;
    active = FALSE;
    main_window_set_status(application->main_window,
        "Pièces jointes de la personne enregistrées.");
    application_on_entity_selected(context->entity_identifier, application);
    goto cleanup;
failure:
    if (active) database_transaction_rollback(database);
    application_present_error(application, "Pièces jointes non enregistrées",
        error != NULL ? error->message : "La sélection n'a pas pu être enregistrée.");
cleanup:
    g_clear_error(&error); g_clear_pointer(&existing, g_ptr_array_unref);
    g_clear_pointer(&selected, g_ptr_array_unref);
    evidence_entity_dao_free(dao);
    application_person_evidence_context_free(context);
}
/** @brief Ouvre le gestionnaire des preuves de la personne sélectionnée. */
static void application_on_person_evidence_requested(
    const char *entity_identifier, gpointer user_data)
{
    Application *application = user_data; Database *database = NULL;
    EvidenceDao *evidence_dao = NULL; EvidenceEntityDao *link_dao = NULL;
    GPtrArray *records = NULL; GPtrArray *selected = NULL;
    ApplicationPersonEvidenceContext *context = NULL;
    const InvestigationProject *project = NULL; GError *error = NULL;
    if (application == NULL || application->session == NULL) return;
    database = investigation_session_get_database(application->session);
    project = investigation_session_get_project(application->session);
    evidence_dao = evidence_dao_new(database, &error);
    if (evidence_dao != NULL) records = evidence_dao_list_all(evidence_dao, &error);
    link_dao = evidence_entity_dao_new(database, &error);
    if (link_dao != NULL) selected =
        evidence_entity_dao_list_evidence_identifiers(link_dao,
            entity_identifier, &error);
    if (records == NULL || selected == NULL || project == NULL) goto failure;
    context = g_new0(ApplicationPersonEvidenceContext, 1);
    context->application = application;
    context->entity_identifier = g_strdup(entity_identifier);
    if (context->entity_identifier == NULL ||
        !manage_entity_evidence_dialog_present(main_window_get_window(
            application->main_window), records, selected,
            investigation_project_get_root_path(project),
            application_on_person_evidences_selected, context, &error))
        goto failure;
    context = NULL; goto cleanup;
failure:
    application_person_evidence_context_free(context); context = NULL;
    application_present_error(application, "Pièces jointes indisponibles",
        error != NULL ? error->message : "Le gestionnaire n'a pas pu être ouvert.");
cleanup:
    g_clear_error(&error); g_clear_pointer(&records, g_ptr_array_unref);
    g_clear_pointer(&selected, g_ptr_array_unref);
    evidence_dao_free(evidence_dao); evidence_entity_dao_free(link_dao);
}

/** @brief Libère le contexte d'édition d'une relation. */
static void application_edit_relation_context_free(
    ApplicationEditRelationContext *context)
{
    if (context == NULL) return;
    g_free(context->relation_identifier);
    g_free(context);
}

/** @brief Persiste les valeurs validées du dialogue d'édition. */
static void application_on_edit_relation_completed(
    CreateRelationDialogResult *result, gpointer user_data)
{
    ApplicationEditRelationContext *context = user_data;
    Application *application = context != NULL ? context->application : NULL;
    Database *database = NULL;
    RelationDao *relation_dao = NULL;
    RelationEvidenceDao *relation_evidence_dao = NULL;
    RelationRecord *existing = NULL;
    RelationRecord *updated = NULL;
    const InvestigationProject *project = NULL;
    GDateTime *now = NULL;
    char *timestamp = NULL;
    GError *error = NULL;
    gboolean transaction_active = FALSE;
    gint64 relation_type_identifier = 0;

    if (result == NULL || application == NULL || application->session == NULL)
        goto cleanup;
    database = investigation_session_get_database(application->session);
    project = investigation_session_get_project(application->session);
    relation_dao = relation_dao_new(database, &error);
    relation_evidence_dao = relation_evidence_dao_new(database, &error);
    if (relation_dao == NULL || relation_evidence_dao == NULL) goto failure;
    existing = relation_dao_find_by_identifier(relation_dao,
        context->relation_identifier, &error);
    if (existing == NULL) goto failure;
    now = g_date_time_new_now_utc();
    timestamp = now != NULL ? g_date_time_format(now,
        "%Y-%m-%dT%H:%M:%SZ") : NULL;
    relation_type_identifier =
        create_relation_dialog_result_get_relation_type_identifier(result);
    if (relation_type_identifier == 0)
    {
        RelationTypeService *type_service =
            relation_type_service_new(database, &error);
        if (type_service == NULL ||
            !relation_type_service_create_custom(type_service,
                create_relation_dialog_result_get_relation_type(result),
                NULL, &relation_type_identifier, &error))
        {
            relation_type_service_free(type_service);
            goto failure;
        }
        relation_type_service_free(type_service);
    }
    updated = relation_record_new_canonical(
        relation_record_get_identifier(existing),
        relation_record_get_source_entity_identifier(existing),
        relation_record_get_target_entity_identifier(existing),
        relation_type_identifier,
        create_relation_dialog_result_get_relation_type_code(result),
        create_relation_dialog_result_get_relation_type(result),
        create_relation_dialog_result_get_label(result),
        create_relation_dialog_result_get_justification(result),
        create_relation_dialog_result_get_confidence(result),
        relation_record_get_created_at(existing), timestamp,
        relation_record_get_status(existing), &error);
    if (updated == NULL || !database_transaction_begin(database)) goto failure;
    transaction_active = TRUE;
    if (!relation_dao_update(relation_dao, updated, &error))
        goto failure;
    {
        GPtrArray *existing_evidence =
            relation_evidence_dao_list_evidence_identifiers(
                relation_evidence_dao, context->relation_identifier, &error);
        const GPtrArray *selected_evidence =
            create_relation_dialog_result_get_evidence_identifiers(result);
        if (existing_evidence == NULL) goto failure;
        for (guint index = 0; index < existing_evidence->len; index++)
        {
            const char *identifier = g_ptr_array_index(existing_evidence, index);
            gboolean retained = FALSE;
            for (guint selected_index = 0;
                 selected_index < selected_evidence->len; selected_index++)
                if (g_strcmp0(identifier, g_ptr_array_index(selected_evidence,
                        selected_index)) == 0) retained = TRUE;
            if (!retained && !relation_evidence_dao_unlink(
                    relation_evidence_dao, context->relation_identifier,
                    identifier, &error))
            {
                g_ptr_array_unref(existing_evidence);
                goto failure;
            }
        }
        for (guint index = 0; index < selected_evidence->len; index++)
        {
            const char *identifier = g_ptr_array_index(selected_evidence, index);
            gboolean exists = FALSE;
            if (!relation_evidence_dao_exists(relation_evidence_dao,
                    context->relation_identifier, identifier, &exists, &error) ||
                (!exists && !relation_evidence_dao_link(relation_evidence_dao,
                    context->relation_identifier, identifier, &error)))
            {
                g_ptr_array_unref(existing_evidence);
                goto failure;
            }
        }
        g_ptr_array_unref(existing_evidence);
    }
    if (!database_transaction_commit(database)) goto failure;
    transaction_active = FALSE;
    main_window_set_status(application->main_window,
        "Relation modifiée. Actualisation du graphe…");
    g_free(application->pending_relation_selection_identifier);
    application->pending_relation_selection_identifier = g_strdup(
        context->relation_identifier);
    application_start_graph_loading(application,
        investigation_project_get_database_path(project));
    goto cleanup;

failure:
    if (transaction_active) database_transaction_rollback(database);
    application_present_error(application, "Modification impossible",
        error != NULL ? error->message :
        "La relation n'a pas pu être modifiée.");
cleanup:
    g_clear_error(&error);
    g_free(timestamp);
    if (now != NULL) g_date_time_unref(now);
    relation_record_free(updated);
    relation_record_free(existing);
    relation_dao_free(relation_dao);
    relation_evidence_dao_free(relation_evidence_dao);
    create_relation_dialog_result_free(result);
    application_edit_relation_context_free(context);
}

/** @brief Ouvre le formulaire prérempli de la relation sélectionnée. */
static void application_on_edit_relation_requested(
    const char *relation_identifier, gpointer user_data)
{
    Application *application = user_data;
    Database *database = NULL;
    RelationDao *relation_dao = NULL;
    EntityDao *entity_dao = NULL;
    EvidenceDao *evidence_dao = NULL;
    RelationEvidenceDao *relation_evidence_dao = NULL;
    RelationRecord *relation = NULL;
    GPtrArray *entities = NULL;
    GPtrArray *evidences = NULL;
    GPtrArray *selected_evidences = NULL;
    GPtrArray *relation_types = NULL;
    RelationTypeDao *relation_type_dao = NULL;
    const InvestigationProject *project = NULL;
    ApplicationEditRelationContext *context = NULL;
    GError *error = NULL;

    if (application == NULL || application->session == NULL ||
        relation_identifier == NULL) return;
    database = investigation_session_get_database(application->session);
    relation_dao = relation_dao_new(database, &error);
    entity_dao = entity_dao_new(database, &error);
    evidence_dao = evidence_dao_new(database, &error);
    relation_evidence_dao = relation_evidence_dao_new(database, &error);
    relation_type_dao = relation_type_dao_new(database, &error);
    project = investigation_session_get_project(application->session);
    if (relation_dao != NULL)
        relation = relation_dao_find_by_identifier(relation_dao,
            relation_identifier, &error);
    if (entity_dao != NULL) entities = entity_dao_list_all(entity_dao, &error);
    if (evidence_dao != NULL) evidences = evidence_dao_list_all(evidence_dao,
        &error);
    if (relation_evidence_dao != NULL) selected_evidences =
        relation_evidence_dao_list_evidence_identifiers(relation_evidence_dao,
            relation_identifier, &error);
    if (relation_type_dao != NULL)
        relation_types = relation_type_dao_list_all(relation_type_dao, &error);
    if (relation == NULL || entities == NULL || evidences == NULL ||
        selected_evidences == NULL || relation_types == NULL ||
        project == NULL) goto failure;
    context = g_new0(ApplicationEditRelationContext, 1);
    context->application = application;
    context->relation_identifier = g_strdup(relation_identifier);
    if (context->relation_identifier == NULL || !edit_relation_dialog_present(
            main_window_get_window(application->main_window), relation, entities,
            relation_types,
            evidences, selected_evidences,
            investigation_project_get_root_path(project),
            application_on_edit_relation_completed, context, &error))
        goto failure;
    context = NULL;
    goto cleanup;
failure:
    application_present_error(application, "Modification impossible",
        error != NULL ? error->message :
        "Le formulaire de modification n'a pas pu être ouvert.");
cleanup:
    application_edit_relation_context_free(context);
    g_clear_error(&error);
    g_clear_pointer(&entities, g_ptr_array_unref);
    g_clear_pointer(&evidences, g_ptr_array_unref);
    g_clear_pointer(&selected_evidences, g_ptr_array_unref);
    relation_record_free(relation);
    entity_dao_free(entity_dao);
    evidence_dao_free(evidence_dao);
    relation_evidence_dao_free(relation_evidence_dao);
    relation_type_dao_free(relation_type_dao);
    g_clear_pointer(&relation_types, g_ptr_array_unref);
    relation_dao_free(relation_dao);
}

/** @brief Charge les preuves liées à la relation affichée dans le volet. */
static void application_on_relation_selected(
    const char *relation_identifier,
    gpointer user_data)
{
    Application *application = user_data;
    Database *database = NULL;
    RelationEvidenceDao *relation_evidence_dao = NULL;
    EvidenceDao *evidence_dao = NULL;
    GPtrArray *identifiers = NULL;
    GPtrArray *records = NULL;
    GError *error = NULL;
    if (application == NULL || application->session == NULL ||
        relation_identifier == NULL) return;
    database = investigation_session_get_database(application->session);
    relation_evidence_dao = relation_evidence_dao_new(database, &error);
    if (relation_evidence_dao == NULL) goto cleanup;
    evidence_dao = evidence_dao_new(database, &error);
    if (evidence_dao == NULL) goto cleanup;
    identifiers = relation_evidence_dao_list_evidence_identifiers(
        relation_evidence_dao, relation_identifier, &error);
    if (identifiers == NULL) goto cleanup;
    records = g_ptr_array_new_with_free_func((GDestroyNotify)
        evidence_record_free);
    if (records == NULL) goto cleanup;
    for (guint index = 0; index < identifiers->len; index++)
    {
        EvidenceRecord *record = evidence_dao_find_by_identifier(evidence_dao,
            g_ptr_array_index(identifiers, index), &error);
        if (record == NULL) goto cleanup;
        g_ptr_array_add(records, record);
    }
    main_window_set_relation_evidences(application->main_window, records);

cleanup:
    if (error != NULL)
    {
        g_warning("Impossible de charger les preuves de la relation : %s",
            error->message);
        main_window_set_relation_evidences(application->main_window, NULL);
    }
    g_clear_error(&error);
    g_clear_pointer(&records, g_ptr_array_unref);
    g_clear_pointer(&identifiers, g_ptr_array_unref);
    evidence_dao_free(evidence_dao);
    relation_evidence_dao_free(relation_evidence_dao);
}

static void application_on_add_relation_requested(
    const char *source_entity_identifier,
    gpointer user_data
)
{
    Application *application =
        user_data;

    Database *database =
        NULL;

    EntityDao *entity_dao =
        NULL;

    EvidenceDao *evidence_dao = NULL;
    RelationTypeDao *relation_type_dao = NULL;
    const InvestigationProject *project = NULL;

    GPtrArray *entities =
        NULL;
    GPtrArray *evidences = NULL;
    GPtrArray *relation_types = NULL;

    GError *error =
        NULL;

    if (application == NULL ||
        application->main_window == NULL ||
        application->session == NULL ||
        source_entity_identifier == NULL ||
        !g_uuid_string_is_valid(
            source_entity_identifier
        ))
    {
        return;
    }

    database =
        investigation_session_get_database(
            application->session
        );
    project = investigation_session_get_project(application->session);

    if (database == NULL)
    {
        application_present_error(
            application,
            "Relations indisponibles",
            "La session ne fournit aucune connexion SQLite."
        );

        return;
    }

    entity_dao =
        entity_dao_new(
            database,
            &error
        );

    if (entity_dao == NULL)
    {
        application_present_error(
            application,
            "Relations indisponibles",
            error != NULL
                ? error->message
                : "Impossible d'accéder aux entités."
        );

        g_clear_error(
            &error
        );

        return;
    }

    entities =
        entity_dao_list_all(
            entity_dao,
            &error
        );

    evidence_dao = evidence_dao_new(database, &error);
    if (evidence_dao != NULL)
        evidences = evidence_dao_list_all(evidence_dao, &error);
    evidence_dao_free(evidence_dao);

    relation_type_dao = relation_type_dao_new(database, &error);
    if (relation_type_dao != NULL)
        relation_types = relation_type_dao_list_all(relation_type_dao, &error);
    relation_type_dao_free(relation_type_dao);

    entity_dao_free(
        entity_dao
    );

    if (entities == NULL || evidences == NULL || relation_types == NULL ||
        project == NULL)
    {
        application_present_error(
            application,
            "Relations indisponibles",
            error != NULL
                ? error->message
                : "Impossible de charger les entités."
        );

        g_clear_error(
            &error
        );

        g_clear_pointer(&entities, g_ptr_array_unref);
        g_clear_pointer(&evidences, g_ptr_array_unref);
        g_clear_pointer(&relation_types, g_ptr_array_unref);

        return;
    }

    if (!create_relation_dialog_present(
            main_window_get_window(
                application->main_window
            ),
            source_entity_identifier,
            entities,
            relation_types,
            evidences,
            investigation_project_get_root_path(project),
            application_on_create_relation_completed,
            application,
            &error
        ))
    {
        application_present_error(
            application,
            "Ajout de relation impossible",
            error != NULL
                ? error->message
                : "Le dialogue de relation n'a pas pu être ouvert."
        );

        g_clear_error(
            &error
        );
    }

    g_ptr_array_unref(
        entities
    );
    g_ptr_array_unref(evidences);
    g_ptr_array_unref(relation_types);
}

/**
 * @brief Enregistre le statut d'intégrité dans l'enquête d'origine.
 *
 * Une connexion indépendante est utilisée afin que la bonne base soit
 * mise à jour même si l'utilisateur a changé d'enquête entre-temps.
 */
static gboolean application_persist_evidence_integrity_status(
    const ApplicationEvidenceIntegrityContext *context,
    EvidenceIntegrityStatus integrity_status,
    GError **error
)
{
    Database *database =
        NULL;

    EvidenceDao *evidence_dao =
        NULL;

    gboolean updated =
        FALSE;

    g_return_val_if_fail(
        error == NULL || *error == NULL,
        FALSE
    );

    if (context == NULL ||
        context->database_path == NULL ||
        context->database_path[0] == '\0' ||
        context->evidence_identifier == NULL ||
        !g_uuid_string_is_valid(
            context->evidence_identifier
        ))
    {
        g_set_error_literal(
            error,
            APPLICATION_OPEN_ERROR,
            APPLICATION_OPEN_ERROR_EVIDENCE,
            "Le contexte de mise à jour de l'intégrité est invalide."
        );

        return FALSE;
    }

    database =
        database_open(
            context->database_path
        );

    if (database == NULL)
    {
        g_set_error(
            error,
            APPLICATION_OPEN_ERROR,
            APPLICATION_OPEN_ERROR_EVIDENCE,
            "Impossible d'ouvrir la base SQLite : %s",
            context->database_path
        );

        return FALSE;
    }

    evidence_dao =
        evidence_dao_new(
            database,
            error
        );

    if (evidence_dao == NULL)
    {
        database_close(
            database
        );

        return FALSE;
    }

    updated =
        evidence_dao_update_integrity_status(
            evidence_dao,
            context->evidence_identifier,
            integrity_status,
            error
        );

    evidence_dao_free(
        evidence_dao
    );

    database_close(
        database
    );

    return updated;
}

/**
 * @brief Traite la fin d'une vérification d'intégrité.
 */
static void application_on_evidence_integrity_completed(
    BackgroundTask *task,
    gpointer user_data
)
{
    ApplicationEvidenceIntegrityContext *context =
        user_data;

    Application *application =
        NULL;

    const EvidenceIntegrityVerificationResult *result =
        NULL;

    EvidenceIntegrityStatus integrity_status =
        EVIDENCE_INTEGRITY_STATUS_ERROR;

    BackgroundTaskState task_state;

    const char *diagnostic =
        NULL;

    const char *display_name =
        NULL;

    char *status_message =
        NULL;

    GError *error =
        NULL;

    GError *refresh_error =
        NULL;

    gboolean session_matches =
        FALSE;

    gboolean evidence_was_selected =
        FALSE;

    if (task == NULL ||
        context == NULL)
    {
        return;
    }

    application =
        context->application;

    if (application == NULL)
    {
        return;
    }

    task_state =
        background_task_get_state(
            task
        );

    session_matches =
        application_session_matches_root(
            application,
            context->investigation_root_path
        );

    display_name =
        context->original_name != NULL &&
        context->original_name[0] != '\0'
            ? context->original_name
            : context->evidence_identifier;

    if (task_state ==
        BACKGROUND_TASK_STATE_COMPLETED)
    {
        result =
            background_task_get_result(
                task
            );

        if (result == NULL)
        {
            if (session_matches)
            {
                application_present_error(
                    application,
                    "Vérification incomplète",
                    "La tâche s'est terminée sans fournir de résultat."
                );
            }

            return;
        }

        integrity_status =
            evidence_integrity_verification_result_get_status(
                result
            );

        /*
         * UNKNOWN après une vérification complète serait incohérent.
         */
        if (integrity_status ==
            EVIDENCE_INTEGRITY_STATUS_UNKNOWN)
        {
            integrity_status =
                EVIDENCE_INTEGRITY_STATUS_ERROR;
        }

        diagnostic =
            evidence_integrity_verification_result_get_diagnostic(
                result
            );

        if (!application_persist_evidence_integrity_status(
                context,
                integrity_status,
                &error
            ))
        {
            g_warning(
                "Impossible d'enregistrer le statut de la preuve '%s' : %s",
                context->evidence_identifier,
                error != NULL
                    ? error->message
                    : "erreur inconnue"
            );

            if (session_matches)
            {
                application_present_error(
                    application,
                    "Statut non enregistré",
                    error != NULL
                        ? error->message
                        : "Le résultat n'a pas pu être enregistré."
                );
            }

            g_clear_error(
                &error
            );

            return;
        }

        if (session_matches)
        {
            /*
             * La reconstruction du modèle peut provoquer temporairement
             * une sélection vide. On mémorise donc l'état avant celle-ci.
             */
            evidence_was_selected =
                g_strcmp0(
                    application->selected_evidence_identifier,
                    context->evidence_identifier
                ) == 0;

            if (!application_refresh_evidence_models(
                    application,
                    &refresh_error
                ))
            {
                g_warning(
                    "Le statut a été enregistré, mais la liste "
                    "des preuves n'a pas été actualisée : %s",
                    refresh_error != NULL
                        ? refresh_error->message
                        : "erreur inconnue"
                );
            }

            g_clear_error(
                &refresh_error
            );

            /*
             * On ne force pas l'affichage d'une ancienne preuve lorsque
             * l'utilisateur en a sélectionné une autre entre-temps.
             */
            if (evidence_was_selected)
            {
                application_on_evidence_selected(
                    context->evidence_identifier,
                    application
                );
            }

            switch (integrity_status)
            {
                case EVIDENCE_INTEGRITY_STATUS_VALID:
                    status_message =
                        g_strdup_printf(
                            "Intégrité valide : %s",
                            display_name
                        );

                    break;

                case EVIDENCE_INTEGRITY_STATUS_MODIFIED:
                    status_message =
                        g_strdup_printf(
                            "Alerte d'intégrité — fichier modifié : %s",
                            display_name
                        );

                    break;

                case EVIDENCE_INTEGRITY_STATUS_MISSING:
                    status_message =
                        g_strdup_printf(
                            "Preuve absente du disque : %s",
                            display_name
                        );

                    break;

                case EVIDENCE_INTEGRITY_STATUS_ERROR:
                case EVIDENCE_INTEGRITY_STATUS_UNKNOWN:
                default:
                    status_message =
                        g_strdup_printf(
                            "Erreur de vérification : %s",
                            display_name
                        );

                    break;
            }

            main_window_set_status(
                application->main_window,
                status_message
            );

            if (integrity_status ==
                    EVIDENCE_INTEGRITY_STATUS_ERROR &&
                diagnostic != NULL &&
                diagnostic[0] != '\0')
            {
                application_present_error(
                    application,
                    "Vérification impossible",
                    diagnostic
                );
            }
        }

        g_message(
            "Vérification de '%s' terminée avec le statut %d.",
            context->evidence_identifier,
            (int) integrity_status
        );

        g_free(
            status_message
        );

        return;
    }

    if (task_state ==
        BACKGROUND_TASK_STATE_CANCELLED)
    {
        if (session_matches)
        {
            main_window_set_status(
                application->main_window,
                "Vérification d'intégrité annulée."
            );
        }

        return;
    }

    error =
        background_task_dup_error(
            task
        );

    g_warning(
        "La vérification de la preuve '%s' a échoué : %s",
        context->evidence_identifier,
        error != NULL
            ? error->message
            : "erreur inconnue"
    );

    if (session_matches)
    {
        application_present_error(
            application,
            "Vérification impossible",
            error != NULL
                ? error->message
                : "La vérification n'a pas pu être exécutée."
        );
    }

    g_clear_error(
        &error
    );
}

/**
 * @brief Charge la preuve et démarre sa vérification asynchrone.
 */
static void application_start_evidence_integrity_verification(
    Application *application,
    const char *evidence_identifier
)
{
    const InvestigationProject *project =
        NULL;

    Database *database =
        NULL;

    EvidenceDao *evidence_dao =
        NULL;

    EvidenceRecord *evidence_record =
        NULL;

    ApplicationEvidenceIntegrityContext *context =
        NULL;

    EvidenceIntegrityTaskRequest request =
        {0};

    BackgroundTask *task =
        NULL;

    const char *root_path =
        NULL;

    const char *database_path =
        NULL;

    const char *relative_path =
        NULL;

    const char *expected_sha256 =
        NULL;

    const char *original_name =
        NULL;

    char *status_message =
        NULL;

    GError *error =
        NULL;

    if (application == NULL ||
        application->main_window == NULL ||
        application->session == NULL ||
        application->task_manager == NULL ||
        evidence_identifier == NULL ||
        !g_uuid_string_is_valid(
            evidence_identifier
        ))
    {
        return;
    }

    project =
        investigation_session_get_project(
            application->session
        );

    database =
        investigation_session_get_database(
            application->session
        );

    if (project == NULL ||
        database == NULL)
    {
        application_present_error(
            application,
            "Vérification impossible",
            "La session d'enquête est invalide."
        );

        return;
    }

    root_path =
        investigation_project_get_root_path(
            project
        );

    database_path =
        investigation_project_get_database_path(
            project
        );

    if (root_path == NULL ||
        root_path[0] == '\0' ||
        database_path == NULL ||
        database_path[0] == '\0')
    {
        application_present_error(
            application,
            "Vérification impossible",
            "Les chemins de l'enquête sont invalides."
        );

        return;
    }

    evidence_dao =
        evidence_dao_new(
            database,
            &error
        );

    if (evidence_dao == NULL)
    {
        application_present_error(
            application,
            "Vérification impossible",
            error != NULL
                ? error->message
                : "Impossible d'accéder aux preuves."
        );

        g_clear_error(
            &error
        );

        return;
    }

    evidence_record =
        evidence_dao_find_by_identifier(
            evidence_dao,
            evidence_identifier,
            &error
        );

    evidence_dao_free(
        evidence_dao
    );

    evidence_dao =
        NULL;

    if (error != NULL)
    {
        application_present_error(
            application,
            "Vérification impossible",
            error->message
        );

        g_clear_error(
            &error
        );

        return;
    }

    if (evidence_record == NULL)
    {
        application_present_error(
            application,
            "Preuve introuvable",
            "La preuve n'existe plus dans la base SQLite."
        );

        return;
    }

    relative_path =
        evidence_record_get_relative_path(
            evidence_record
        );

    expected_sha256 =
        evidence_record_get_sha256(
            evidence_record
        );

    original_name =
        evidence_record_get_original_name(
            evidence_record
        );

    if (relative_path == NULL ||
        relative_path[0] == '\0' ||
        expected_sha256 == NULL ||
        expected_sha256[0] == '\0')
    {
        application_present_error(
            application,
            "Vérification impossible",
            "La preuve ne contient pas les données nécessaires."
        );

        evidence_record_free(
            evidence_record
        );

        return;
    }

    context =
        g_try_new0(
            ApplicationEvidenceIntegrityContext,
            1
        );

    if (context == NULL)
    {
        application_present_error(
            application,
            "Vérification impossible",
            "Impossible d'allouer le contexte de la tâche."
        );

        evidence_record_free(
            evidence_record
        );

        return;
    }

    context->application =
        application;

    context->investigation_root_path =
        g_strdup(
            root_path
        );

    context->database_path =
        g_strdup(
            database_path
        );

    context->evidence_identifier =
        g_strdup(
            evidence_identifier
        );

    context->original_name =
        g_strdup(
            original_name
        );

    if (context->investigation_root_path == NULL ||
        context->database_path == NULL ||
        context->evidence_identifier == NULL)
    {
        application_evidence_integrity_context_free(
            context
        );

        evidence_record_free(
            evidence_record
        );

        application_present_error(
            application,
            "Vérification impossible",
            "Impossible de copier les paramètres de la tâche."
        );

        return;
    }

    request.investigation_root_path =
        root_path;

    request.relative_path =
        relative_path;

    request.expected_sha256 =
        expected_sha256;

    task =
        evidence_integrity_task_start(
            application->task_manager,
            &request,
            application_on_evidence_integrity_completed,
            context,
            application_evidence_integrity_context_free,
            &error
        );

    if (task == NULL)
    {
        /*
         * La propriété du contexte n'a pas été transférée.
         */
        application_evidence_integrity_context_free(
            context
        );

        application_present_error(
            application,
            "Vérification impossible",
            error != NULL
                ? error->message
                : "La tâche n'a pas pu être démarrée."
        );

        g_clear_error(
            &error
        );

        evidence_record_free(
            evidence_record
        );

        return;
    }

    /*
     * BackgroundTask et TaskManager possèdent désormais leurs références.
     */
    background_task_unref(
        task
    );

    status_message =
        g_strdup_printf(
            "Vérification en cours : %s",
            original_name != NULL &&
            original_name[0] != '\0'
                ? original_name
                : evidence_identifier
        );

    main_window_set_status(
        application->main_window,
        status_message
    );

    g_free(
        status_message
    );

    evidence_record_free(
        evidence_record
    );
}

/**
 * @brief Reçoit la demande de vérification d'une preuve.
 *
 * Cette première étape valide uniquement le relais de l'interface.
 * Le lancement de la tâche sera ajouté ensuite.
 *
 * @param evidence_identifier UUID de la preuve.
 * @param user_data Pointeur vers Application.
 */
/**
 * @brief Traite la demande de vérification provenant du Workspace.
 */
static void application_on_verify_evidence_requested(
    const char *evidence_identifier,
    gpointer user_data
)
{
    Application *application =
        user_data;

    application_start_evidence_integrity_verification(
        application,
        evidence_identifier
    );
}

/**
 * @brief Ferme proprement l'application.
 *
 * @param user_data Pointeur vers Application.
 */
/**
 * @brief Enregistre la nouvelle position logique d'un nœud.
 *
 * Le modèle en mémoire est mis à jour avant l'UPSERT SQLite. En cas d'échec
 * SQLite, le déplacement reste visible pendant la session, mais un message
 * explicite indique qu'il ne survivra pas à la réouverture de l'enquête.
 */
static void application_on_graph_node_moved(
    const char *entity_identifier,
    double x,
    double y,
    gpointer user_data
)
{
    Application *application =
        user_data;

    Database *database =
        NULL;

    GraphNodePositionDao *position_dao =
        NULL;

    GError *error =
        NULL;

    if (application == NULL ||
        application->main_window == NULL ||
        application->session == NULL ||
        application->graph_layout == NULL ||
        entity_identifier == NULL ||
        !g_uuid_string_is_valid(
            entity_identifier
        ))
    {
        return;
    }

    if (!investigation_graph_layout_set_position(
            application->graph_layout,
            entity_identifier,
            x,
            y,
            &error
        ))
    {
        g_warning(
            "Impossible de mettre à jour la position du nœud '%s' : %s",
            entity_identifier,
            error != NULL
                ? error->message
                : "erreur inconnue"
        );

        application_present_error(
            application,
            "Position invalide",
            error != NULL
                ? error->message
                : "La position du nœud ne peut pas être conservée."
        );

        g_clear_error(
            &error
        );

        return;
    }

    database =
        investigation_session_get_database(
            application->session
        );

    if (database == NULL)
    {
        main_window_set_status(
            application->main_window,
            "Nœud déplacé, mais position non enregistrée."
        );

        application_present_error(
            application,
            "Enregistrement impossible",
            "La session ne fournit aucune connexion SQLite."
        );

        return;
    }

    position_dao =
        graph_node_position_dao_new(
            database,
            &error
        );

    if (position_dao == NULL)
    {
        g_warning(
            "Impossible de créer le DAO des positions : %s",
            error != NULL
                ? error->message
                : "erreur inconnue"
        );

        main_window_set_status(
            application->main_window,
            "Nœud déplacé, mais position non enregistrée."
        );

        application_present_error(
            application,
            "Enregistrement impossible",
            error != NULL
                ? error->message
                : "Impossible d'accéder aux positions du graphe."
        );

        g_clear_error(
            &error
        );

        return;
    }

    if (!graph_node_position_dao_upsert(
            position_dao,
            entity_identifier,
            x,
            y,
            &error
        ))
    {
        g_warning(
            "Impossible d'enregistrer la position du nœud '%s' : %s",
            entity_identifier,
            error != NULL
                ? error->message
                : "erreur inconnue"
        );

        main_window_set_status(
            application->main_window,
            "Nœud déplacé, mais position non enregistrée."
        );

        application_present_error(
            application,
            "Enregistrement impossible",
            error != NULL
                ? error->message
                : "La position du nœud n'a pas pu être enregistrée."
        );

        g_clear_error(
            &error
        );

        graph_node_position_dao_free(
            position_dao
        );

        return;
    }

    graph_node_position_dao_free(
        position_dao
    );

    main_window_set_status(
        application->main_window,
        "Position du nœud enregistrée."
    );
}

/**
 * @brief Supprime les positions persistées et restaure la grille automatique.
 *
 * Cette fonction est appelée uniquement après une confirmation explicite.
 * L'affichage et le modèle en mémoire restent inchangés en cas d'échec SQLite.
 */
static void application_reset_graph_layout(
    Application *application
)
{
    Database *database =
        NULL;

    GraphNodePositionDao *position_dao =
        NULL;

    GError *error =
        NULL;

    if (application == NULL ||
        application->main_window == NULL ||
        application->session == NULL ||
        application->graph_model == NULL ||
        application->graph_layout == NULL)
    {
        return;
    }

    database =
        investigation_session_get_database(
            application->session
        );

    if (database == NULL)
    {
        application_present_error(
            application,
            "Réinitialisation impossible",
            "La session ne fournit aucune connexion SQLite."
        );

        return;
    }

    position_dao =
        graph_node_position_dao_new(
            database,
            &error
        );

    if (position_dao == NULL)
    {
        g_warning(
            "Impossible de créer le DAO des positions : %s",
            error != NULL
                ? error->message
                : "erreur inconnue"
        );

        application_present_error(
            application,
            "Réinitialisation impossible",
            error != NULL
                ? error->message
                : "Impossible d'accéder aux positions enregistrées."
        );

        g_clear_error(
            &error
        );

        return;
    }

    if (!graph_node_position_dao_delete_all(
            position_dao,
            &error
        ))
    {
        g_warning(
            "Impossible de supprimer les positions du graphe : %s",
            error != NULL
                ? error->message
                : "erreur inconnue"
        );

        application_present_error(
            application,
            "Réinitialisation impossible",
            error != NULL
                ? error->message
                : "Les positions enregistrées n'ont pas pu être supprimées."
        );

        g_clear_error(
            &error
        );

        graph_node_position_dao_free(
            position_dao
        );

        return;
    }

    graph_node_position_dao_free(
        position_dao
    );

    investigation_graph_layout_clear(
        application->graph_layout
    );

    main_window_reset_graph_layout(
        application->main_window
    );

    main_window_set_status(
        application->main_window,
        "Disposition du graphe réinitialisée."
    );
}

/**
 * @brief Traite la réponse du dialogue de confirmation.
 */
static void application_on_reset_graph_layout_confirmed(
    gboolean confirmed,
    gpointer user_data
)
{
    Application *application =
        user_data;

    if (!confirmed)
    {
        return;
    }

    application_reset_graph_layout(
        application
    );
}

/**
 * @brief Demande confirmation avant toute suppression de position.
 */
static void application_on_show_graph_requested(
    gpointer user_data
)
{
    Application *application =
        user_data;

    if (application == NULL ||
        application->main_window == NULL ||
        application->graph_model == NULL)
    {
        return;
    }

    application_set_selected_evidence_identifier(
        application,
        NULL
    );

    /*
     * Passer NULL restaure l'état principal du Workspace. Quand le graphe
     * est prêt, workspace_show_default() affiche automatiquement le canvas.
     */
    main_window_set_selected_evidence(
        application->main_window,
        NULL
    );

    main_window_set_status(
        application->main_window,
        "Graphe de l'enquête affiché."
    );
}

/**
 * @brief Demande confirmation avant toute suppression de position.
 */
static void application_on_reset_graph_layout_requested(
    gpointer user_data
)
{
    Application *application =
        user_data;

    if (application == NULL ||
        application->main_window == NULL ||
        application->session == NULL ||
        application->graph_model == NULL ||
        application->graph_layout == NULL)
    {
        return;
    }

    application_message_dialog_present_confirmation(
        main_window_get_window(
            application->main_window
        ),
        APPLICATION_MESSAGE_DIALOG_WARNING,
        "Réinitialiser la disposition du graphe",
        "Toutes les positions personnalisées des nœuds seront supprimées. "
        "Le graphe retrouvera sa disposition automatique.\n\n"
        "Cette action ne peut pas être annulée.",
        "Réinitialiser",
        application_on_reset_graph_layout_confirmed,
        application
    );
}

static void application_on_observation_remove_confirmed(
    gboolean confirmed, gpointer user_data)
{
    ApplicationObservationRemovalContext *context = user_data;
    Application *application = context != NULL ? context->application : NULL;
    GError *error = NULL; gboolean deleted = FALSE, shared = FALSE;
    if (!confirmed || application == NULL || application->session == NULL)
    { application_observation_removal_context_free(context); return; }
    if (!eml_integration_remove_promotion(
            investigation_session_get_database(application->session),
            context->observation_identifier, &deleted, &shared, &error))
        application_present_error(application, "Retrait du graphe impossible",
            error != NULL ? error->message : "La transaction a échoué.");
    else
    {
        if (deleted)
        {
            const InvestigationProject *project =
                investigation_session_get_project(application->session);
            application_start_graph_loading(application,
                investigation_project_get_database_path(project));
        }
        char *selected_evidence = g_strdup(
            application->selected_evidence_identifier);
        application_on_evidence_selected(selected_evidence, application);
        g_free(selected_evidence);
        main_window_set_status(application->main_window,
            deleted ? "Observation conservée et nœud orphelin supprimé." :
            shared ? "Observation détachée ; entité partagée conservée." :
            "Observation retirée du graphe.");
    }
    g_clear_error(&error);
    application_observation_removal_context_free(context);
}

static void application_on_observation_remove_requested(
    const char *observation_identifier, gpointer user_data)
{
    Application *application = user_data;
    if (application == NULL ||
        !g_uuid_string_is_valid(observation_identifier)) return;
    ApplicationObservationRemovalContext *context =
        g_new0(ApplicationObservationRemovalContext, 1);
    context->application = application;
    context->observation_identifier = g_strdup(observation_identifier);
    application_message_dialog_present_confirmation(
        main_window_get_window(application->main_window),
        APPLICATION_MESSAGE_DIALOG_WARNING, "Retirer du graphe",
        "L’observation restera dans la fiche. Le nœud sera supprimé "
        "uniquement s’il n’est utilisé par aucune autre preuve, observation "
        "ou relation.", "Retirer du graphe",
        application_on_observation_remove_confirmed, context);
}

/**
 * @brief Ferme proprement l'application.
 *
 * @param user_data Pointeur vers Application.
 */
static void application_on_quit_requested(
    gpointer user_data
)
{
    Application *application = user_data;

    if (application == NULL ||
        application->gtk_application == NULL)
    {
        return;
    }

    task_manager_cancel_all(
        application->task_manager
    );

    g_application_quit(
        G_APPLICATION(
            application->gtk_application
        )
    );
}

/**
 * @brief Crée la fenêtre principale lors de l'activation.
 *
 * Le signal activate peut être reçu plusieurs fois. Si la fenêtre existe
 * déjà, elle est simplement présentée.
 *
 * @param gtk_application Application GTK ayant reçu le signal.
 * @param user_data Pointeur vers Application.
 */
static void application_on_activate(
    GtkApplication *gtk_application,
    gpointer user_data
)
{
    Application *application = user_data;

    if (application == NULL)
    {
        return;
    }

    if (application->main_window != NULL)
    {
        main_window_present(
            application->main_window
        );

        return;
    }

    application->main_window = main_window_new(
        gtk_application,
        application->task_manager
    );

    if (application->main_window == NULL)
    {
        g_warning(
            "Impossible de créer la fenêtre principale."
        );

        return;
    }

    main_window_set_tree_selection_callback(
        application->main_window,
        application_on_tree_node_selected,
        application
    );

    main_window_set_evidence_selection_callback(
        application->main_window,
        application_on_evidence_selected,
        application
    );
    main_window_set_observation_remove_callback(application->main_window,
        application_on_observation_remove_requested, application);

    main_window_set_verify_evidence_callback(
        application->main_window,
        application_on_verify_evidence_requested,
        application
    );

    main_window_set_edit_evidence_callback(
        application->main_window,
        application_on_edit_evidence_requested,
        application
    );
    main_window_set_analyze_eml_callback(application->main_window,
        application_on_analyze_eml_requested, application);
    main_window_set_analyze_rib_callback(application->main_window,
        application_on_analyze_rib_requested, application);
    main_window_set_extract_metadata_callback(application->main_window,
        application_on_extract_metadata_requested, application);
    main_window_set_recover_pdf_password_callback(application->main_window,
        application_on_recover_pdf_password_requested, application);

    main_window_set_graph_node_moved_callback(
        application->main_window,
        application_on_graph_node_moved,
        application
    );
    main_window_set_graph_transform_changed_callback(
        application->main_window,
        application_on_graph_transform_changed,
        application);
    main_window_set_extraction_drop_callback(
        application->main_window, application_on_extraction_dropped,
        application);

    main_window_set_reset_graph_layout_callback(
        application->main_window,
        application_on_reset_graph_layout_requested,
        application
    );

    main_window_set_show_graph_callback(
        application->main_window,
        application_on_show_graph_requested,
        application
    );

    main_window_set_add_relation_callback(
        application->main_window,
        application_on_add_relation_requested,
        application
    );

    main_window_set_edit_relation_callback(application->main_window,
        application_on_edit_relation_requested, application);
    main_window_set_delete_relation_callback(application->main_window,
        application_on_delete_relation_requested, application);
    main_window_set_relation_selected_callback(application->main_window,
        application_on_relation_selected, application);
    main_window_set_person_role_callback(application->main_window,
        application_on_person_role_changed, application);
    main_window_set_person_confidence_callback(application->main_window,
        application_on_person_confidence_changed, application);
    main_window_set_person_name_callback(application->main_window,
        application_on_person_name_changed, application);
    main_window_set_person_evidence_callback(application->main_window,
        application_on_person_evidence_requested, application);
    main_window_set_entity_selected_callback(application->main_window,
        application_on_entity_selected, application);

    main_window_set_osint_action_callback(
        application->main_window,
        application_on_osint_action_requested,
        application
    );

    main_window_set_new_investigation_callback(
        application->main_window,
        application_on_new_investigation_requested,
        application
    );

    main_window_set_open_investigation_callback(
        application->main_window,
        application_on_open_investigation_requested,
        application
    );

    main_window_set_import_evidence_callback(
        application->main_window,
        application_on_import_evidence_requested,
        application
    );

    main_window_set_add_social_account_callback(
        application->main_window,
        application_on_add_social_account_requested,
        application
    );
    main_window_set_add_person_callback(application->main_window,
        application_on_add_person_requested, application);

    main_window_set_import_evidence_enabled(
        application->main_window,
        application->session != NULL
    );

    main_window_set_add_social_account_enabled(
        application->main_window,
        application->session != NULL
    );
    main_window_set_add_person_enabled(application->main_window,
        application->session != NULL);

    main_window_set_quit_callback(
        application->main_window,
        application_on_quit_requested,
        application
    );

    main_window_present(
        application->main_window
    );

    /*
     * Le démarrage est non bloquant. Le worker s’exécute dans un
     * thread secondaire et sa progression apparaît dans TaskPanel.
     */
    application_start_tool_initialization(
        application
    );
}

/** @brief Ajoute le répertoire privé des outils OSINT au PATH du processus. */
static void application_prepare_osint_tool_path(void)
{
    const char *current_path = g_getenv("PATH");
    const char *home_directory = g_get_home_dir();
    char *osint_directory = NULL;
    char *new_path = NULL;

    if (home_directory == NULL || home_directory[0] == '\0') return;
    osint_directory = g_build_filename(home_directory, ".local", "share",
        "labfy-osint", "bin", NULL);
    if (!g_file_test(osint_directory, G_FILE_TEST_IS_DIR))
    {
        g_free(osint_directory);
        return;
    }
    if (current_path != NULL && g_strstr_len(current_path, -1,
            osint_directory) != NULL)
    {
        g_free(osint_directory);
        return;
    }
    new_path = g_strdup_printf("%s%s%s", osint_directory,
        current_path != NULL && current_path[0] != '\0' ? G_SEARCHPATH_SEPARATOR_S :
        "", current_path != NULL ? current_path : "");
    g_setenv("PATH", new_path, TRUE);
    g_free(new_path);
    g_free(osint_directory);
}

Application *application_new(void)
{
    Application *application = NULL;
    GError *error = NULL;

    application = g_new0(
        Application,
        1
    );

    application_prepare_osint_tool_path();

    application->task_manager =
        task_manager_new();

    if (application->task_manager == NULL)
    {
        g_free(
            application
        );

        return NULL;
    }

    application->tool_initializer =
        tool_initializer_new(
            application->task_manager,
            &error
        );

    if (application->tool_initializer == NULL)
    {
        g_warning(
            "Impossible de créer l’initialiseur des outils : %s",
            error != NULL
            ? error->message
            : "erreur inconnue"
        );

        g_clear_error(
            &error
        );

        task_manager_free(
            application->task_manager
        );

        g_free(
            application
        );

        return NULL;
    }

    tool_initializer_set_completed_callback(
        application->tool_initializer,
        application_on_tool_initialization_completed,
        application,
        NULL
    );

    application->gtk_application = gtk_application_new(
        APPLICATION_ID,
        G_APPLICATION_DEFAULT_FLAGS
    );

    if (application->gtk_application == NULL)
    {
        tool_initializer_free(
            application->tool_initializer
        );

        task_manager_free(
            application->task_manager
        );

        g_free(
            application
        );

        return NULL;
    }

    g_signal_connect(
        application->gtk_application,
        "activate",
        G_CALLBACK(application_on_activate),
        application
    );

    return application;
}

int application_run(
    Application *application,
    int argc,
    char **argv
)
{
    if (application == NULL ||
        application->gtk_application == NULL)
    {
        return 1;
    }

    return g_application_run(
        G_APPLICATION(
            application->gtk_application
        ),
        argc,
        argv
    );
}

const InvestigationSession *application_get_session(
    const Application *application
)
{
    if (application == NULL)
    {
        return NULL;
    }

    return application->session;
}

void application_free(
    Application *application
)
{
    if (application == NULL)
    {
        return;
    }

    if (application->tool_initializer != NULL)
    {
        tool_initializer_set_completed_callback(
            application->tool_initializer,
            NULL,
            NULL,
            NULL
        );
    }

    task_manager_cancel_all(
        application->task_manager
    );

    application_cancel_graph_loading(
        application
    );

    if (application->graph_viewport_save_source_id != 0U)
    {
        g_source_remove(application->graph_viewport_save_source_id);
        application->graph_viewport_save_source_id = 0U;
    }
    application_save_graph_viewport(application);

    application_clear_graph(
        application
    );

    investigation_tree_model_free(
        application->tree_model
    );

    investigation_session_close(
        application->session
    );

    if (application->main_window != NULL)
    {
        main_window_set_evidence_model(
            application->main_window,
            NULL
        );
    }

    evidence_category_model_free(
        application->evidence_category_model
    );

    evidence_list_model_free(
        application->evidence_list_model
    );

    /*
     * MainWindow contient TaskPanel.
     * Il doit être détruit avant TaskManager.
     */
    main_window_free(
        application->main_window
    );

    /*
     * ToolInitializer emprunte TaskManager.
     * Il doit être libéré avant celui-ci.
     */
    tool_initializer_free(
        application->tool_initializer
    );

    task_manager_free(
        application->task_manager
    );

    if (application->gtk_application != NULL)
    {
        g_object_unref(
            application->gtk_application
        );
    }

    g_clear_pointer(
        &application->selected_evidence_identifier,
        g_free
    );
    g_clear_pointer(&application->pending_relation_selection_identifier,
        g_free);
    g_clear_pointer(&application->pending_entity_selection_identifier, g_free);

    g_free(
        application
    );
}