Gui

class GuiPage(BaseModel, abc.ABC):
    """
    Abstract base class for all GUI pages.

    Provides common page structure and lifecycle using the Template Method
    pattern. Subclasses implement `render_content()` for page-specific UI
    while inheriting consistent header/footer rendering.

    Exit lifecycle:
    - `on_exit()`: Override to perform cleanup when leaving the page
    - `requires_exit_confirmation()`: Override to trigger confirmation dialog
    - `get_exit_confirmation_message()`: Override to customize confirmation text

    Attributes:
        session: Session state container with app context
        route: URL route for this page (e.g., "/", "/projects")
        title: Page title shown in header
        show_back_button: Whether to show back navigation button
        back_route: Route to navigate when back button clicked
        back_icon: Icon for back button (default: "arrow_back")
        back_text: Optional text label for back button
        show_footer: Whether to render footer

    Usage:
        ```python
        class MyPage(GuiPage):
            def __init__(self, session: GuiSession):
                super().__init__(
                    session=session,
                    route="/my_page",
                    title="My Page",
                    show_back_button=True,
                    back_route="/",
                )

            def render_content(self) -> None:
                with ui.column().classes("items-center"):
                    ui.label("My page content")

            def requires_exit_confirmation(self) -> bool:
                return self.session.current_analysis is not None

            def on_exit(self) -> None:
                self.session.reset_analysis_workflow()

        # Register with NiceGUI
        @ui.page("/my_page")
        def my_page():
            page = MyPage(session)
            page.render()
        ```
    """

    # Link to main session state/variables
    session: GuiSession

    # Page configuration
    route: str = "/"
    title: str = "CIB Mango Tree"

    # Navigation configuration
    show_back_button: bool = False
    back_route: str | None = None
    back_icon: str = "arrow_back"
    back_text: str | None = None

    # Footer configuration
    show_footer: bool = True

    # Allow arbitrary types
    model_config = ConfigDict(arbitrary_types_allowed=True)

    # main rendering function
    def render(self) -> None:
        """
        Main rendering method implementing template pattern.

        Call this method from the NiceGUI @ui.page decorator to render
        the complete page with header, content, and footer.

        Lifecycle:
        1. Setup colors
        2. Render header
        3. Render content (abstract - implemented by subclasses)
        4. Render footer
        """
        self._setup_colors()
        self._render_header()
        self.render_content()
        if self.show_footer:
            self._render_footer()

    @abc.abstractmethod
    def render_content(self) -> None:
        """
        Render page-specific content.

        Subclasses MUST implement this method to provide the main
        page content. This is called automatically by render().

        Example:
            ```python
            def render_content(self) -> None:
                with ui.column().classes("items-center"):
                    ui.label("Welcome")
                    ui.button("Click me", on_click=self._handle_click)
            ```
        """
        raise NotImplementedError

    def _setup_colors(self) -> None:
        """Setup Mango Tree brand colors for NiceGUI."""
        ui.colors(
            primary=gui_colors.primary,
            secondary=gui_colors.secondary,
            accent=gui_colors.accent,
        )

    def _render_header(self) -> None:
        """
        Render standardized header with 3-column layout.

        Layout:
        - Left: Back button (if show_back_button=True)
        - Center: Page title
        - Right: Home button (if not on home page)
        """
        with ui.header(elevated=True):
            with ui.row().classes("w-full items-center justify-between"):
                # Left: Back button or spacer
                with ui.element("div").classes("flex items-center"):
                    if self.show_back_button and self.back_route:
                        # Build button parameters conditionally
                        btn_kwargs = {
                            "icon": self.back_icon,
                            "color": "accent",
                            "on_click": self._handle_back_click,
                        }
                        if self.back_text:
                            btn_kwargs["text"] = self.back_text
                        ui.button(**btn_kwargs).props("flat")

                # Center: Title
                ui.label(self.title).classes("text-h6")

                # Right: Home button (if not on home page)
                with ui.element("div").classes("flex items-center"):
                    if self.show_back_button:  # Not on home if back button shown
                        ui.button(
                            icon="home",
                            color="accent",
                            on_click=self._handle_home_click,
                        ).props("flat")

    async def _handle_back_click(self) -> None:
        """Handle back button click with optional exit confirmation."""
        if self.requires_exit_confirmation():
            dialog = ExitConfirmationDialog(
                message=self.get_exit_confirmation_message(),
            )
            confirmed = await dialog
            if not confirmed:
                return

        self.on_exit()

        if self.back_route:
            self.navigate_to(self.back_route)

    async def _handle_home_click(self) -> None:
        """Handle home button click with optional exit confirmation."""
        if self.requires_exit_confirmation():
            dialog = ExitConfirmationDialog(
                message=self.get_exit_confirmation_message(),
            )
            confirmed = await dialog
            if not confirmed:
                return

        self.on_exit()
        self.navigate_to("/")

    def on_exit(self) -> None:
        """Override to perform cleanup when leaving the page.

        Called after exit confirmation (if any) is accepted,
        before navigation occurs.
        """
        pass

    def requires_exit_confirmation(self) -> bool:
        """Override to trigger confirmation dialog before leaving.

        Returns True to show confirmation, False to navigate directly.
        """
        return False

    def get_exit_confirmation_message(self) -> str:
        """Override to customize the exit confirmation message.

        Only used when requires_exit_confirmation() returns True.
        """
        return "Are you sure you want to leave this page?"

    def _render_footer(self) -> None:
        """
        Render standardized footer with 3-column layout.

        Layout:
        - Left: License information
        - Center: Project attribution
        - Right: External links (GitHub, Instagram)
        """
        with ui.footer(elevated=True):
            with (
                ui.row()
                .classes("w-full items-center")
                .style("justify-content: space-between")
            ):
                # Left: License
                with ui.element("div").classes("flex items-center"):
                    ui.label("MIT License").classes("text-sm text-bold")

                # Center: Project attribution
                with ui.element("div").classes("flex items-center gap-2"):
                    with ui.link(target=gui_urls.website_url, new_tab=True).classes(
                        "inline-flex items-center no-underline"
                    ):
                        with ui.element("div").classes("bg-white rounded-full p-1.5"):
                            ui.html(
                                self._load_svg_icon("cibmt_logo"), sanitize=False
                            ).classes("size-5")
                        ui.tooltip("Visit cibmangotree.org")
                    ui.label("A Civic Tech DC Project").classes("text-sm text-bold")

                # Right: External links
                self._render_footer_links()

    def _render_footer_links(self) -> None:
        """Render social media links in footer."""
        with ui.element("div").classes("flex items-center gap-3"):
            # GitHub button
            with ui.link(target=gui_urls.github_url, new_tab=True).classes(
                "inline-flex items-center justify-center text-white no-underline size-5"
            ):
                ui.html(self._load_svg_icon("github"), sanitize=False).classes(
                    "size-full fill-current"
                )
                ui.tooltip("Visit our GitHub")

            with ui.link(target=gui_urls.instagram_url, new_tab=True).classes(
                "inline-flex items-center justify-center text-white no-underline size-5"
            ):
                ui.html(self._load_svg_icon("instagram"), sanitize=False).classes(
                    "size-full fill-current"
                )
                ui.tooltip("Follow us on Instagram")

    # Navigation helpers
    def navigate_to(self, route: str) -> None:
        """
        Navigate to another page in the application.

        Args:
            route: Target route path (e.g., "/projects", "/new_project")
        """
        ui.navigate.to(route)

    def navigate_to_external(self, url: str) -> None:
        """
        Navigate to external URL in new tab.

        Args:
            url: External URL to open
        """
        ui.navigate.to(url, new_tab=True)

    def go_back(self) -> None:
        """Navigate to the configured back route."""
        if self.back_route:
            self.navigate_to(self.back_route)

    def go_home(self) -> None:
        """Navigate to home page."""
        self.navigate_to("/")

    # utilities
    def _load_svg_icon(self, icon_name: str) -> str:
        """
        Load SVG icon from the icons directory.

        Args:
            icon_name: Name of icon file (without .svg extension)

        Returns:
            SVG content as string
        """
        icon_path = Path(__file__).parent / "icons" / f"{icon_name}.svg"
        return icon_path.read_text()

    def notify_success(self, message: str) -> None:
        """Show success notification."""
        ui.notify(message, type="positive", color="secondary")

    def notify_warning(self, message: str) -> None:
        """Show warning notification."""
        ui.notify(message, type="warning")

    def notify_error(self, message: str) -> None:
        """Show error notification."""
        ui.notify(message, type="negative")

    @contextmanager
    def centered_content(
        self,
        max_width: str | None = None,
        height: str = "80vh",
        padding: str | None = None,
        justify: str = "center",
    ) -> Generator[ui.column, None, None]:
        style = f"height: {height}; width: 100%"
        if max_width:
            style += f"; max-width: {max_width}; margin: 0 auto"
        if padding:
            style += f"; padding: {padding}"
        container = (
            ui.column().classes(f"items-center justify-{justify} gap-8").style(style)
        )
        with container:
            yield container

    def require_project(self) -> bool:
        if not self.session.current_project:
            self.notify_warning("No project selected. Redirecting...")
            self.navigate_to(gui_routes.select_project)
            return False
        return True

    def require_file(self) -> bool:
        if not self.session.selected_file:
            self.notify_warning("No file selected. Redirecting...")
            self.navigate_to(gui_routes.import_dataset)
            return False
        return True

class GUIContext(BaseModel):
    """Context for GUI mode, wrapping the App instance."""

    app: App = Field(...)
    model_config = ConfigDict(arbitrary_types_allowed=True)

class GuiSession(BaseModel):
    """
    Application-wide session state container.

    Replaces module-level global variables with a type-safe,
    validated state container. Provides access to
    application context and workflow state.

    Attributes:
        context: Application context wrapping App instance
        current_project: Currently selected/active project
        selected_file_path: Path to file selected for import
        new_project_name: Name for project being created
        import_session: Active importer session for data preview
        selected_analyzer: ID of selected primary analyzer
        current_analysis: Currently selected/active analysis
        project_loaded_from_storage: True if project was loaded from disk
        analysis_loaded_from_storage: True if analysis was loaded from disk

    Example:
        ```python
        context = GUIContext(app=app)
        session = GuiSession(context=context)

        # Set project
        session.current_project = project

        # Access app
        projects = session.app.list_projects()
        ```
    """

    # Core context
    context: GUIContext

    # Workflow state - project creation
    current_project: ProjectContext | None = None
    selected_file_path: Path | None = None
    selected_file_name: str | None = None
    selected_file: BytesIO | None = None
    selected_file_content_type: str | None = None
    new_project_name: str | None = None
    import_session: ImporterSession | None = None

    # Workflow state - analysis
    selected_analyzer: AnalyzerInterface | None = None
    selected_analyzer_name: str | None = None
    column_mapping: dict[str, str] | None = None
    current_analysis: AnalysisModel | None = None
    analysis_params: dict[str, ParamValue] | None = None

    # Source tracking flags
    project_loaded_from_storage: bool = False
    analysis_loaded_from_storage: bool = False

    # Allow arbitrary types (for NiceGUI components, ImporterSession, etc.)
    model_config = ConfigDict(arbitrary_types_allowed=True)

    @property
    def app(self):
        """Access underlying App instance."""
        return self.context.app

    def reset_project_workflow(self) -> None:
        """Clear project creation workflow state."""
        self.current_project = None
        self.selected_file_path = None
        self.selected_file_name = None
        self.selected_file = None
        self.selected_file_content_type = None
        self.new_project_name = None
        self.import_session = None
        self.project_loaded_from_storage = False

    def reset_analysis_workflow(self) -> None:
        """Clear analysis workflow state."""
        self.selected_analyzer = None
        self.selected_analyzer_name = None
        self.column_mapping = None
        self.current_analysis = None
        self.analysis_params = None
        self.analysis_loaded_from_storage = False

    def validate_project_selected(self) -> bool:
        """Check if a project is currently selected."""
        return self.current_project is not None

    def validate_file_selected(self) -> bool:
        """Check if a file is currently selected."""
        return self.selected_file is not None

    def validate_project_name_set(self) -> bool:
        """Check if new project name is set."""
        return bool(self.new_project_name and self.new_project_name.strip())

class GuiRoutes(BaseModel):
    """Container for"""

    root: str = "/"
    import_dataset: str = "/import_dataset"
    new_project: str = "/new_project"
    select_project: str = "/select_project"
    select_analyzer_fork: str = "/select_analyzer_fork"
    select_previous_analyzer: str = "/select_previous_analyzer"
    configure_analysis: str = "/configure_analysis"
    preview_dataset: str = "/preview_dataset"
    post_analysis: str = "/post_analysis"
    dashboard: str = "/dashboard"

class GuiColors(BaseModel):
    """Mango Tree brand colors"""

    model_config = ConfigDict(frozen=True)

    primary: str = Field(default=MANGO_DARK_GREEN, description="Mango dark green")
    secondary: str = Field(default=MANGO_ORANGE_LIGHT, description="Mango orange light")
    accent: str = Field(default=ACCENT, description="Accent color")

    # Additional colors for reference
    mango_orange: str = Field(default=MANGO_ORANGE, description="Mango orange")

class GuiConstants(BaseModel):
    """Container for both colors and urls"""

    model_config = ConfigDict(arbitrary_types_allowed=True)

    colors: GuiColors = Field(...)
    urls: GuiURLS = Field(...)

class GuiURLS(BaseModel):
    """UI URL constants."""

    model_config = ConfigDict(frozen=True)

    # External URLs
    github_url: str = Field(
        default="https://github.com/civictechdc/cib-mango-tree",
        description="GitHub repository URL",
    )
    instagram_url: str = Field(
        default="https://www.instagram.com/cibmangotree",
        description="Instagram profile URL",
    )
    website_url: str = Field(
        default="https://cibmangotree.org",
        description="Official website URL",
    )

class AnalysisParamsCard:
    """
    Card component for configuring analyzer parameters.

    Displays each parameter as an individual card, matching the visual style
    of the column picker cards for consistent UX.
    """

    def __init__(
        self,
        params: list[AnalyzerParam],
        default_values: dict[str, ParamValue],
    ):
        """
        Initialize the analysis parameters card.

        Args:
            params: List of analyzer parameter specifications
            default_values: Dictionary of default parameter values
        """
        self.params = params
        self.default_values = default_values
        self.param_widgets: dict[str, tuple] = {}

        # Build the card UI
        self._build_card()

    def _build_card(self):
        """Build the parameter configuration cards in a flex-wrap row."""
        if not self.params:
            with ui.column().classes("w-full items-center"):
                ui.label("This analyzer has no configurable parameters.").classes(
                    "text-grey-7"
                )
            return

        with ui.row().classes("flex-wrap gap-6 justify-center w-full"):
            for param in self.params:
                self._build_param_card(param)

    def _build_param_card(self, param: AnalyzerParam):
        """Build an individual card for a single parameter."""
        with ui.card().classes("w-72 p-4 no-shadow border border-gray-200"):
            with ui.row().classes("items-center gap-1"):
                ui.label(param.print_name).classes("text-bold")
                if param.description:
                    with ui.icon("info").classes("text-grey-6 cursor-pointer"):
                        ui.tooltip(param.description)

            param_type = param.type
            default_value = self.default_values.get(param.id)

            if param_type.type == "integer":
                self._build_integer_control(param, param_type, default_value)
            elif param_type.type == "time_binning":
                self._build_time_binning_control(param, default_value)

    def _build_integer_control(
        self,
        param: AnalyzerParam,
        param_type: IntegerParam,
        default_value: ParamValue | None,
    ):
        """Build integer parameter control."""
        int_default = default_value if isinstance(default_value, int) else None
        number_input = ui.number(
            value=int_default if int_default is not None else param_type.min,
            min=param_type.min,
            max=param_type.max,
            step=1,
            precision=0,
            validation={
                f"Must be at least {param_type.min}": lambda v: v >= param_type.min,
                f"Must be at most {param_type.max}": lambda v: v <= param_type.max,
            },
        ).classes("w-full mt-2")

        self.param_widgets[param.id] = ("integer", number_input)

    def _build_time_binning_control(
        self, param: AnalyzerParam, default_value: ParamValue | None
    ):
        """Build time binning parameter control."""
        tb_default = (
            default_value if isinstance(default_value, TimeBinningValue) else None
        )
        with ui.row().classes("gap-2 mt-2 w-full"):
            unit_select = ui.select(
                {
                    "year": "Year",
                    "month": "Month",
                    "week": "Week",
                    "day": "Day",
                    "hour": "Hour",
                    "minute": "Minute",
                    "second": "Second",
                },
                value=tb_default.unit if tb_default else "day",
            ).classes("w-32")

            amount_input = ui.number(
                value=tb_default.amount if tb_default else 1,
                min=1,
                max=1000,
                step=1,
                precision=0,
                validation={
                    "Must be at least 1": lambda v: v >= 1,
                    "Cannot exceed 1000": lambda v: v <= 1000,
                },
            ).classes("w-24")

        self.param_widgets[param.id] = ("time_binning", unit_select, amount_input)

    def get_param_values(self) -> dict[str, ParamValue]:
        """
        Retrieve current parameter values from the UI controls.

        Returns:
            Dictionary mapping parameter IDs to their values
        """
        param_values = {}

        for param_id, widgets in self.param_widgets.items():
            param_type = widgets[0]

            if param_type == "integer":
                number_input = widgets[1]
                param_values[param_id] = int(number_input.value)

            elif param_type == "time_binning":
                unit_toggle = widgets[1]
                amount_input = widgets[2]
                param_values[param_id] = TimeBinningValue(
                    unit=unit_toggle.value, amount=int(amount_input.value)
                )

        return param_values

class ExitConfirmationDialog(ui.dialog):
    """Reusable confirmation dialog for page exit navigation.

    Subclasses ui.dialog to match the pattern used by
    ManageProjectsDialog and ImportOptionsDialog.

    Usage:
        dialog = ExitConfirmationDialog(
            message="You have unsaved changes. Leave anyway?",
            confirm_text="Leave",
            cancel_text="Stay"
        )
        confirmed = await dialog
        if confirmed:
            ui.navigate.to("/home")
    """

    def __init__(
        self,
        message: str = "Are you sure you want to leave?",
        confirm_text: str = "Leave",
        cancel_text: str = "Stay",
    ):
        super().__init__()
        with self, ui.card().classes("w-80 items-center"):
            ui.label(message).classes("text-center q-mb-md")
            with ui.row().classes("gap-2"):
                ui.button(
                    cancel_text,
                    on_click=lambda: self.submit(False),
                ).props("flat")
                ui.button(
                    confirm_text,
                    on_click=lambda: self.submit(True),
                    color="negative",
                ).props("flat")

class ExportDialog(ui.dialog):
    """Multi-step dialog for selecting and exporting analysis outputs."""

    def __init__(self, analysis_context: AnalysisContext):
        super().__init__()

        self.analysis_context = analysis_context

        self.outputs = sorted(
            analysis_context.get_all_exportable_outputs(),
            key=lambda output: (
                (
                    "0"
                    if output.secondary_spec is None
                    else "1_" + output.secondary_spec.name
                ),
                output.descriptive_qualified_name,
            ),
        )

        self.selected_outputs: list[AnalysisOutputContext] = []
        self.format: SupportedOutputExtension | None = None
        self.exported_paths: list[tuple[str, int]] = []
        self.export_errors: list[str] = []

        self.progress_queue: queue.Queue | None = None
        self.timer: ui.timer | None = None

        self.output_status_rows: dict[str, tuple] = {}

        with (
            self,
            ui.card().classes("w-full").style("min-width: 500px; max-width: 700px"),
        ):
            self._build_select_outputs()
            self._build_configure_export()
            self._build_export_progress()
            self._build_export_complete()

        self._show_step("select_outputs")

    def _show_step(self, step: str):
        steps = {
            "select_outputs": self.select_outputs,
            "configure_export": self.configure_export,
            "export_progress": self.export_progress,
            "export_complete": self.export_complete,
        }
        for name, card in steps.items():
            card.set_visibility(name == step)

    def _add_checkbox_group(
        self, label_text: str, outputs: list[AnalysisOutputContext]
    ):
        ui.label(label_text).classes("text-subtitle2 text-weight-bold q-mt-sm")
        ui.separator()
        for output in outputs:
            cb = ui.checkbox(
                f"{output.descriptive_qualified_name}",
                on_change=lambda _=None: self._on_selection_changed(),
            )
            self.output_checkboxes.append((output, cb))

    def _build_select_outputs(self):
        self.select_outputs = ui.column().classes("w-full")
        with self.select_outputs:
            ui.label("Select outputs to export").classes("text-h6 q-mb-md")

            self.output_checkboxes: list[tuple[AnalysisOutputContext, ui.checkbox]] = []
            self.checkbox_container = ui.column().classes("w-full gap-1 mb-4")

            with self.checkbox_container:
                primary_outputs = [o for o in self.outputs if o.secondary_spec is None]
                secondary_outputs = [
                    o for o in self.outputs if o.secondary_spec is not None
                ]

                if primary_outputs:
                    self._add_checkbox_group("Primary Outputs", primary_outputs)

                if secondary_outputs:
                    sec_names = sorted(
                        {o.secondary_spec.name for o in secondary_outputs}
                    )
                    for sec_name in sec_names:
                        sec_outputs = [
                            o
                            for o in secondary_outputs
                            if o.secondary_spec.name == sec_name
                        ]
                        self._add_checkbox_group("Secondary Outputs", sec_outputs)

            with ui.row().classes("w-full justify-end gap-2"):
                ui.button("Cancel", on_click=self.close, color="secondary")
                self.select_outputs_next = ui.button(
                    "Next",
                    on_click=self._go_to_configure_export,
                    color="primary",
                    icon="arrow_forward",
                )
                self.select_outputs_next.set_enabled(False)

    def _on_selection_changed(self):
        has_selection = any(cb.value for _, cb in self.output_checkboxes)
        self.select_outputs_next.set_enabled(has_selection)

    def _go_to_configure_export(self):
        self.selected_outputs = [
            output for output, cb in self.output_checkboxes if cb.value
        ]

        self.chunking_visible = any(
            output.num_rows > LARGE_OUTPUT_THRESHOLD for output in self.selected_outputs
        )
        self.chunking_section.set_visibility(self.chunking_visible)
        self._show_step("configure_export")

    def _build_configure_export(self):
        self.configure_export = ui.column().classes("w-full")
        with self.configure_export:
            ui.label("Configure export").classes("text-h6 q-mb-md")

            is_hashtags = self.analysis_context.analyzer_id == "hashtags"
            format_options: dict[str, str] = {}
            if not is_hashtags:
                format_options["csv"] = "CSV"
                format_options["xlsx"] = "Excel"
            format_options["json"] = "JSON"

            self.format_toggle = ui.toggle(
                format_options,
                value=list(format_options.keys())[0],
            ).classes("q-mb-md")

            self.chunking_visible = False
            self.chunking_section = ui.column().classes("w-full")
            self.chunking_section.set_visibility(False)
            with self.chunking_section:
                ui.label("Chunking options").classes(
                    "text-subtitle2 text-weight-bold q-mt-sm"
                )
                ui.label(
                    f"Control how outputs larger than "
                    f"{LARGE_OUTPUT_THRESHOLD:,} rows are saved."
                ).classes("q-mb-md text-sm")

                settings = self.analysis_context.app_context.settings
                current_chunk = settings.export_chunk_size
                is_current_chunking = (
                    current_chunk is not None and current_chunk is not False
                )
                default_toggle = (
                    is_current_chunking if current_chunk is not None else True
                )

                self.chunk_toggle = ui.toggle(
                    {True: "Break into chunks", False: "Export in a single file"},
                    value=default_toggle,
                ).classes("q-mb-md")

                self.chunk_size_input = ui.number(
                    "Rows per chunk",
                    value=(
                        current_chunk
                        if isinstance(current_chunk, int)
                        else LARGE_OUTPUT_THRESHOLD
                    ),
                    min=100,
                ).classes("q-mb-md")

                if not is_current_chunking:
                    self.chunk_size_input.set_visibility(False)

                self.chunk_toggle.on_value_change(
                    lambda: self.chunk_size_input.set_visibility(
                        self.chunk_toggle.value
                    )
                )

            with ui.row().classes("w-full justify-end gap-2"):
                ui.button(
                    "Back",
                    on_click=lambda: self._show_step("select_outputs"),
                    color="secondary",
                    icon="arrow_back",
                )
                ui.button(
                    "Start Export",
                    on_click=self._handle_start_export,
                    color="primary",
                    icon="arrow_forward",
                )

    def _handle_start_export(self):
        self.format = self.format_toggle.value

        if self.chunking_visible:
            settings = self.analysis_context.app_context.settings
            if self.chunk_toggle.value:
                settings.set_export_chunk_size(self.chunk_size_input.value)
            else:
                settings.set_export_chunk_size(False)

        self._start_export()

    def _build_export_progress(self):
        self.export_progress = ui.column().classes("w-full")
        with self.export_progress:
            ui.label("Exporting...").classes("text-h6 q-mb-md")

            self.export_status_label = ui.label("Preparing...").classes(
                "text-base q-mb-md"
            )

            self.export_progress_bar = (
                ui.linear_progress(value=0, show_value=False)
                .classes("w-full q-mb-md")
                .props("instant-feedback")
            )

            self.output_status_container = ui.column().classes("w-full gap-1 mb-4")

    def _build_export_complete(self):
        self.export_complete = ui.column().classes("w-full")
        with self.export_complete:
            with ui.row().classes("items-center gap-2 q-mb-md"):
                self.complete_success_icon = ui.icon(
                    "check_circle", color=MANGO_DARK_GREEN, size="lg"
                )
                self.complete_error_icon = ui.icon(
                    "cancel", color="negative", size="lg"
                )
                self.complete_status_label = ui.label("").classes("text-h6")
                self.complete_success_icon.set_visibility(False)
                self.complete_error_icon.set_visibility(False)

            self.complete_message_container = ui.column().classes("w-full gap-1 mb-4")

            with ui.row().classes("w-full justify-end gap-2"):
                self.export_complete_open_folder = ui.button(
                    "Open exports folder",
                    on_click=self._open_folder,
                    color="primary",
                    icon="folder_open",
                )
                ui.button("Close", on_click=self.close, color="secondary")

    def _start_export(self):
        if self.format is None:
            ui.notify("Please select an export format", type="warning")
            self._show_step("configure_export")
            return

        self._show_step("export_progress")

        self.progress_queue = queue.Queue()
        self.exported_paths = []
        self.export_errors = []
        self.output_status_rows.clear()

        self.output_status_container.clear()

        self.export_progress_bar.value = 0

        thread = threading.Thread(
            target=_export_worker,
            args=(
                self.selected_outputs,
                self.format,
                self.progress_queue,
            ),
            daemon=True,
        )
        thread.start()

        self.timer = ui.timer(QUEUE_POLL_INTERVAL, self._poll_progress)

    def _poll_progress(self):
        try:
            msg = self.progress_queue.get_nowait()
        except queue.Empty:
            return

        if msg.msg_type == "output_start":
            self.export_status_label.text = f"Exporting {msg.name}..."
            self.export_progress_bar.value = msg.index / msg.total

            with self.output_status_container:
                with ui.row().classes("items-center gap-2") as row:
                    spinner = ui.spinner("gears", size="sm")
                    label = ui.label(msg.name).classes("text-sm")
                self.output_status_rows[msg.name] = (row, spinner, label)

        elif msg.msg_type == "output_progress":
            self.export_progress_bar.value = (
                msg.index + msg.chunk_progress
            ) / msg.total
            if msg.name in self.output_status_rows:
                _, _, label = self.output_status_rows[msg.name]
                label.text = f"{msg.name} ({msg.chunk_progress * 100:.0f}%)"

        elif msg.msg_type == "output_finish":
            self.export_progress_bar.value = (msg.index + 1) / msg.total
            self.exported_paths.append((msg.path, msg.chunk_count))
            if msg.name in self.output_status_rows:
                _, spinner, label = self.output_status_rows[msg.name]
                spinner.set_visibility(False)
                if msg.chunk_count > 1:
                    display_path = msg.path.replace("_[*]", "")
                    label.text = (
                        f"Exported as {os.path.basename(display_path)} "
                        f"in {msg.chunk_count} chunks"
                    )
                else:
                    label.text = f"Exported as {os.path.basename(msg.path)}"

        elif msg.msg_type == "output_error":
            self.export_errors.append(f"{msg.name}: {msg.error}")
            if msg.name in self.output_status_rows:
                _, spinner, label = self.output_status_rows[msg.name]
                spinner.set_visibility(False)
                label.text = f"Error: {msg.name} \u2014 {msg.error}"

        elif msg.msg_type == "all_complete":
            self._on_export_complete()

    def _on_export_complete(self):
        if self.timer:
            self.timer.cancel()
            self.timer = None

        self.export_progress_bar.value = 1.0
        if self.export_errors:
            self.complete_status_label.text = "Export completed with errors"
            self.complete_error_icon.set_visibility(True)
            self.complete_success_icon.set_visibility(False)
        else:
            self.complete_status_label.text = "Export complete!"
            self.complete_success_icon.set_visibility(True)
            self.complete_error_icon.set_visibility(False)

        self.complete_message_container.clear()
        with self.complete_message_container:
            if self.exported_paths:
                for path, chunk_count in self.exported_paths:
                    if chunk_count > 1:
                        display_path = path.replace("_[*]", "")
                        ui.label(
                            f"Exported {os.path.basename(display_path)} in {chunk_count} chunks"
                        ).classes("text-sm")
                    else:
                        ui.label(f"Exported {os.path.basename(path)}").classes(
                            "text-sm"
                        )

            if self.export_errors:
                for error in self.export_errors:
                    ui.label(error).classes("text-sm")

        self.export_complete_open_folder.set_visibility(bool(self.exported_paths))
        self._show_step("export_complete")

    async def _open_folder(self):
        await run.io_bound(
            open_directory_explorer, self.analysis_context.export_root_path
        )