def register_info_modal_callbacks(app):
    """
    Register info modal callbacks with Dash app.

    Parameters
    ----------
    app : Dash
        Dash application instance

    Notes
    -----
    Registered Callbacks:
    1. Toggle modal (open button, close button, backdrop click)

    Behavior:
    - Modal opens when "More Info" button is clicked
    - Modal closes when X button is clicked or when clicking outside
    - Modal is extra-large and vertically centered

    See Also
    --------
    create_info_modal : Modal component
    create_intro_card : Intro card with More Info button
    """
    global _info_modal_callbacks_registered

    # Prevent duplicate registration
    if _info_modal_callbacks_registered:
        logger.warning(
            "[INFO_MODAL] Callbacks already registered, skipping duplicate registration"
        )
        return

    logger.info("[INFO_MODAL] Registering info modal callbacks...")

    # ========================================
    # Callback: Toggle Modal Open/Close
    # ========================================
    @app.callback(
        Output("info-modal", "is_open"),
        [
            Input("info-modal-open-button", "n_clicks"),
            Input("info-modal-close-button", "n_clicks"),
        ],
        State("info-modal", "is_open"),
        prevent_initial_call=True,
    )
    def toggle_info_modal(open_clicks, close_clicks, is_open):
        """
        Toggle info modal open/close state.

        Parameters
        ----------
        open_clicks : int
            Number of open button clicks
        close_clicks : int
            Number of close button clicks
        is_open : bool
            Current modal state

        Returns
        -------
        bool
            New modal state (toggled based on which button was clicked)

        Notes
        -----
        - Uses ctx.triggered_id to determine which button was clicked
        - Open button opens the modal
        - Close button closes the modal
        - Backdrop click automatically closes (handled by dbc.Modal backdrop=True)
        """
        logger.info("=" * 80)
        logger.info(f"[INFO_MODAL-{_callback_instance_id}] TOGGLE_INFO_MODAL CALLED")
        logger.info(
            f"[INFO_MODAL-{_callback_instance_id}]   Input open_clicks: {open_clicks}"
        )
        logger.info(
            f"[INFO_MODAL-{_callback_instance_id}]   Input close_clicks: {close_clicks}"
        )
        logger.info(f"[INFO_MODAL-{_callback_instance_id}]   State is_open: {is_open}")
        logger.info(
            f"[INFO_MODAL-{_callback_instance_id}]   ctx.triggered: {ctx.triggered}"
        )
        logger.info(
            f"[INFO_MODAL-{_callback_instance_id}]   ctx.triggered_id: {ctx.triggered_id}"
        )

        if not ctx.triggered_id:
            logger.warning(
                f"[INFO_MODAL-{_callback_instance_id}] No triggered_id, returning no_update"
            )
            logger.info("=" * 80)
            return no_update

        # Determine action based on which button was clicked
        if ctx.triggered_id == "info-modal-open-button":
            new_state = True
            logger.info(
                f"[INFO_MODAL-{_callback_instance_id}] OPEN BUTTON CLICKED: "
                f"Setting modal to OPEN (clicks={open_clicks})"
            )
        elif ctx.triggered_id == "info-modal-close-button":
            new_state = False
            logger.info(
                f"[INFO_MODAL-{_callback_instance_id}] CLOSE BUTTON CLICKED: "
                f"Setting modal to CLOSED (clicks={close_clicks})"
            )
        else:
            logger.warning(
                f"[INFO_MODAL-{_callback_instance_id}] Unknown trigger: {ctx.triggered_id}, "
                f"returning current state"
            )
            new_state = is_open

        logger.info(f"[INFO_MODAL-{_callback_instance_id}] RETURNING: {new_state}")
        logger.info("=" * 80)
        return new_state

    # ========================================
    # Callback: Toggle Sample Data Modal Open/Close
    # ========================================
    @app.callback(
        Output("sample-data-modal", "is_open"),
        [
            Input("sample-data-card", "n_clicks"),
            Input("sample-data-modal-close-button", "n_clicks"),
        ],
        State("sample-data-modal", "is_open"),
        prevent_initial_call=True,
    )
    def toggle_sample_data_modal(card_clicks, close_clicks, is_open):
        """
        Toggle sample data modal open/close state.

        Parameters
        ----------
        card_clicks : int
            Number of card clicks
        close_clicks : int
            Number of close button clicks
        is_open : bool
            Current modal state

        Returns
        -------
        bool
            New modal state (toggled based on which element was clicked)

        Notes
        -----
        - Uses ctx.triggered_id to determine which element was clicked
        - Card click opens the modal
        - Close button closes the modal
        - Backdrop click automatically closes (handled by dbc.Modal backdrop=True)
        """
        logger.info("=" * 80)
        logger.info(
            f"[SAMPLE_DATA_MODAL-{_callback_instance_id}] TOGGLE_SAMPLE_DATA_MODAL CALLED"
        )
        logger.info(
            f"[SAMPLE_DATA_MODAL-{_callback_instance_id}]   Input card_clicks: {card_clicks}"
        )
        logger.info(
            f"[SAMPLE_DATA_MODAL-{_callback_instance_id}]   Input close_clicks: {close_clicks}"
        )
        logger.info(
            f"[SAMPLE_DATA_MODAL-{_callback_instance_id}]   State is_open: {is_open}"
        )
        logger.info(
            f"[SAMPLE_DATA_MODAL-{_callback_instance_id}]   ctx.triggered: {ctx.triggered}"
        )
        logger.info(
            f"[SAMPLE_DATA_MODAL-{_callback_instance_id}]   ctx.triggered_id: {ctx.triggered_id}"
        )

        if not ctx.triggered_id:
            logger.warning(
                f"[SAMPLE_DATA_MODAL-{_callback_instance_id}] No triggered_id, returning no_update"
            )
            logger.info("=" * 80)
            return no_update

        # Determine action based on which element was clicked
        if ctx.triggered_id == "sample-data-card":
            new_state = True
            logger.info(
                f"[SAMPLE_DATA_MODAL-{_callback_instance_id}] CARD CLICKED: "
                f"Setting modal to OPEN (clicks={card_clicks})"
            )
        elif ctx.triggered_id == "sample-data-modal-close-button":
            new_state = False
            logger.info(
                f"[SAMPLE_DATA_MODAL-{_callback_instance_id}] CLOSE BUTTON CLICKED: "
                f"Setting modal to CLOSED (clicks={close_clicks})"
            )
        else:
            logger.warning(
                f"[SAMPLE_DATA_MODAL-{_callback_instance_id}] Unknown trigger: {ctx.triggered_id}, "
                f"returning current state"
            )
            new_state = is_open

        logger.info(
            f"[SAMPLE_DATA_MODAL-{_callback_instance_id}] RETURNING: {new_state}"
        )
        logger.info("=" * 80)
        return new_state

    # ========================================
    # Callback: Trigger sample data download
    # ========================================
    @app.callback(
        Output("sample-data-download", "data"),
        Input("sample-data-download-btn", "n_clicks"),
        prevent_initial_call=True,
    )
    def download_sample_data(n_clicks):
        """Download sample dataset file without URL navigation."""
        if not n_clicks:
            return no_update

        dataset_path = (
            Path(__file__).resolve().parents[3] / "data" / "exemple_dataset.txt"
        )
        if not dataset_path.exists():
            logger.error("[SAMPLE_DATA_MODAL] Sample dataset file not found")
            return no_update

        return dcc.send_file(str(dataset_path), "exemple_dataset.txt")

    # ========================================
    # Callback: Toggle Publications Modal Open/Close
    # ========================================
    @app.callback(
        Output("publications-modal", "is_open"),
        [
            Input("publications-card", "n_clicks"),
            Input("publications-modal-close-button", "n_clicks"),
        ],
        State("publications-modal", "is_open"),
        prevent_initial_call=True,
    )
    def toggle_publications_modal(card_clicks, close_clicks, is_open):
        """
        Toggle publications modal open/close state.

        Parameters
        ----------
        card_clicks : int
            Number of card clicks
        close_clicks : int
            Number of close button clicks
        is_open : bool
            Current modal state

        Returns
        -------
        bool
            New modal state (toggled based on which element was clicked)

        Notes
        -----
        - Uses ctx.triggered_id to determine which element was clicked
        - Card click opens the modal
        - Close button closes the modal
        - Backdrop click automatically closes (handled by dbc.Modal backdrop=True)
        """
        logger.info("=" * 80)
        logger.info(
            f"[PUBLICATIONS_MODAL-{_callback_instance_id}] TOGGLE_PUBLICATIONS_MODAL CALLED"
        )
        logger.info(
            f"[PUBLICATIONS_MODAL-{_callback_instance_id}]   Input card_clicks: {card_clicks}"
        )
        logger.info(
            f"[PUBLICATIONS_MODAL-{_callback_instance_id}]   Input close_clicks: {close_clicks}"
        )
        logger.info(
            f"[PUBLICATIONS_MODAL-{_callback_instance_id}]   State is_open: {is_open}"
        )
        logger.info(
            f"[PUBLICATIONS_MODAL-{_callback_instance_id}]   ctx.triggered: {ctx.triggered}"
        )
        logger.info(
            f"[PUBLICATIONS_MODAL-{_callback_instance_id}]   ctx.triggered_id: {ctx.triggered_id}"
        )

        if not ctx.triggered_id:
            logger.warning(
                f"[PUBLICATIONS_MODAL-{_callback_instance_id}] No triggered_id, returning no_update"
            )
            logger.info("=" * 80)
            return no_update

        # Determine action based on which element was clicked
        if ctx.triggered_id == "publications-card":
            new_state = True
            logger.info(
                f"[PUBLICATIONS_MODAL-{_callback_instance_id}] CARD CLICKED: "
                f"Setting modal to OPEN (clicks={card_clicks})"
            )
        elif ctx.triggered_id == "publications-modal-close-button":
            new_state = False
            logger.info(
                f"[PUBLICATIONS_MODAL-{_callback_instance_id}] CLOSE BUTTON CLICKED: "
                f"Setting modal to CLOSED (clicks={close_clicks})"
            )
        else:
            logger.warning(
                f"[PUBLICATIONS_MODAL-{_callback_instance_id}] Unknown trigger: {ctx.triggered_id}, "
                f"returning current state"
            )
            new_state = is_open

        logger.info(
            f"[PUBLICATIONS_MODAL-{_callback_instance_id}] RETURNING: {new_state}"
        )
        logger.info("=" * 80)
        return new_state

    # Mark callbacks as registered
    _info_modal_callbacks_registered = True
    logger.info("[INFO_MODAL] [OK] Info modal callbacks registered successfully")
    logger.info(f"[INFO_MODAL] [OK] Callback IDs registered:")
    logger.info(
        f"[INFO_MODAL]     - toggle_info_modal: Inputs=['info-modal-open-button', 'info-modal-close-button'], Output='info-modal.is_open'"
    )
    logger.info(
        f"[INFO_MODAL]     - toggle_sample_data_modal: Inputs=['sample-data-card', 'sample-data-modal-close-button'], Output='sample-data-modal.is_open'"
    )
    logger.info(
        "[INFO_MODAL]     - download_sample_data: Input='sample-data-download-btn', Output='sample-data-download.data'"
    )
    logger.info(
        f"[INFO_MODAL]     - toggle_publications_modal: Inputs=['publications-card', 'publications-modal-close-button'], Output='publications-modal.is_open'"
    )

def register_job_resume_callbacks(app):
    """Register callbacks related to resume-by-job-id flow."""
    logger.info("=" * 60)
    logger.info("Registering JOB RESUME callbacks...")
    logger.info("=" * 60)

    @app.callback(
        Output("resume-browser-token-store", "data"),
        Input("resume-browser-token-store", "modified_timestamp"),
        State("resume-browser-token-store", "data"),
    )
    @instrument_callback("resume.ensure_browser_token")
    def ensure_resume_browser_token(_, existing_token):
        token = initialize_resume_browser_token(existing_token)
        if token is no_update:
            raise PreventUpdate
        logger.info("Resume browser token initialized")
        return token

    @app.callback(
        [
            Output("merged-result-store", "data", allow_duplicate=True),
            Output("results-context-store", "data", allow_duplicate=True),
            Output("url", "pathname"),
            Output("url", "hash"),
            Output("resume-job-status", "children"),
        ],
        Input("resume-job-btn", "n_clicks"),
        [
            State("resume-job-id-input", "value"),
            State("resume-browser-token-store", "data"),
        ],
        prevent_initial_call=True,
    )
    @instrument_callback("resume.resume_job_by_id")
    def resume_job_by_id(n_clicks, job_id, owner_token):
        if n_clicks is None:
            raise PreventUpdate

        return resolve_resume_request(job_id, owner_token)

    logger.info("[OK] Job resume callbacks registered successfully")

def register_module1_callbacks(app, plot_service) -> None:
    """
    Register all Module 1 callbacks with Dash app.

    Parameters
    ----------
    app : Dash
        Dash application instance.
    plot_service : PlotService
        Singleton PlotService instance (shared across all callbacks).

    Notes
    -----
    - Registers callback handlers for Module 1 use cases
    - Refer to official documentation for supported use case details
    """
    logger.info("Starting Module 1 callback registration")

    try:
        # UC-1.1: Database Overlap and Unique Contributions
        logger.debug("Registering UC-1.1 callbacks...")
        register_uc_1_1_callbacks(app, plot_service)
        logger.info("[OK] UC-1.1 callbacks registered successfully")

        # UC-1.2: Regulatory Agency Compound Overlap
        logger.debug("Registering UC-1.2 callbacks...")
        register_uc_1_2_callbacks(app, plot_service)
        logger.info("[OK] UC-1.2 callbacks registered successfully")

        # UC-1.3: Proportional Contribution of Reference Agencies
        logger.debug("Registering UC-1.3 callbacks...")
        register_uc_1_3_callbacks(app, plot_service)
        logger.info("[OK] UC-1.3 callbacks registered successfully")

        # UC-1.4: Proportional Functional Diversity of Samples
        logger.debug("Registering UC-1.4 callbacks...")
        register_uc_1_4_callbacks(app, plot_service)
        logger.info("[OK] UC-1.4 callbacks registered successfully")

        # UC-1.5: Regulatory Compliance Scorecard
        logger.debug("Registering UC-1.5 callbacks...")
        register_uc_1_5_callbacks(app, plot_service)
        logger.info("[OK] UC-1.5 callbacks registered successfully")

        # UC-1.6: Sample-Agency Functional Potential Heatmap
        logger.debug("Registering UC-1.6 callbacks...")
        register_uc_1_6_callbacks(app, plot_service)
        logger.info("[OK] UC-1.6 callbacks registered successfully")

        logger.info("Module 1 callback registration complete")

    except Exception as e:
        logger.error(f"Failed to register Module 1 callbacks: {e}", exc_info=True)
        raise

def register_module2_callbacks(app, plot_service) -> None:
    """
    Register all Module 2 callbacks with Dash app.

    Parameters
    ----------
    app : Dash
        Dash application instance.
    plot_service : PlotService
        Singleton PlotService instance (shared across all callbacks).

    Notes
    -----
    - Registers callback handlers for Module 2 use cases
    - Refer to official documentation for supported use case details
    """
    logger.info("=" * 60)
    logger.info("REGISTERING MODULE 2 CALLBACKS...")
    logger.info("=" * 60)

    # Register UC-2.1: Ranking of Samples by KO Richness
    logger.info("→ Registering UC-2.1...")
    register_uc_2_1_callbacks(app, plot_service)
    logger.info("[OK] UC-2.1 callbacks registered (KO richness analysis)")

    # Register UC-2.2: Ranking of Samples by Compound Richness
    logger.info("→ Registering UC-2.2...")
    register_uc_2_2_callbacks(app, plot_service)
    logger.info("[OK] UC-2.2 callbacks registered (Compound richness analysis)")

    # Register UC-2.3: Ranking of Compounds by Sample Diversity per Class
    logger.info("→ Registering UC-2.3...")
    register_uc_2_3_callbacks(app, plot_service)
    logger.info("[OK] UC-2.3 callbacks registered (Compound-sample diversity)")

    # Register UC-2.4: Ranking of Compounds by Genetic Interaction per Class
    logger.info("→ Registering UC-2.4...")
    register_uc_2_4_callbacks(app, plot_service)
    logger.info("[OK] UC-2.4 callbacks registered (Compound-gene diversity)")

    # Register UC-2.5: Distribution of KO Across Samples
    logger.info("→ Registering UC-2.5...")
    register_uc_2_5_callbacks(app, plot_service)
    logger.info("[OK] UC-2.5 callbacks registered (KO distribution)")

    logger.info("=" * 60)
    logger.info("[OK] ALL MODULE 2 CALLBACKS REGISTERED SUCCESSFULLY")
    logger.info("=" * 60)

def register_module3_callbacks(app, plot_service) -> None:
    """
    Register all Module 3 callbacks with Dash app.

    Parameters
    ----------
    app : Dash
        Dash application instance.
    plot_service : PlotService
        Singleton PlotService instance (shared across all callbacks).

    Notes
    -----
    - Registers callback handlers for Module 3 use cases
    - Refer to official documentation for supported use case details
    """
    logger.info("=" * 60)
    logger.info("REGISTERING MODULE 3 CALLBACKS...")
    logger.info("=" * 60)

    # Register UC-3.1: PCA - Sample Relationships by KO Profile
    logger.info("→ Registering UC-3.1...")
    register_uc_3_1_callbacks(app, plot_service)
    logger.info("[OK] UC-3.1 callbacks registered (PCA - KO profile)")

    # Register UC-3.2: PCA - Sample Relationships by Chemical Profile
    logger.info("→ Registering UC-3.2...")
    register_uc_3_2_callbacks(app, plot_service)
    logger.info("[OK] UC-3.2 callbacks registered (PCA - Compound profile)")

    # Register UC-3.3: Interactive Hierarchical Clustering of Samples
    logger.info("→ Registering UC-3.3...")
    register_uc_3_3_callbacks(app, plot_service)
    logger.info("[OK] UC-3.3 callbacks registered (Hierarchical clustering)")

    # Register UC-3.4: Sample Similarity Based on KO Profiles
    logger.info("→ Registering UC-3.4...")
    register_uc_3_4_callbacks(app, plot_service)
    logger.info("[OK] UC-3.4 callbacks registered (Sample similarity - KO)")

    # Register UC-3.5: Sample Similarity Based on Compound Profiles
    logger.info("→ Registering UC-3.5...")
    register_uc_3_5_callbacks(app, plot_service)
    logger.info("[OK] UC-3.5 callbacks registered (Sample similarity - Compound)")

    # Register UC-3.6: Gene Co-occurrence Patterns Across Samples
    logger.info("→ Registering UC-3.6...")
    register_uc_3_6_callbacks(app, plot_service)
    logger.info("[OK] UC-3.6 callbacks registered (Gene symbol co-occurrence)")

    # Register UC-3.7: Compound Co-occurrence Patterns Across Samples
    logger.info("→ Registering UC-3.7...")
    register_uc_3_7_callbacks(app, plot_service)
    logger.info("[OK] UC-3.7 callbacks registered (Compound co-occurrence)")

    logger.info("=" * 60)
    logger.info("[OK] ALL MODULE 3 CALLBACKS REGISTERED SUCCESSFULLY")
    logger.info("=" * 60)

def register_module4_callbacks(app, plot_service) -> None:
    """
    Register all Module 4 callbacks with Dash app.

    Parameters
    ----------
    app : Dash
        Dash application instance.
    plot_service : PlotService
        Singleton PlotService instance (shared across all callbacks).

    Notes
    -----
    - Registers callback handlers for Module 4 use cases
    - Refer to official documentation for supported use case details
    """
    logger.info("=" * 60)
    logger.info("REGISTERING MODULE 4 CALLBACKS...")
    logger.info("=" * 60)

    # Register UC-4.1: Interactive Functional Profiling by Pathway
    logger.info("→ Registering UC-4.1...")
    register_uc_4_1_callbacks(app, plot_service)
    logger.info("[OK] UC-4.1 callbacks registered (Pathway functional profiling)")

    # Register UC-4.2: Interactive Sample Ranking by Pathway
    logger.info("→ Registering UC-4.2...")
    register_uc_4_2_callbacks(app, plot_service)
    logger.info("[OK] UC-4.2 callbacks registered (Sample ranking by pathway richness)")

    # Register UC-4.3: Interactive Sample Comparison by Pathway (Radar)
    logger.info("→ Registering UC-4.3...")
    register_uc_4_3_callbacks(app, plot_service)
    logger.info(
        "[OK] UC-4.3 callbacks registered (Sample comparison by pathway - Radar)"
    )

    # Register UC-4.4: Interactive Functional Fingerprint by Sample (Radar)
    logger.info("→ Registering UC-4.4...")
    register_uc_4_4_callbacks(app, plot_service)
    logger.info(
        "[OK] UC-4.4 callbacks registered (Functional fingerprint by sample - Radar)"
    )

    # Register UC-4.5: Interactive Gene Presence Map by Pathway
    logger.info("→ Registering UC-4.5...")
    register_uc_4_5_callbacks(app, plot_service)
    logger.info("[OK] UC-4.5 callbacks registered (Gene presence map by pathway)")

    # Register UC-4.6: Interactive Functional Potential by Compound
    logger.info("→ Registering UC-4.6...")
    register_uc_4_6_callbacks(app, plot_service)
    logger.info(
        "[OK] UC-4.6 callbacks registered " "(Functional potential by compound)"
    )

    # Register UC-4.9: Interactive Enzymatic Activity Profiling
    logger.info("→ Registering UC-4.9...")
    register_uc_4_9_callbacks(app, plot_service)
    logger.info("[OK] UC-4.9 callbacks registered " "(Enzymatic activity profiling)")

    # Register UC-4.7: Interactive Gene-Compound Association Explorer
    logger.info("→ Registering UC-4.7...")
    register_uc_4_7_callbacks(app, plot_service)
    logger.info(
        "[OK] UC-4.7 callbacks registered " "(Gene-compound association explorer)"
    )

    # Register UC-4.8: Interactive Gene Inventory Explorer
    logger.info("→ Registering UC-4.8...")
    register_uc_4_8_callbacks(app, plot_service)
    logger.info(
        "[OK] UC-4.8 callbacks registered " "(Gene inventory explorer by sample)"
    )

    # Register UC-4.10: Genetic Diversity of Enzymatic Activities
    logger.info("→ Registering UC-4.10...")
    register_uc_4_10_callbacks(app, plot_service)
    logger.info(
        "[OK] UC-4.10 callbacks registered " "(Genetic diversity by enzyme activity)"
    )

    # Register UC-4.11: Global Hierarchical View of Genetic Diversity (HADEG)
    logger.info("→ Registering UC-4.11...")
    register_uc_4_11_callbacks(app, plot_service)
    logger.info(
        "[OK] UC-4.11 callbacks registered "
        "(Global genetic diversity hierarchy - HADEG Sunburst)"
    )

    # Register UC-4.12: Interactive Pathway Relationships by Sample (HADEG)
    logger.info("→ Registering UC-4.12...")
    register_uc_4_12_callbacks(app, plot_service)
    logger.info(
        "[OK] UC-4.12 callbacks registered " "(Pathway relationships by sample - HADEG)"
    )

    # Register UC-4.13: Interactive Genetic Profile by Compound Pathway (HADEG)
    logger.info("→ Registering UC-4.13...")
    register_uc_4_13_callbacks(app, plot_service)
    logger.info(
        "[OK] UC-4.13 callbacks registered "
        "(Genetic profile by compound pathway - HADEG)"
    )

    logger.info("=" * 60)
    logger.info("[OK] ALL MODULE 4 CALLBACKS REGISTERED SUCCESSFULLY")
    logger.info("=" * 60)

def register_module5_callbacks(app, plot_service) -> None:
    """
    Register all Module 5 callbacks with Dash app.

    Parameters
    ----------
    app : Dash
        Dash application instance.
    plot_service : PlotService
        Singleton PlotService instance (shared across all callbacks).

    Notes
    -----
    - Registers callback handlers for Module 5 use cases
    - Refer to official documentation for supported use case details
    """
    logger.info("=" * 60)
    logger.info("REGISTERING MODULE 5 CALLBACKS...")
    logger.info("=" * 60)

    # Register UC-5.1: Sample - Compound Class Interaction Strength
    logger.info("-> Registering UC-5.1...")
    register_uc_5_1_callbacks(app, plot_service)
    logger.info("UC-5.1 callbacks registered (Chord Diagram)")

    # Register UC-5.2: Sample Similarity Based on Shared Chemical Profiles
    logger.info("-> Registering UC-5.2...")
    register_uc_5_2_callbacks(app, plot_service)
    logger.info("UC-5.2 callbacks registered (Chord Diagram - Pairwise Mode)")

    # Register UC-5.3: Regulatory Relevance of Samples
    logger.info("-> Registering UC-5.3...")
    register_uc_5_3_callbacks(app, plot_service)
    logger.info("UC-5.3 callbacks registered (Chord Diagram - Dropdown Trigger)")

    # Register UC-5.4: Gene-Compound Interaction Network
    logger.info("-> Registering UC-5.4...")
    register_uc_5_4_callbacks(app, plot_service)
    logger.info("UC-5.4 callbacks registered (Network Diagram - Accordion Trigger)")

    # Register UC-5.5: Gene-Gene Functional Interaction Network
    logger.info("-> Registering UC-5.5...")
    register_uc_5_5_callbacks(app, plot_service)
    logger.info("UC-5.5 callbacks registered (Similarity Network - Accordion Trigger)")

    # Register UC-5.6: Compound-Compound Functional Similarity Network
    logger.info("-> Registering UC-5.6...")
    register_uc_5_6_callbacks(app, plot_service)
    logger.info("UC-5.6 callbacks registered (Similarity Network - Accordion Trigger)")

    logger.info("=" * 60)
    logger.info("ALL MODULE 5 CALLBACKS REGISTERED SUCCESSFULLY")
    logger.info("=" * 60)

def register_module6_callbacks(app, plot_service) -> None:
    """
    Register all Module 6 callbacks with Dash app.

    Parameters
    ----------
    app : Dash
        Dash application instance.
    plot_service : PlotService
        Singleton PlotService instance (shared across all callbacks).

    Notes
    -----
    - Registers callback handlers for Module 6 use cases
    - Refer to official documentation for supported use case details
    """
    logger.info("=" * 60)
    logger.info("REGISTERING MODULE 6 CALLBACKS...")
    logger.info("=" * 60)

    # Register UC-6.1: Regulatory to Molecular Interaction Flow
    logger.info("→ Registering UC-6.1...")
    register_uc_6_1_callbacks(app, plot_service)
    logger.info("[OK] UC-6.1 callbacks registered (Regulatory-Molecular Sankey)")

    # Register UC-6.2: Biological Interaction Flow
    logger.info("→ Registering UC-6.2...")
    register_uc_6_2_callbacks(app, plot_service)
    logger.info("[OK] UC-6.2 callbacks registered (Biological Interaction Sankey)")

    # Register UC-6.3: Chemical Hierarchy of Bioremediation
    logger.info("→ Registering UC-6.3...")
    register_uc_6_3_callbacks(app, plot_service)
    logger.info("[OK] UC-6.3 callbacks registered (Chemical Hierarchy Treemap)")

    # Register UC-6.4: Overview of Enzymatic Activity and Substrate Scope
    logger.info("→ Registering UC-6.4...")
    register_uc_6_4_callbacks(app, plot_service)
    logger.info("[OK] UC-6.4 callbacks registered (Enzymatic Activity Treemap)")

    # Register UC-6.5: Chemical-Enzymatic Landscape by Substrate Scope
    logger.info("→ Registering UC-6.5...")
    register_uc_6_5_callbacks(app, plot_service)
    logger.info("[OK] UC-6.5 callbacks registered (Chemo-Enzymatic Landscape)")

    logger.info("=" * 60)
    logger.info("[OK] ALL MODULE 6 CALLBACKS REGISTERED SUCCESSFULLY")
    logger.info("=" * 60)

def register_module7_callbacks(app, plot_service) -> None:
    """
    Register all Module 7 callbacks with Dash app.

    Parameters
    ----------
    app : Dash
        Dash application instance.
    plot_service : PlotService
        Singleton PlotService instance (shared across all callbacks).

    Notes
    -----
    - Registers callback handlers for Module 7 use cases
    - Refer to official documentation for supported use case details
    """
    logger.info("=" * 60)
    logger.info("REGISTERING MODULE 7 CALLBACKS...")
    logger.info("=" * 60)

    # Register UC-7.1: Faceted Heatmap of Predicted Compound Toxicity Profiles
    logger.info("→ Registering UC-7.1...")
    register_uc_7_1_callbacks(app, plot_service)
    logger.info("[OK] UC-7.1 callbacks registered (Toxicity fingerprints)")

    # Register UC-7.2: Concordance Between Predicted Risk and Regulatory Focus
    logger.info("→ Registering UC-7.2...")
    register_uc_7_2_callbacks(app, plot_service)
    logger.info("[OK] UC-7.2 callbacks registered (Risk-Regulatory Concordance)")

    # Register UC-7.3: Elite Specialist Identification
    logger.info("→ Registering UC-7.3...")
    register_uc_7_3_callbacks(app, plot_service)
    logger.info("[OK] UC-7.3 callbacks registered (Genetic Response Mapping)")

    # Register UC-7.4: Toxicity Score Distribution
    logger.info("→ Registering UC-7.4...")
    register_uc_7_4_callbacks(app, plot_service)
    logger.info("[OK] UC-7.4 callbacks registered (Toxicity endpoint distribution)")

    # Register UC-7.5: Interactive Distribution of Toxicity Scores by Endpoint Category
    logger.info("→ Registering UC-7.5...")
    register_uc_7_5_callbacks(app, plot_service)
    logger.info("[OK] UC-7.5 callbacks registered (Density plot toxicity distribution)")

    # Register UC-7.6: Sample Risk Mitigation Breadth by Compound Variety
    logger.info("→ Registering UC-7.6...")
    register_uc_7_6_callbacks(app, plot_service)
    logger.info("[OK] UC-7.6 callbacks registered (Risk Mitigation Breadth)")

    # Register UC-7.7: Sample Risk Mitigation Depth Profile by Genetic Investment
    logger.info("→ Registering UC-7.7...")
    register_uc_7_7_callbacks(app, plot_service)
    logger.info("[OK] UC-7.7 callbacks registered (Risk Mitigation Depth)")

    logger.info("=" * 60)
    logger.info("[OK] ALL MODULE 7 CALLBACKS REGISTERED SUCCESSFULLY")
    logger.info("=" * 60)

def register_module8_callbacks(app, plot_service) -> None:
    """
    Register all Module 8 callbacks with Dash app.

    Parameters
    ----------
    app : dash.Dash
        Dash application instance.
    plot_service : PlotService
        Singleton PlotService instance (shared across all callbacks).

    Notes
    -----
    - Registers callback handlers for Module 8 use cases
    - Refer to official documentation for supported use case details
    """
    logger.info("=" * 60)
    logger.info("REGISTERING MODULE 8 CALLBACKS")
    logger.info("=" * 60)

    # UC-8.1: Minimal Sample Grouping for Complete Compound Coverage
    logger.info("[Module 8] Registering UC-8.1 callbacks...")
    register_uc_8_1_callbacks(app, plot_service)
    logger.info("[Module 8] [OK] UC-8.1 callbacks registered successfully")

    # UC-8.2: Chemical Class Completeness Scorecard
    logger.info("[Module 8] Registering UC-8.2 callbacks...")
    register_uc_8_2_callbacks(app, plot_service)
    logger.info("[Module 8] [OK] UC-8.2 callbacks registered successfully")

    # UC-8.3: Compound-Specific KO Completeness Scorecard
    logger.info("[Module 8] Registering UC-8.3 callbacks...")
    register_uc_8_3_callbacks(app, plot_service)
    logger.info("[Module 8] [OK] UC-8.3 callbacks registered successfully")

    # UC-8.4: Pathway Completeness Scorecard for HADEG Pathways
    logger.info("[Module 8] Registering UC-8.4 callbacks...")
    register_uc_8_4_callbacks(app, plot_service)
    logger.info("[Module 8] \u2713 UC-8.4 callbacks registered successfully")

    # UC-8.5: KEGG Pathway Completeness Scorecard
    logger.info("[Module 8] Registering UC-8.5 callbacks...")
    register_uc_8_5_callbacks(app, plot_service)
    logger.info("[Module 8] \u2713 UC-8.5 callbacks registered successfully")

    # UC-8.6: Pathway-Centric Consortium Design by KO Coverage
    logger.info("[Module 8] Registering UC-8.6 callbacks...")
    register_uc_8_6_callbacks(app, plot_service)
    logger.info("[Module 8] [OK] UC-8.6 callbacks registered successfully")

    # UC-8.7: Intersection of Genes Across Samples
    logger.info("[Module 8] Registering UC-8.7 callbacks...")
    register_uc_8_7_callbacks(app, plot_service)
    logger.info("[Module 8] [OK] UC-8.7 callbacks registered successfully")

    logger.info("=" * 60)
    logger.info("MODULE 8 CALLBACKS REGISTRATION COMPLETE")
    logger.info("=" * 60)

def register_processing_callbacks(
    app,
    data_processor: Optional[DataProcessor] = None,
    progress_tracker: Optional[ProgressTracker] = None,
):
    """
    Register processing callbacks.

    Parameters
    ----------
    app : Dash
        Dash application instance
    data_processor : Optional[DataProcessor], optional
        DataProcessor instance, by default None
    progress_tracker : Optional[ProgressTracker], optional
        ProgressTracker instance, by default None

    Notes
    -----
    DESATIVADO - Usando real_processing_callbacks.py

    Este arquivo contém callbacks da Application Layer que foram
    substituídos pelos callbacks reais.
    """
    # DESATIVADO - Callbacks duplicados, usando real_processing_callbacks.py
    return

    # Initialize services if not provided
    if data_processor is None:
        data_processor = DataProcessor()
    if progress_tracker is None:
        progress_tracker = ProgressTracker()

    # CALLBACK DESATIVADO - Conflita com real_processing_callbacks.py
    # @callback(
    #     [
    #         Output("progress-panel", "style"),
    #         Output("progress-interval", "disabled"),
    #         Output("session-id-store", "data")
    #     ],
    #     [Input("process-data-btn", "n_clicks")],
    #     [
    #         State("upload-result-store", "data"),
    #         State("session-id-store", "data")
    #     ],
    #     prevent_initial_call=True
    # )
    def start_processing_disabled(
        n_clicks: Optional[int],
        upload_result: Optional[Dict[str, Any]],
        session_id: Optional[str],
    ) -> Tuple[Dict, bool, str]:
        """
        Start data processing workflow.

        Parameters
        ----------
        n_clicks : Optional[int]
            Button click count
        upload_result : Optional[Dict[str, Any]]
            UploadResultDTO from store
        session_id : Optional[str]
            Current session ID

        Returns
        -------
        Tuple[Dict, bool, str]
            - Progress panel style (display: block)
            - Interval disabled flag (False to enable)
            - Session ID (new or existing)

        Notes
        -----
        - Generates session ID if not exists
        - Starts background processing task
        - Enables progress interval for updates
        - Shows progress panel
        """
        if not n_clicks or not upload_result:
            raise PreventUpdate

        # Generate session ID if needed
        if not session_id:
            session_id = str(uuid.uuid4())

        try:
            # TODO: Start async processing task
            # For now, we'll track progress synchronously
            # In production, use Celery or similar for background tasks

            # Initialize progress
            progress_tracker.start_processing(session_id, total_stages=8)

            # Show progress panel and enable interval
            return {"display": "block"}, False, session_id

        except Exception as e:
            # Handle errors
            return {"display": "none"}, True, session_id

    # CALLBACK DESATIVADO - Conflita com real_processing_callbacks.py
    # @callback(
    #     [
    #         Output("processing-progress-store", "data"),
    #         Output("progress-display", "children")
    #     ],
    #     [Input("progress-interval", "n_intervals")],
    #     [State("session-id-store", "data")],
    #     prevent_initial_call=True
    # )
    def update_progress_disabled(
        n_intervals: int, session_id: Optional[str]
    ) -> Tuple[Optional[Dict[str, Any]], Any]:
        """
        Update processing progress.

        Parameters
        ----------
        n_intervals : int
            Number of interval ticks
        session_id : Optional[str]
            Current session ID

        Returns
        -------
        Tuple[Optional[Dict[str, Any]], Any]
            - ProcessingProgressDTO as dict
            - Updated progress bar component

        Notes
        -----
        - Polls ProgressTracker every 1 second
        - Updates progress bar display
        - Stores progress data for completion check
        """
        if not session_id:
            raise PreventUpdate

        try:
            # Get current progress
            progress = progress_tracker.get_progress(session_id)

            if not progress:
                raise PreventUpdate

            # Create progress bar component
            from ..components.base import create_progress_bar

            progress_bar = create_progress_bar(progress_data=progress.to_dict())

            return progress.to_dict(), progress_bar.children

        except Exception:
            raise PreventUpdate

    # Callback desativado - usando real_processing_callbacks.py
    # @callback(
    #     [
    #         Output("completion-panel", "style"),
    #         Output("completion-panel", "children"),
    #         Output("progress-interval", "disabled", allow_duplicate=True),
    #         Output("processing-complete-store", "data")
    #     ],
    #     [Input("processing-progress-store", "data")],
    #     prevent_initial_call=True
    # )
    def show_completion_disabled(
        progress_data: Optional[Dict[str, Any]]
    ) -> Tuple[Dict[str, str], Any, bool, bool]:
        """
        Show completion panel when processing finishes.

        Parameters
        ----------
        progress_data : Optional[Dict[str, Any]]
            ProcessingProgressDTO data

        Returns
        -------
        Tuple[Dict, Any, bool, bool]
            - Completion panel style
            - Completion panel component
            - Interval disabled (True to stop polling)
            - Processing complete flag

        Notes
        -----
        - Checks if percentage == 100
        - Disables progress interval
        - Shows completion panel
        - Sets complete flag to True
        """
        if not progress_data:
            raise PreventUpdate

        percentage = progress_data.get("percentage", 0)

        # Check if complete
        if percentage >= 100:
            # Create completion data
            completion_data = {
                "success": True,
                "processing_time": 45.2,  # TODO: Get actual time
                "total_samples": 150,  # TODO: Get from result
                "merged_records": 1200,  # TODO: Get from result
                "session_id": "abc123",  # TODO: Get actual session_id
            }

            # Create completion panel
            from ..components.composite import create_completion_panel

            panel = create_completion_panel(completion_data=completion_data)

            return {"display": "block"}, panel.children, True, True

        raise PreventUpdate

    # CALLBACK DESATIVADO - Conflita com real_processing_callbacks.py
    # @callback(
    #     Output("url", "pathname"),
    #     [Input("view-results-btn", "n_clicks")],
    #     prevent_initial_call=True
    # )
    def navigate_to_results_disabled(n_clicks: Optional[int]) -> str:
        """
        Navigate to results page.

        Parameters
        ----------
        n_clicks : Optional[int]
            Button click count

        Returns
        -------
        str
            URL pathname (/results)

        Notes
        -----
        - Triggered by "View Results" button
        - Changes URL to /results
        - Results page will load merged data from store
        """
        if not n_clicks:
            raise PreventUpdate

        return "/results"