app.py

"""Gradio web UI for D&D Session Processor - Modern UI"""
import os
import json
import socket
import sys
from pathlib import Path
sys.path.append(str(Path(__file__).resolve().parent))
import subprocess
from pathlib import Path
from threading import Event, RLock

import gradio as gr
import requests

from typing import Any, Dict, List, Optional, Tuple

from src.pipeline import DDSessionProcessor
from src.exceptions import CancelledError
from src.config import Config
from src.diarizer import SpeakerProfileManager
from src.character_profile import CharacterProfileManager
from src.logger import (
    get_log_file_path,
    get_logger,
    get_console_log_level,
    set_console_log_level,
    LOG_LEVEL_CHOICES,
)
from src.audit import log_audit_event
from src.party_config import PartyConfigManager, CampaignManager
from src.knowledge_base import CampaignKnowledgeBase
from src.preflight import PreflightIssue
from src.ui.constants import StatusIndicators
from src.ui.helpers import StatusMessages, UIComponents
from src.ui.state_store import UIStateStore
from src.campaign_dashboard import CampaignDashboard
from src.story_notebook import StoryNotebookManager
from src.artifact_counter import CampaignArtifactCounter

# Modern UI imports
from src.ui.theme import create_modern_theme, MODERN_CSS
from src.ui.process_session_tab_modern import create_process_session_tab_modern
from src.ui.api_key_manager import load_api_keys, save_api_keys
from src.ui.campaign_tab_modern import create_campaign_tab_modern
from src.ui.characters_tab_modern import (
    create_characters_tab_modern,
    character_tab_snapshot,
)
from src.ui.party_management_tab import create_party_management_tab
from src.ui.stories_output_tab_modern import create_stories_output_tab_modern
from src.ui.settings_tools_tab_modern import create_settings_tools_tab_modern
from src.ui.session_artifacts_tab import create_session_artifacts_tab, refresh_sessions as refresh_artifact_sessions
from src.ui.search_tab import create_search_tab
from src.ui.analytics_tab import create_analytics_tab
from src.ui.character_analytics_tab import create_character_analytics_tab
from src.ui.diagnostics_helpers import (
    run_health_check,
    export_diagnostics,
    list_conversations,
    clear_all_conversations,
)
from src.ui.campaign_dashboard_helpers import (
    campaign_overview_markdown,
    knowledge_summary_markdown,
    session_library_markdown,
    narrative_hint_markdown,
    diagnostics_markdown,
    chat_status_markdown,
    build_campaign_manifest,
)

from src.google_drive_auth import (
    get_auth_url,
    exchange_code_for_token,
    get_document_content,
    is_authenticated,
    revoke_credentials,
    authenticate_automatically
)
from src.restart_manager import RestartManager
from src.lock_manager import LockManager, LockTimeoutError
from src.ui.setup_wizard import create_setup_wizard

# Global dictionary to track cancel events for active processing sessions
# Key: session_id, Value: threading.Event
_active_cancel_events: Dict[str, Event] = {}

# Global lock for campaign modification operations to prevent race conditions
# Replaced by LockManager but kept for backward compatibility if needed
# campaign_modification_lock = RLock()

def ui_load_api_keys() -> Tuple[str, str, str, str]:
    """Load API keys on UI startup and format for Gradio."""
    keys = load_api_keys()
    groq_key = keys.get("GROQ_API_KEY", "")
    openai_key = keys.get("OPENAI_API_KEY", "")
    hf_key = keys.get("HUGGING_FACE_API_KEY", "")

    if groq_key or openai_key or hf_key:
        status = StatusMessages.success("API Keys", "Existing API keys loaded from `.env`.")
    else:
        status = StatusMessages.info("API Keys", "Enter your API keys to enable cloud services.")
    return groq_key, openai_key, hf_key, status

def _save_config_helper(group_name: str, allow_empty: bool = False, **kwargs) -> str:
    """
    Helper function to validate and save configuration settings.

    Args:
        group_name: Display name for the configuration group (e.g., "API Keys")
        allow_empty: If True, return info message when no changes to save
        **kwargs: Configuration parameters to validate and save

    Returns:
        Status message for UI display
    """
    try:
        from src.ui.config_manager import ConfigManager

        validated, errors = ConfigManager.validate_config(**kwargs)

        if errors:
            return StatusMessages.error(group_name, f"Validation failed: {'; '.join(errors)}")

        if not validated:
            if allow_empty:
                return StatusMessages.info(group_name, "No changes to save.")
            # Even if empty, we might want to show success for consistency
            return StatusMessages.info(group_name, "No changes to save.")

        ConfigManager.save_config(validated)
        return StatusMessages.success(
            group_name,
            f"{group_name} saved successfully. Restart the application to apply changes."
        )

    except Exception as e:
        logger.exception("Failed to save %s from UI", group_name)
        return StatusMessages.error(group_name, f"Failed to save: {e}")


def ui_save_api_keys(
    groq_api_key: str,
    openai_api_key: str,
    hugging_face_api_key: str
) -> str:
    """UI wrapper to save API keys from Gradio inputs."""
    return _save_config_helper(
        "API Keys",
        allow_empty=True,
        groq_api_key=groq_api_key if groq_api_key else None,
        openai_api_key=openai_api_key if openai_api_key else None,
        hugging_face_api_key=hugging_face_api_key if hugging_face_api_key else None,
    )


def ui_save_model_config(
    whisper_backend: str,
    whisper_model: str,
    whisper_language: str,
    diarization_backend: str,
    llm_backend: str,
) -> str:
    """UI wrapper to save model configuration."""
    return _save_config_helper(
        "Model Configuration",
        whisper_backend=whisper_backend,
        whisper_model=whisper_model,
        whisper_language=whisper_language,
        diarization_backend=diarization_backend,
        llm_backend=llm_backend,
    )


def ui_save_processing_config(
    chunk_length: int,
    chunk_overlap: int,
    sample_rate: int,
    clean_stale: bool,
    save_intermediate: bool,
) -> str:
    """UI wrapper to save processing settings."""
    return _save_config_helper(
        "Processing Settings",
        chunk_length_seconds=chunk_length,
        chunk_overlap_seconds=chunk_overlap,
        audio_sample_rate=sample_rate,
        clean_stale_clips=clean_stale,
        save_intermediate_outputs=save_intermediate,
    )


def ui_save_ollama_config(
    ollama_model: str,
    ollama_fallback: str,
    ollama_url: str,
) -> str:
    """UI wrapper to save Ollama settings."""
    return _save_config_helper(
        "Ollama Settings",
        allow_empty=True,
        ollama_model=ollama_model if ollama_model else None,
        ollama_fallback_model=ollama_fallback if ollama_fallback else None,
        ollama_base_url=ollama_url if ollama_url else None,
    )


def ui_save_advanced_config(
    groq_max_calls: int,
    groq_rate_period: float,
    groq_rate_burst: int,
    colab_poll: int,
    colab_timeout: int,
) -> str:
    """UI wrapper to save advanced settings."""
    return _save_config_helper(
        "Advanced Settings",
        groq_max_calls_per_second=groq_max_calls,
        groq_rate_limit_period_seconds=groq_rate_period,
        groq_rate_limit_burst=groq_rate_burst,
        colab_poll_interval=colab_poll,
        colab_timeout=colab_timeout,
    )


def ui_restart_application() -> str:
    """UI handler for application restart."""
    logger.info("Restart requested from UI")
    log_audit_event(
        "ui.app.restart",
        actor="ui",
        source="gradio",
        metadata={"restart_method": "ui_button"},
    )

    success = RestartManager.restart_application(delay_seconds=2.0)

    if success:
        return StatusMessages.success(
            "Restart Initiated",
            "Application is restarting... The page will reload automatically.",
            "Wait a few seconds, then refresh your browser if needed."
        )
    else:
        return StatusMessages.error(
            "Restart Failed",
            "Could not initiate automatic restart.",
            RestartManager.get_restart_instructions()
        )


PROJECT_ROOT = Path(__file__).resolve().parent
NOTEBOOK_CONTEXT = ""
story_manager = StoryNotebookManager()
character_profile_manager = CharacterProfileManager()
speaker_profile_manager = SpeakerProfileManager()
logger = get_logger(__name__)

# Create global artifact counter with 5-minute cache
_artifact_counter = CampaignArtifactCounter(
    output_dir=Config.OUTPUT_DIR,
    cache_ttl_seconds=300,
    logger=logger
)


def cancel_processing(session_id: str) -> str:
    """
    Cancel an active processing session.

    Args:
        session_id: The session ID to cancel

    Returns:
        Status message indicating whether cancellation was successful
    """
    cancel_event = _active_cancel_events.get(session_id)
    if cancel_event:
        cancel_event.set()
        logger.info(f"Cancellation requested for session '{session_id}'")
        return f"Cancellation requested for session '{session_id}'. The pipeline will stop at the next checkpoint."
    else:
        logger.warning(f"No active processing found for session '{session_id}'")
        return f"No active processing found for session '{session_id}'. It may have already completed or not started yet."


def _notebook_status() -> str:
    return StoryNotebookManager.format_notebook_status(NOTEBOOK_CONTEXT)


def _set_notebook_context(value: str) -> None:
    global NOTEBOOK_CONTEXT
    NOTEBOOK_CONTEXT = value


def _persist_active_campaign(campaign_id: Optional[str]) -> None:
    """Persist the active campaign selection while suppressing UI errors."""

    try:
        ui_state_store.save_active_campaign(campaign_id)
    except Exception as exc:  # pragma: no cover - defensive logging
        logger.warning("Failed to persist active campaign: %s", exc)


campaign_manager = CampaignManager()
ui_state_store = UIStateStore()
campaign_names = campaign_manager.get_campaign_names()


def _refresh_campaign_names() -> Dict[str, str]:
    """Forces a reload of campaign data from disk and returns an updated name map."""
    global campaign_names
    # Using a global lock for campaign list refresh to avoid reading partial writes
    try:
        with LockManager.lock("global", "campaign_list", timeout=10.0, owner_id="refresh_campaigns"):
            # By calling _load_campaigns() directly, we bypass any in-memory cache and
            # ensure the CampaignManager has the latest data from the campaigns.json file.
            # This is critical after operations like creation or deletion.
            campaign_manager.campaigns = campaign_manager._load_campaigns()
            campaign_names = campaign_manager.get_campaign_names()
            logger.debug(f"Refreshed campaign names: {list(campaign_names.values())}")
            return campaign_names
    except LockTimeoutError:
        logger.warning("Could not acquire global campaign list lock, returning cached names.")
        return campaign_names


def _campaign_id_from_name(display_name: Optional[str], campaign_names_map: Optional[Dict[str, str]] = None) -> Optional[str]:
    """Resolve campaign_id from display name."""
    if not display_name:
        return None

    # Use provided map or refresh if not provided
    names = campaign_names_map if campaign_names_map is not None else _refresh_campaign_names()

    for cid, name in names.items():
        if name == display_name:
            return cid
    return None


def _format_campaign_badge(campaign_id: Optional[str]) -> str:
    """Return campaign badge markdown for the Process tab."""
    if not campaign_id:
        return StatusMessages.warning(
            "Campaign",
            "No campaign selected. Use the Campaign Launcher to choose one."
        )

    campaign = campaign_manager.get_campaign(campaign_id)
    if not campaign:
        return StatusMessages.error(
            "Campaign",
            f"Campaign `{campaign_id}` was not found in campaigns.json."
        )

    party_line = "No party assigned yet."
    if campaign.party_id:
        party = party_manager.get_party(campaign.party_id)
        if party:
            party_line = f"Party `{campaign.party_id}`: {len(party.characters)} characters."
        else:
            party_line = f"Party `{campaign.party_id}` not found. Update party configuration."

    return StatusMessages.success(
        "Campaign Active",
        f"Working in **{campaign.name}** (`{campaign_id}`).",
        party_line,
    )


def _build_campaign_manifest(campaign_id: Optional[str]) -> str:
    return build_campaign_manifest(
        campaign_id,
        campaign_manager,
        party_manager,
        _artifact_counter
    )


def _campaign_summary_message(campaign_id: Optional[str], *, is_new: bool = False) -> str:
    """Return summary markdown for the active campaign."""
    if not campaign_id:
        return StatusMessages.warning(
            "No Campaign Selected",
            "Choose an existing campaign or create a new one to begin."
        )

    campaign = campaign_manager.get_campaign(campaign_id)
    if not campaign:
        return StatusMessages.error(
            "Campaign Not Found",
            f"Campaign `{campaign_id}` could not be loaded."
        )

    details = []
    if campaign.party_id:
        party = party_manager.get_party(campaign.party_id)
        if party:
            details.append(f"Party `{campaign.party_id}` with {len(party.characters)} characters.")
        else:
            details.append(f"Party `{campaign.party_id}` is missing.")
    else:
        details.append("No party linked yet.")

    prefix = "New campaign created." if is_new else "Campaign ready."
    return StatusMessages.success(
        "Campaign Loaded",
        f"{prefix} Active campaign: **{campaign.name}** (`{campaign_id}`).",
        " ".join(details),
    )


def _process_defaults_for_campaign(campaign_id: Optional[str]) -> Dict[str, Any]:
    """Return default process tab settings for the campaign."""
    defaults = {
        "party_selection": "Manual Entry",
        "num_speakers": 4,
        "skip_diarization": False,
        "skip_classification": False,
        "skip_snippets": True,
        "skip_knowledge": False,
    }

    if not campaign_id:
        return defaults

    campaign = campaign_manager.get_campaign(campaign_id)
    if not campaign:
        return defaults

    defaults["party_selection"] = campaign.party_id or "Manual Entry"
    defaults["num_speakers"] = campaign.settings.num_speakers
    defaults["skip_diarization"] = campaign.settings.skip_diarization
    defaults["skip_classification"] = campaign.settings.skip_classification
    defaults["skip_snippets"] = campaign.settings.skip_snippets
    defaults["skip_knowledge"] = campaign.settings.skip_knowledge
    return defaults


def _campaign_overview_markdown(campaign_id: Optional[str]) -> str:
    return campaign_overview_markdown(campaign_id, campaign_manager, _artifact_counter)


def _knowledge_summary_markdown(campaign_id: Optional[str]) -> str:
    return knowledge_summary_markdown(campaign_id)


def _character_overview_placeholder() -> str:
    return StatusMessages.info(
        "Character Overview",
        "Select a character to view their profile summary."
    )


def _character_tab_updates(
    campaign_id: Optional[str]
) -> Tuple[Any, Any, Any, Any, Any]:
    snapshot = character_tab_snapshot(campaign_id)
    characters = snapshot["characters"]
    default_value = characters[0] if characters else None
    dropdown_update = gr.update(choices=characters, value=default_value)
    table_update = gr.update(value=snapshot["table"])
    status_update = gr.update(value=snapshot["status"])
    overview_update = gr.update(value=_character_overview_placeholder())
    return status_update, table_update, dropdown_update, dropdown_update, overview_update


def _character_profiles_markdown(campaign_id: Optional[str]) -> str:
    snapshot = character_tab_snapshot(campaign_id)
    characters = snapshot["characters"]
    if not campaign_id or not characters:
        return snapshot["status"]

    manager = CharacterProfileManager()
    lines = ["### Characters"]
    for name in characters:
        profile = manager.get_profile(name)
        if not profile:
            continue
        class_name = profile.class_name or "Unknown class"
        level = profile.level if profile.level is not None else "n/a"
        last_updated = profile.last_updated or "unknown"
        lines.append(
            f"- **{profile.name}** ({class_name}, level {level}) - last updated {last_updated}"
        )
    return "\n".join(lines)


def _extract_party_dropdown_update(campaign_id: Optional[str]) -> Any:
    party_choices = [party for party in party_manager.list_parties() if party != "Manual Entry"]
    preferred_party = None
    if campaign_id:
        campaign = campaign_manager.get_campaign(campaign_id)
        if campaign and campaign.party_id and campaign.party_id in party_choices:
            preferred_party = campaign.party_id
    if preferred_party is None and party_choices:
        preferred_party = party_choices[0]
    return gr.update(choices=party_choices, value=preferred_party)



def _session_library_markdown(campaign_id: Optional[str]) -> str:
    return session_library_markdown(campaign_id, story_manager, campaign_manager)


def _narrative_hint_markdown(campaign_id: Optional[str]) -> str:
    return narrative_hint_markdown(campaign_id, story_manager)


def _diagnostics_markdown(campaign_id: Optional[str]) -> str:
    return diagnostics_markdown(campaign_id)


def _chat_status_markdown(campaign_id: Optional[str]) -> str:
    return chat_status_markdown(campaign_id)


def _resolve_audio_path(audio_file: Any) -> Path:
    """
    Normalize Gradio file input into a filesystem path with validation.

    Handles multiple input types from different Gradio versions and deployment
    environments: strings, Path objects, dicts, temporary file wrappers, and lists.

    Args:
        audio_file: Audio file input from Gradio (str, Path, dict, list, or object with .name)

    Returns:
        Path: Validated path to audio file

    Raises:
        ValueError: If no audio file provided or path doesn't exist
        TypeError: If audio file type is unsupported
    """
    if audio_file is None:
        raise ValueError("No audio file provided")

    candidate = audio_file

    # Handle list input (batch upload or multi-file selection)
    if isinstance(candidate, list):
        if not candidate:
            raise ValueError("Empty audio input list")
        candidate = candidate[0]

    # Handle dict input (some Gradio versions return dicts)
    if isinstance(candidate, dict):
        for key in ("name", "path", "tempfile"):
            value = candidate.get(key)
            if value:
                candidate = value
                break

    # Handle objects with .name attribute (file-like objects)
    # BUT skip Path objects which also have .name (returns just filename)
    if hasattr(candidate, "name") and not isinstance(candidate, (str, os.PathLike)):
        candidate = candidate.name

    # Validate type before converting to Path
    if not isinstance(candidate, (str, os.PathLike)):
        raise TypeError(f"Unsupported audio file type: {type(candidate)}")

    # Convert to Path and validate existence
    resolved_path = Path(candidate)
    if not resolved_path.exists():
        raise ValueError(f"Audio file not found: {resolved_path}")

    return resolved_path


def _create_processor_for_context(
    session_id: str,
    party_selection: Optional[str],
    character_names: str,
    player_names: str,
    num_speakers: Optional[int],
    language: Optional[str],
    campaign_id: Optional[str],
    transcription_backend: str,
    diarization_backend: str,
    classification_backend: str,
    *,
    allow_empty_names: bool = False,
    enable_audit_mode: bool = False,
    redact_prompts: bool = False,
    generate_scenes: bool = True,
    scene_summary_mode: str = "template",
) -> DDSessionProcessor:
    """Instantiate a session processor respecting party/manual inputs."""
    resolved_speakers = int(num_speakers) if num_speakers else 4
    resolved_language = language or "en"

    kwargs: Dict[str, Any] = {
        "session_id": session_id,
        "campaign_id": campaign_id,
        "num_speakers": resolved_speakers,
        "language": resolved_language,
        "transcription_backend": transcription_backend,
        "diarization_backend": diarization_backend,
        "classification_backend": classification_backend,
        "enable_audit_mode": enable_audit_mode,
        "redact_prompts": redact_prompts,
        "generate_scenes": generate_scenes,
        "scene_summary_mode": scene_summary_mode,
    }

    if party_selection and party_selection != "Manual Entry":
        kwargs["party_id"] = party_selection
    else:
        # Parse and validate character/player names with better edge case handling
        chars = [c.strip() for c in (character_names or "").split(',') if c.strip()]
        players = [p.strip() for p in (player_names or "").split(',') if p.strip()]

        # Remove duplicates while preserving order
        chars = list(dict.fromkeys(chars))
        players = list(dict.fromkeys(players))

        # Validate character names if required
        if not chars and not allow_empty_names:
            raise ValueError("Character names are required when using Manual Entry")

        if chars:
            kwargs["character_names"] = chars
        if players:
            kwargs["player_names"] = players

    return DDSessionProcessor(**kwargs)


def _format_highlighted_transcript(classification_file_path: Optional[str]) -> Optional[List[Tuple[str, str]]]:
    """
    Reads a classification JSON file and formats it for Gradio's HighlightedText component.
    """
    if not classification_file_path or not Path(classification_file_path).exists():
        return None
    
    try:
        with open(classification_file_path, 'r', encoding='utf-8') as f:
            segments = json.load(f)
        
        highlighted_text = []
        for segment in segments:
            text = segment.get("text", "")
            # Use the granular type if available, fall back to primary classification
            label = segment.get("classification_type", segment.get("classification", "UNKNOWN"))
            
            # Add speaker/character name for context, similar to a transcript
            actor = segment.get("character_name") or segment.get("speaker_name", "???")
            
            # Format with a newline for readability between segments
            formatted_text = f'{actor}: {text}\n'
            
            highlighted_text.append((formatted_text, label))
            
        return highlighted_text
    except Exception as e:
        logger.error(f"Failed to format highlighted transcript: {e}", exc_info=True)
        return None


def process_session(
    audio_file,
    session_id: str,
    party_selection: Optional[str],
    character_names: str,
    player_names: str,
    num_speakers: int,
    language: str,
    skip_diarization: bool,
    skip_classification: bool,
    skip_snippets: bool,
    skip_knowledge: bool,
    transcription_backend: str,
    diarization_backend: str,
    classification_backend: str,
    campaign_id: Optional[str] = None,
    enable_audit_mode: bool = False,
    redact_prompts: bool = False,
    generate_scenes: bool = True,
    scene_summary_mode: str = "template",
    progress=gr.Progress(),
) -> Dict:
    """Main session processing function with progress tracking."""
    try:
        if audio_file is None:
            return {"status": "error", "message": "Please upload an audio file."}

        resolved_session_id = session_id or "session"

        log_audit_event(
            "ui.session.process.start",
            actor="ui",
            source="gradio",
            metadata={
                "session_id": resolved_session_id,
                "party_selection": party_selection,
                "num_speakers": num_speakers,
                "skip_diarization": skip_diarization,
                "skip_classification": skip_classification,
                "skip_snippets": skip_snippets,
                "skip_knowledge": skip_knowledge,
                "transcription_backend": transcription_backend,
                "diarization_backend": diarization_backend,
                "classification_backend": classification_backend,
                "campaign_id": campaign_id,
                "enable_audit_mode": enable_audit_mode,
                "redact_prompts": redact_prompts,
                "generate_scenes": generate_scenes,
                "scene_summary_mode": scene_summary_mode,
            },
        )

        # Determine if using party config or manual entry
        processor = _create_processor_for_context(
            resolved_session_id,
            party_selection,
            character_names,
            player_names,
            num_speakers,
            language,
            campaign_id,
            transcription_backend,
            diarization_backend,
            classification_backend,
            allow_empty_names=False,
            enable_audit_mode=enable_audit_mode,
            redact_prompts=redact_prompts,
            generate_scenes=generate_scenes,
            scene_summary_mode=scene_summary_mode,
        )

        # Create cancel event for this session
        cancel_event = Event()
        _active_cancel_events[resolved_session_id] = cancel_event

        # Create progress callback for Gradio progress tracker
        def progress_callback(progress_value: float, message: str):
            """Update Gradio progress bar."""
            progress(progress_value, desc=message)

        try:
            # Acquire lock for the session to prevent concurrent processing of same session
            # Also lock campaign if modifying campaign data (which processing does)
            # Note: We use a long timeout because session processing is long running,
            # but we check lock availability first.
            # Actually, we just want to ensure no two processes run for SAME session.
            with LockManager.lock("session", resolved_session_id, timeout=1.0, owner_id="process_session"):
                # We also might want to "read lock" the campaign so it isn't deleted while processing
                # But we don't have read/write locks yet.

                pipeline_result = processor.process(
                    input_file=_resolve_audio_path(audio_file),
                    skip_diarization=skip_diarization,
                    skip_classification=skip_classification,
                    skip_snippets=skip_snippets,
                    skip_knowledge=skip_knowledge,
                    cancel_event=cancel_event,
                    progress_callback=progress_callback
                )
        except LockTimeoutError:
             return {
                "status": "error",
                "message": f"Session '{resolved_session_id}' is already being processed or locked.",
                "details": "Please wait for the current operation to finish or choose a different session ID."
            }
        finally:
            # Clean up cancel event regardless of outcome
            _active_cancel_events.pop(resolved_session_id, None)

        if not isinstance(pipeline_result, dict):
            log_audit_event(
                "ui.session.process.error",
                actor="ui",
                source="gradio",
                status="error",
                metadata={
                    "session_id": resolved_session_id,
                    "campaign_id": campaign_id,
                    "error": "Non-dict pipeline response",
                },
            )
            return {
                "status": "error",
                "message": "Pipeline did not return a result. Check preflight checks and logs for details.",
                "details": f"Unexpected pipeline response: {type(pipeline_result).__name__}",
            }

        output_files = pipeline_result.get("output_files") or {}

        def _read_output_file(key: str) -> str:
            path = output_files.get(key)
            if not path:
                return ""
            try:
                return Path(path).read_text(encoding="utf-8")
            except Exception:
                return ""

        snippet_export = pipeline_result.get("audio_segments") or {}
        snippet_payload = {
            "segments_dir": str(snippet_export.get("segments_dir")) if snippet_export.get("segments_dir") else None,
            "manifest": str(snippet_export.get("manifest")) if snippet_export.get("manifest") else None,
        }

        # IMPROVEMENT: Format the highlighted transcript for the new UI component
        highlighted_transcript = _format_highlighted_transcript(
            output_files.get("classification_json")
        )

        log_audit_event(
            "ui.session.process.complete",
            actor="ui",
            source="gradio",
            status="success",
            metadata={
                "session_id": resolved_session_id,
                "campaign_id": campaign_id,
                "outputs": list(output_files.keys()),
                "has_snippets": bool(snippet_payload["segments_dir"]),
            },
        )

        # Clear artifact cache for this campaign to ensure fresh counts on next UI refresh
        if campaign_id:
            _artifact_counter.clear_cache(campaign_id)
            logger.debug(f"Cleared artifact cache for campaign '{campaign_id}' after processing session '{resolved_session_id}'")

        return {
            "status": "success",
            "message": "Session processed successfully.",
            "full": _read_output_file("full"),
            "ic": _read_output_file("ic_only"),
            "ooc": _read_output_file("ooc_only"),
            "highlighted_transcript": highlighted_transcript, # Add new data to response
            "stats": pipeline_result.get("statistics") or {},
            "snippet": snippet_payload,
            "knowledge": pipeline_result.get("knowledge_extraction") or {},
            "output_files": output_files,
        }

    except CancelledError as e:
        logger.info(f"Session processing cancelled for '{resolved_session_id}': {e}")
        log_audit_event(
            "ui.session.process.cancelled",
            actor="user",
            source="gradio",
            status="cancelled",
            metadata={
                "session_id": resolved_session_id,
                "campaign_id": campaign_id,
            },
        )
        return {
            "status": "cancelled",
            "message": "Processing was cancelled by user.",
            "details": str(e),
        }

    except Exception as e:
        logger.exception("Error during session processing in Gradio UI")

        # Sanitize error message to avoid leaking internal paths
        error_msg = StatusMessages._sanitize_text(str(e))

        log_audit_event(
            "ui.session.process.error",
            actor="ui",
            source="gradio",
            status="error",
            metadata={
                "session_id": session_id or "session",
                "campaign_id": campaign_id,
                "error": error_msg,
            },
        )
        return {
            "status": "error",
            "message": error_msg,
            "details": f"See log for details: {get_log_file_path()}",
        }


def run_preflight_checks(
    party_selection,
    character_names,
    player_names,
    num_speakers,
    language,
    skip_diarization,
    skip_classification,
    transcription_backend,
    diarization_backend,
    classification_backend,
    campaign_id,
):
    """Run dependency checks before long-running processing."""
    try:
        processor = _create_processor_for_context(
            session_id="preflight_check",
            party_selection=party_selection,
            character_names=character_names or "",
            player_names=player_names or "",
            num_speakers=num_speakers,
            language=language,
            campaign_id=campaign_id,
            transcription_backend=transcription_backend,
            diarization_backend=diarization_backend,
            classification_backend=classification_backend,
            allow_empty_names=True,
        )
        processor.is_test_run = True
        issues = processor.run_preflight_checks_only(
            skip_diarization=bool(skip_diarization),
            skip_classification=bool(skip_classification),
        )

        if not issues:
            return StatusMessages.success(
                "Preflight Checks",
                "All systems ready for processing."
            )

        error_issues = [issue for issue in issues if issue.is_error()]
        warning_issues = [issue for issue in issues if not issue.is_error()]

        def _format_section(title: str, entries: List[PreflightIssue]) -> List[str]:
            if not entries:
                return []
            lines = [f"**{title}:**"]
            lines.extend(
                f"- `{issue.component}`: {issue.message}" for issue in entries
            )
            return lines

        sections: List[str] = []
        sections.extend(_format_section("Errors", error_issues))
        sections.extend(_format_section("Warnings", warning_issues))
        details = "\n".join(sections)

        if error_issues:
            return "\n".join([
                f"### {StatusIndicators.ERROR} Preflight Failed",
                "",
                "Resolve the blocking issues below before starting processing.",
                "",
                details,
            ])

        return "\n".join([
            f"### {StatusIndicators.WARNING} Preflight Warnings",
            "",
            "Processing can continue, but review the warnings below:",
            "",
            details,
        ])
    except Exception as exc:
        return StatusMessages.error(
            "Preflight Failed",
            "An unexpected error occurred while running the checks.",
            str(exc),
        )


# ============================================================================
# Pipeline Stage Control Functions
# ============================================================================

def update_skip_flags_from_stage(run_until_stage):
    """
    Automatically set skip flags based on 'Run Until Stage' selection.

    Args:
        run_until_stage: Selected stage to run until

    Returns:
        Tuple of (skip_diarization, skip_classification, skip_snippets, skip_knowledge)
    """
    stage_configs = {
        "full": (False, False, False, False),  # Run all stages
        "stage_4": (True, True, True, True),   # Stop after transcription
        "stage_5": (False, True, True, True),  # Stop after diarization
        "stage_6": (False, False, True, True), # Stop after classification
        "stage_7": (False, False, True, True), # Stop after outputs (skip snippets & knowledge)
    }

    skip_diarization, skip_classification, skip_snippets, skip_knowledge = stage_configs.get(
        run_until_stage, (False, False, False, False)
    )

    return (
        gr.update(value=skip_diarization),
        gr.update(value=skip_classification),
        gr.update(value=skip_snippets),
        gr.update(value=skip_knowledge),
    )


# ============================================================================
# Resume from Intermediate Outputs Functions
# ============================================================================

def refresh_resume_sessions():
    """Refresh the list of sessions with intermediate outputs."""
    from src.ui.intermediate_resume_helper import discover_sessions_with_intermediates

    sessions = discover_sessions_with_intermediates()
    if not sessions:
        return gr.update(choices=[], value=None)

    # Format as (label, value) tuples
    choices = [(name, path) for name, path in sessions]
    return gr.update(choices=choices, value=choices[0][1] if choices else None)


def update_resume_session_info(session_dir):
    """Update session info display when a session is selected."""
    if not session_dir:
        return StatusMessages.info(
            "Session Info",
            "Select a session to see details."
        )

    from src.ui.intermediate_resume_helper import get_session_info
    info = get_session_info(session_dir)

    if not info or not info.get("has_intermediates"):
        return StatusMessages.warning(
            "No Intermediate Outputs",
            f"Session {info.get('session_name', 'unknown')} does not have intermediate outputs saved."
        )

    return StatusMessages.success(
        info["session_name"],
        f"**Available stages:** {info['available_stages']}\n\n"
        f"**Path:** `{info['session_path']}`"
    )


def process_from_intermediate_ui(session_dir, from_stage, progress=gr.Progress()):
    """Process from intermediate outputs via UI."""
    if not session_dir:
        return StatusMessages.error(
            "No Session Selected",
            "Please select a session to resume."
        )

    from pathlib import Path
    from src.pipeline import DDSessionProcessor

    try:
        # Extract session ID from directory name
        session_path = Path(session_dir)
        session_id = session_path.name.split("_", 2)[-1]

        progress(0.1, desc="Initializing...")

        # Create processor
        processor = DDSessionProcessor(
            session_id=session_id,
            resume=False,
        )

        progress(0.2, desc=f"Loading stage {from_stage} outputs...")

        # Process from intermediate
        result = processor.process_from_intermediate(
            session_dir=session_path,
            from_stage=from_stage,
            skip_snippets=False,
            skip_knowledge=False,
        )

        progress(1.0, desc="Complete!")

        if result['success']:
            stats = result.get('statistics', {})
            return StatusMessages.success(
                "Processing Complete",
                f"✅ Successfully resumed from stage {from_stage}\n\n"
                f"**Statistics:**\n"
                f"- Total duration: {stats.get('total_duration_formatted', 'N/A')}\n"
                f"- IC percentage: {stats.get('ic_percentage', 0):.1f}%\n"
                f"- Total segments: {stats.get('total_segments', 0)}\n\n"
                f"**Outputs saved to:** `{session_dir}`"
            )
        else:
            return StatusMessages.error(
                "Processing Failed",
                "Processing from intermediate failed. Check logs for details."
            )

    except Exception as e:
        return StatusMessages.error(
            "Error",
            f"Failed to process from intermediate: {str(e)}"
        )


# Get available parties
party_manager = PartyConfigManager()
available_parties = party_manager.list_parties()

# Create modern theme
theme = create_modern_theme()

# Determine initial campaign context
persisted_campaign_id = ui_state_store.load_active_campaign(campaign_names.keys())
initial_campaign_id = persisted_campaign_id or next(iter(campaign_names.keys()), None)
initial_campaign_name = campaign_names.get(initial_campaign_id, "Manual Setup")
initial_badge = _format_campaign_badge(initial_campaign_id)
initial_summary = _campaign_summary_message(initial_campaign_id)
initial_manifest = _build_campaign_manifest(initial_campaign_id)

# Create Gradio interface
with gr.Blocks(
    title="D&D Session Processor",
    # theme=theme, # Removed theme argument for Gradio 6.0 compatibility
    # css=MODERN_CSS, # Removed css argument for Gradio 6.0 compatibility
) as demo:
    active_campaign_state = gr.State(value=initial_campaign_id)

    # Forward declaration for setup wizard callback
    def _on_setup_complete(campaign_name):
        """Callback when setup wizard completes successfully."""
        # The wizard already created the campaign, so we just need to load it
        # We'll trigger a refresh of campaign names and load the new campaign
        return _load_campaign(campaign_name, None)

    # Create main dashboard container (initially visible only if campaigns exist)
    has_campaigns = len(campaign_names) > 0

    # Setup Wizard (visible if no campaigns)
    # returns: container, finish_button, name_input_component
    wizard_container, wizard_finish_btn, wizard_name_input = create_setup_wizard(campaign_manager, _on_setup_complete)

    # Main Dashboard (visible if campaigns exist)
    with gr.Column(visible=has_campaigns, elem_id="main-dashboard") as main_dashboard:
        gr.Markdown("# Campaign Launcher")
        campaign_summary_md = gr.Markdown(value=initial_summary)

        with gr.Row():
            with gr.Column():
                with gr.Row(variant="compact"):
                    existing_campaign_dropdown = gr.Dropdown(
                        label="Existing Campaigns",
                        choices=list(campaign_names.values()),
                        value=initial_campaign_name if initial_campaign_id else None,
                        info="Load a campaign profile to apply its defaults.",
                        scale=10,
                    )
                    refresh_campaign_list_btn = gr.Button(
                        value="Refresh",
                        size="sm",
                        scale=0,
                        min_width=80,
                        variant="secondary",
                    )
                load_campaign_btn = UIComponents.create_action_button(
                    "Load Existing Campaign",
                    variant="primary",
                    size="md",
                    elem_id="load_campaign_btn"
                )

            with gr.Column():
                new_campaign_name = gr.Textbox(
                    label="New Campaign Name",
                    placeholder="New Campaign",
                    info="Provide an optional display name for the new campaign.",
                )
                start_new_campaign_btn = UIComponents.create_action_button(
                    "Start New Campaign",
                    variant="secondary",
                    size="md",
                )

        campaign_manifest_md = gr.Markdown(value=initial_manifest)

        gr.Markdown("---")

        available_parties, process_tab_refs = create_process_session_tab_modern(
            demo,
            refresh_campaign_names=_refresh_campaign_names,
            process_session_fn=process_session,
            preflight_fn=run_preflight_checks,
            campaign_manager=campaign_manager,
            active_campaign_state=active_campaign_state,
            campaign_badge_text=initial_badge,
            initial_campaign_name=initial_campaign_name if initial_campaign_id else "Manual Setup",
            cancel_fn=cancel_processing,
        )

        campaign_tab_refs = create_campaign_tab_modern(demo)
        characters_tab_refs = create_characters_tab_modern(
            demo,
            available_parties,
            refresh_campaign_names=_refresh_campaign_names,
            active_campaign_state=active_campaign_state,
            initial_campaign_id=initial_campaign_id,
        )
        create_party_management_tab(available_parties)
        stories_tab_refs = create_stories_output_tab_modern(demo)
        artifacts_tab_refs = create_session_artifacts_tab(demo)
        create_search_tab(Path.cwd(), ui_container=demo)
        create_analytics_tab(Path.cwd(), ui_container=demo)
        create_character_analytics_tab(character_profile_manager, campaign_manager, Path.cwd())
        settings_tab_refs = create_settings_tools_tab_modern(
            demo,
            story_manager=story_manager,
            refresh_campaign_names=_refresh_campaign_names,
            initial_campaign_id=initial_campaign_id,
            speaker_profile_manager=speaker_profile_manager,
            log_level_choices=list(LOG_LEVEL_CHOICES),
            initial_console_level=get_console_log_level(),
        )

    # Toggle visibility based on initial state
    if not has_campaigns:
        wizard_container.visible = True

    def _apply_console_log_level(level: Optional[str]) -> str:
        if not level:
            return StatusMessages.warning("Logging", "Select a log level before applying.")
        try:
            set_console_log_level(level)
            logger.info("Console log level updated via UI: %s", level)
            return StatusMessages.success("Logging", f"Console log level set to {level}.")
        except ValueError:
            logger.error("Unsupported log level selected in UI: %s", level)
            return StatusMessages.error("Logging", f"Unsupported log level: {level}")

    def _compute_process_updates(campaign_id: Optional[str]) -> Tuple:
        settings = _process_defaults_for_campaign(campaign_id)
        return (
            _format_campaign_badge(campaign_id),
            gr.update(value=""),
            gr.update(value=""),
            gr.update(value=""),
            gr.update(value=settings["party_selection"]),
            gr.update(value=settings["num_speakers"]),
            gr.update(value=settings["skip_diarization"]),
            gr.update(value=settings["skip_classification"]),
            gr.update(value=settings["skip_snippets"]),
            gr.update(value=settings["skip_knowledge"]),
            StatusMessages.info("Ready", "Campaign loaded. Configure session options and click Start Processing."),
            gr.update(visible=False),
            None, # highlighted_transcript
            "",
            "",
            StatusMessages.info("Statistics", "No statistics available."),
            StatusMessages.info("Snippet Export", "No snippet information available."),
        )

def _build_full_ui_update(campaign_id: Optional[str], campaign_names_map: Optional[Dict[str, str]] = None) -> tuple:
    """
    Builds a tuple of Gradio updates for a full UI refresh based on a campaign_id.
    This is the refactored, centralized UI update logic.

    Args:
        campaign_id: The ID of the campaign to load
        campaign_names_map: Optional pre-fetched map of campaign IDs to names to avoid re-fetching
    """
    process_updates = _compute_process_updates(campaign_id)

    # Use provided map or refresh if not provided
    # This optimization prevents double IO hits during campaign loads
    names_map = campaign_names_map if campaign_names_map is not None else _refresh_campaign_names()

    campaign_choices = list(names_map.values())
    selected_campaign_name = names_map.get(campaign_id) if campaign_id else None

    # Main dropdowns
    dropdown_update = gr.update(choices=campaign_choices, value=selected_campaign_name)
    campaign_selector_update = dropdown_update

    # Campaign Tab
    overview_update = gr.update(value=_campaign_overview_markdown(campaign_id))
    knowledge_update = gr.update(value=_knowledge_summary_markdown(campaign_id))
    session_library_update = gr.update(value=_session_library_markdown(campaign_id))

    # Characters Tab
    (
        character_profiles_update,
        character_table_update,
        character_select_update,
        character_export_update,
        character_overview_update,
    ) = _character_tab_updates(campaign_id)
    extract_party_update = _extract_party_dropdown_update(campaign_id)

    # Stories Tab
    story_session_update = gr.update(value=_session_library_markdown(campaign_id))
    narrative_hint_update = gr.update(value=_narrative_hint_markdown(campaign_id))

    # Settings & Tools Tab
    diagnostics_update = gr.update(value=_diagnostics_markdown(campaign_id))
    chat_update = gr.update(value=_chat_status_markdown(campaign_id))

    # Social Insights
    social_campaign_choices = ["All Campaigns"] + campaign_choices
    social_campaign_value = selected_campaign_name or "All Campaigns"
    social_campaign_update = gr.update(choices=social_campaign_choices, value=social_campaign_value)
    social_sessions = story_manager.list_sessions(campaign_id=campaign_id) if campaign_id else story_manager.list_sessions()
    social_session_update = gr.update(choices=social_sessions, value=social_sessions[0] if social_sessions else None)
    social_keyword_update = gr.update(value=StatusMessages.info("Social Insights", "Select a session and run analysis."))
    social_nebula_update = gr.update(value=None)

    # Artifact Explorer
    artifacts_session_picker_update = gr.update(choices=[], value=None)
    artifacts_file_list_update = gr.update(value=None)
    artifacts_file_preview_update = gr.update(value="")
    artifacts_download_button_update = gr.update(visible=False)
    artifacts_status_update = gr.update(value=StatusMessages.info("Ready", "Select a session to begin."))

    return (
        campaign_id,
        dropdown_update,
        *process_updates,
        overview_update,
        knowledge_update,
        session_library_update,
        campaign_selector_update,
        character_profiles_update,
        character_table_update,
        character_select_update,
        character_export_update,
        character_overview_update,
        extract_party_update,
        story_session_update,
        narrative_hint_update,
        diagnostics_update,
        chat_update,
        social_campaign_update,
        social_session_update,
        social_keyword_update,
        social_nebula_update,
        artifacts_session_picker_update,
        artifacts_file_list_update,
        artifacts_file_preview_update,
        artifacts_download_button_update,
        artifacts_status_update,
    )

    def _load_campaign(display_name: Optional[str], current_campaign_id: Optional[str], *current_ui_states):
        """
        Loads a campaign and updates all relevant UI components.
        Includes an optimization to prevent a full UI refresh if the selected campaign
        is already active, which is the root cause of BUG-20251103-026.
        """
        names_map = _refresh_campaign_names()
        campaign_id = _campaign_id_from_name(display_name, names_map) or current_campaign_id or initial_campaign_id

        # Why: This is the fix for BUG-20251103-026. The original check was correct,
        # but returning a series of `gr.update()` objects, even empty ones, still
        # triggers a full refresh cycle in Gradio. The correct way to signal "no change"
        # is to return the component's current value for each output.
        # We accept the current state of all UI components via `*current_ui_states`
        # and return them directly, which effectively cancels the update.
        if campaign_id == current_campaign_id and display_name == names_map.get(campaign_id):
            logger.info(f"Skipping reload for unchanged campaign: {campaign_id}")

            # Construct the no-op return tuple.
            # The order must exactly match the `load_campaign_outputs` list.
            # 1. active_campaign_state: campaign_id (no change)
            # 2. campaign_summary_md: A message indicating it's already loaded.
            # 3. campaign_manifest_md: The current manifest (no change)
            # 4. The rest of the UI components: Pass their current values back.
            no_change_summary = StatusMessages.info("Campaign Active", f"Campaign **{names_map.get(campaign_id)}** is already loaded.")

            # The first two elements of current_ui_states correspond to
            # campaign_summary_md and campaign_manifest_md
            # The rest line up with shared_ui_outputs[1:]

            # The outputs are: active_campaign_state, campaign_summary_md, campaign_manifest_md, ...
            # The inputs are: display_name, current_campaign_id, campaign_summary_md, campaign_manifest_md, ...
            # So, current_ui_states[0] is the current summary markdown.
            # current_ui_states[1] is the current manifest markdown.
            # And so on.

            current_manifest = current_ui_states[1]

            return (
                campaign_id,
                no_change_summary,
                current_manifest,
                *current_ui_states[2:] # Return the rest of the states as they are
            )

        summary = _campaign_summary_message(campaign_id)
        manifest = _build_campaign_manifest(campaign_id)

        ui_updates = _build_full_ui_update(campaign_id, campaign_names_map=names_map)
        _persist_active_campaign(campaign_id)

        # The return tuple for a full update includes the newly generated content
        return (
            ui_updates[0],  # campaign_id
            summary,
            manifest,
            *ui_updates[1:],  # The rest of the UI updates
        )

    def _create_new_campaign(name: str):
        proposed_name = name.strip() if name else ""

        # Validate that campaign name is not empty/whitespace-only
        if not proposed_name:
            error_msg = StatusMessages.error(
                "Invalid Campaign Name",
                "Campaign name cannot be empty or contain only whitespace.",
                "Please provide a valid campaign name."
            )
            # Return error message and keep UI in current state
            return (
                gr.update(), # Keep current campaign_id
                error_msg,
                gr.update(), # Keep current manifest
                gr.update(value=name), # Keep the input value to show what was invalid
                *[gr.update()] * 39, # Keep rest of UI unchanged
            )

        try:
            # Lock global campaign list for creation
            with LockManager.lock("global", "campaign_list", timeout=10.0, owner_id="create_campaign"):
                new_campaign_id, _ = campaign_manager.create_blank_campaign(name=proposed_name)
                # Refresh name map after creation
                names_map = _refresh_campaign_names()

            knowledge = CampaignKnowledgeBase(campaign_id=new_campaign_id)
            if not knowledge.knowledge_file.exists():
                knowledge._save_knowledge()
            _set_notebook_context("")
            _persist_active_campaign(new_campaign_id)

            summary = _campaign_summary_message(new_campaign_id, is_new=True)
            manifest = _build_campaign_manifest(new_campaign_id)

            ui_updates = _build_full_ui_update(new_campaign_id, campaign_names_map=names_map)

            return (
                ui_updates[0], # new_campaign_id
                summary,
                manifest,
                gr.update(value=""), # Clear the new campaign name textbox
                *ui_updates[1:], # The rest of the UI updates
            )
        except LockTimeoutError:
            # Why: This is part of the fix for BUG-20251103-005. This exception is
            # specific and expected, so we provide a user-friendly message.
            error_msg = StatusMessages.error(
                "System Busy",
                "Another user or process is currently modifying the campaign list.",
                "Please wait a moment and try again."
            )
            return (gr.update(), error_msg, gr.update(), gr.update(), *[gr.update()] * 39)
        except (IOError, OSError) as e:
            # Why: Catching specific file system errors provides better context
            # than a generic "Exception".
            logger.error("Campaign creation failed due to a file system error: %s", e)
            error_msg = StatusMessages.error(
                "File System Error",
                "Could not create the new campaign due to a file system issue.",
                "Check permissions and available disk space."
            )
            return (gr.update(), error_msg, gr.update(), gr.update(), *[gr.update()] * 39)
        except Exception as e:
            # Why: This is the fallback for unexpected errors. We log the full
            # exception for debugging but show a generic error to the user.
            logger.exception("An unexpected error occurred during campaign creation")
            error_msg = StatusMessages.error(
                "An Unexpected Error Occurred",
                "Failed to create the campaign due to an unforeseen issue.",
                f"Error details have been logged. Please report this issue."
            )
            return (gr.update(), error_msg, gr.update(), gr.update(), *[gr.update()] * 39)

    def _handle_rename_campaign(campaign_display_name: str, new_name: str, active_campaign_id: Optional[str]):
        """Handler for the rename campaign button."""
        # Initial fetch to resolve ID
        initial_map = _refresh_campaign_names()
        campaign_id = _campaign_id_from_name(campaign_display_name, campaign_names_map=initial_map) or active_campaign_id

        if not campaign_id:
            return StatusMessages.error("Rename Failed", "No campaign selected to rename."), *[gr.update()] * 42

        if not new_name or not new_name.strip():
            return StatusMessages.error("Rename Failed", "New campaign name cannot be empty."), *[gr.update()] * 42

        try:
            # Lock specific campaign and global list
            with LockManager.lock("campaign", campaign_id, owner_id="rename_campaign"):
                with LockManager.lock("global", "campaign_list", owner_id="rename_campaign"):
                    success = campaign_manager.rename_campaign(campaign_id, new_name)
                    if not success:
                        return StatusMessages.error("Rename Failed", f"Could not rename to '{new_name}'. Check logs."), *[gr.update()] * 42

                    # On success, refresh everything
                    updated_map = _refresh_campaign_names()

            ui_updates = _build_full_ui_update(campaign_id, campaign_names_map=updated_map)

            return (
                StatusMessages.success("Rename Successful", f"Campaign renamed to '{new_name}'."),
                *ui_updates
            )
        except LockTimeoutError:
            return StatusMessages.error("System Busy", "Campaign is locked by another operation."), *[gr.update()] * 42

    def _handle_delete_campaign(campaign_display_name: str, active_campaign_id: Optional[str]):
        """Handler for the delete campaign button."""
        initial_map = _refresh_campaign_names()
        campaign_id = _campaign_id_from_name(campaign_display_name, campaign_names_map=initial_map) or active_campaign_id

        if not campaign_id:
            return StatusMessages.error("Delete Failed", "No campaign selected to delete."), None, None, *[gr.update()] * 42

        try:
            # Lock specific campaign and global list
            with LockManager.lock("campaign", campaign_id, owner_id="delete_campaign"):
                with LockManager.lock("global", "campaign_list", owner_id="delete_campaign"):
                    success = campaign_manager.delete_campaign(campaign_id)
                    if not success:
                        return StatusMessages.error("Delete Failed", f"Could not delete campaign '{campaign_display_name}'. Check logs."), None, None, *[gr.update()] * 42

                    # On success, refresh and load the first available campaign
                    updated_map = _refresh_campaign_names()

            new_active_id = next(iter(updated_map.keys()), None)
            _persist_active_campaign(new_active_id)

            summary = _campaign_summary_message(new_active_id)
            manifest = _build_campaign_manifest(new_active_id)
            ui_updates = _build_full_ui_update(new_active_id, campaign_names_map=updated_map)

            return (
                StatusMessages.success("Delete Successful", f"Campaign '{campaign_display_name}' has been deleted."),
                summary,
                manifest,
                *ui_updates
            )
        except LockTimeoutError:
            return StatusMessages.error("System Busy", "Campaign is locked by another operation."), None, None, *[gr.update()] * 42

    def _refresh_campaign_tab(campaign_display_name: Optional[str], current_campaign_id: Optional[str]):
        """Refresh the Campaign tab with current data for the selected campaign."""
        # Single refresh
        campaign_names_map = _refresh_campaign_names()

        campaign_id = _campaign_id_from_name(campaign_display_name, campaign_names_map=campaign_names_map) or current_campaign_id

        campaign_choices = list(campaign_names_map.values())
        selected_campaign_name = campaign_names_map.get(campaign_id) if campaign_id else None

        if campaign_id:
            _artifact_counter.clear_cache(campaign_id)

        return (
            gr.update(choices=campaign_choices, value=selected_campaign_name),
            _campaign_overview_markdown(campaign_id),
            _knowledge_summary_markdown(campaign_id),
            _session_library_markdown(campaign_id),
            gr.update(value=""), # Clear rename textbox
        )

    # This list defines all the UI components that need to be updated during a full refresh.
    shared_ui_outputs = [
        active_campaign_state,
        existing_campaign_dropdown,
        process_tab_refs["campaign_badge"],
        process_tab_refs["session_id_input"],
        process_tab_refs["character_names_input"],
        process_tab_refs["player_names_input"],
        process_tab_refs["party_selection_input"],
        process_tab_refs["num_speakers_input"],
        process_tab_refs["skip_diarization_input"],
        process_tab_refs["skip_classification_input"],
        process_tab_refs["skip_snippets_input"],
        process_tab_refs["skip_knowledge_input"],
        process_tab_refs["status_output"],
        process_tab_refs["results_section"],
        process_tab_refs["full_output"],
        process_tab_refs["ic_output"],
        process_tab_refs["ooc_output"],
        process_tab_refs["stats_output"],
        process_tab_refs["snippet_output"],
        campaign_tab_refs["overview"],
        campaign_tab_refs["knowledge"],
        campaign_tab_refs["session_library"],
        campaign_tab_refs["campaign_selector"],
        characters_tab_refs["profiles"],
        characters_tab_refs["table"],
        characters_tab_refs["character_dropdown"],
        characters_tab_refs["export_dropdown"],
        characters_tab_refs["overview"],
        characters_tab_refs["extract_party_dropdown"],
        stories_tab_refs["session_list"],
        stories_tab_refs["narrative_hint"],
        settings_tab_refs["diagnostics_output"],
        settings_tab_refs["chat_output"],
        settings_tab_refs["social_campaign_selector"],
        settings_tab_refs["social_session_dropdown"],
        settings_tab_refs["social_keyword_output"],
        settings_tab_refs["social_nebula_output"],
        artifacts_tab_refs["session_picker"],
        artifacts_tab_refs["file_list"],
        artifacts_tab_refs["file_preview"],
        artifacts_tab_refs["download_button"],
        artifacts_tab_refs["status_display"],
    ]

    load_campaign_outputs = [
        active_campaign_state,
        campaign_summary_md,
        campaign_manifest_md,
        *shared_ui_outputs[1:] # Skip active_campaign_state as it's already first
    ]

    # Wire up wizard completion to show dashboard and load campaign
    # Note: The wizard internal logic handles creation and hiding the wizard container.
    # We just need to show the dashboard and load the new data.
    wizard_finish_btn.click(
        fn=lambda: gr.update(visible=True), # Show main dashboard
        outputs=main_dashboard
    ).then(
        fn=_on_setup_complete,
        inputs=[wizard_name_input], # Use the wizard's text input
        outputs=load_campaign_outputs
    )
    
    create_campaign_outputs = [
        active_campaign_state,
        campaign_summary_md,
        campaign_manifest_md,
        new_campaign_name, # To clear it
        *shared_ui_outputs[1:]
    ]

    rename_campaign_outputs = [
        campaign_tab_refs["manage_status"],
        *shared_ui_outputs
    ]

    delete_campaign_outputs = [
        campaign_tab_refs["manage_status"],
        campaign_summary_md,
        campaign_manifest_md,
        *shared_ui_outputs
    ]

    settings_tab_refs["save_api_keys_btn"].click(
        fn=ui_save_api_keys,
        inputs=[
            settings_tab_refs["groq_api_key_input"],
            settings_tab_refs["openai_api_key_input"],
            settings_tab_refs["hugging_face_api_key_input"],
        ],
        outputs=settings_tab_refs["api_keys_status"],
    )

    settings_tab_refs["save_model_config_btn"].click(
        fn=ui_save_model_config,
        inputs=[
            settings_tab_refs["whisper_backend_dropdown"],
            settings_tab_refs["whisper_model_dropdown"],
            settings_tab_refs["whisper_language_dropdown"],
            settings_tab_refs["diarization_backend_dropdown"],
            settings_tab_refs["llm_backend_dropdown"],
        ],
        outputs=settings_tab_refs["model_config_status"],
    )

    settings_tab_refs["save_processing_config_btn"].click(
        fn=ui_save_processing_config,
        inputs=[
            settings_tab_refs["chunk_length_input"],
            settings_tab_refs["chunk_overlap_input"],
            settings_tab_refs["audio_sample_rate_input"],
            settings_tab_refs["clean_stale_clips_checkbox"],
            settings_tab_refs["save_intermediate_outputs_checkbox"],
        ],
        outputs=settings_tab_refs["processing_config_status"],
    )

    settings_tab_refs["save_ollama_config_btn"].click(
        fn=ui_save_ollama_config,
        inputs=[
            settings_tab_refs["ollama_model_input"],
            settings_tab_refs["ollama_fallback_model_input"],
            settings_tab_refs["ollama_base_url_input"],
        ],
        outputs=settings_tab_refs["ollama_config_status"],
    )

    settings_tab_refs["save_advanced_config_btn"].click(
        fn=ui_save_advanced_config,
        inputs=[
            settings_tab_refs["groq_max_calls_input"],
            settings_tab_refs["groq_rate_period_input"],
            settings_tab_refs["groq_rate_burst_input"],
            settings_tab_refs["colab_poll_interval_input"],
            settings_tab_refs["colab_timeout_input"],
        ],
        outputs=settings_tab_refs["advanced_config_status"],
    )

    demo.load(
        fn=ui_load_api_keys,
        outputs=[
            settings_tab_refs["groq_api_key_input"],
            settings_tab_refs["openai_api_key_input"],
            settings_tab_refs["hugging_face_api_key_input"],
            settings_tab_refs["api_keys_status"],
        ],
    )

    settings_tab_refs["apply_log_level_btn"].click(
        fn=_apply_console_log_level,
        inputs=settings_tab_refs["log_level_dropdown"],
        outputs=settings_tab_refs["log_level_status"],
    )

    def trigger_restart_confirmation():
        return (
            gr.update(visible=True),
            gr.update(value="### 🔄 Confirm Restart\n\nAre you sure you want to restart the application? This will terminate any active processing jobs and cannot be undone."),
            gr.update(value=False),
            gr.update(interactive=False),
            "restart"
        )

    settings_tab_refs["restart_app_btn"].click(
        fn=trigger_restart_confirmation,
        outputs=[
            settings_tab_refs["confirmation_modal"],
            settings_tab_refs["confirmation_message"],
            settings_tab_refs["confirmation_checkbox"],
            settings_tab_refs["confirm_button"],
            settings_tab_refs["action_to_confirm"],
        ],
    )

    # Diagnostics event handlers
    settings_tab_refs["run_health_check_btn"].click(
        fn=run_health_check,
        outputs=settings_tab_refs["diagnostics_output"],
    )

    settings_tab_refs["export_diagnostics_btn"].click(
        fn=lambda: export_diagnostics()[0],  # Return only the message
        outputs=settings_tab_refs["diagnostics_output"],
    )

    # Confirmation Modal Logic
    def handle_checkbox_change(checked):
        return gr.update(interactive=checked)

    settings_tab_refs["confirmation_checkbox"].change(
        fn=handle_checkbox_change,
        inputs=settings_tab_refs["confirmation_checkbox"],
        outputs=settings_tab_refs["confirm_button"],
    )

    def cancel_confirmation():
        return gr.update(visible=False), None, gr.update(value=""), gr.update(value=False), gr.update(interactive=False)

    settings_tab_refs["cancel_button"].click(
        fn=cancel_confirmation,
        outputs=[
            settings_tab_refs["confirmation_modal"],
            settings_tab_refs["action_to_confirm"],
            settings_tab_refs["countdown_display"],
            settings_tab_refs["confirmation_checkbox"],
            settings_tab_refs["confirm_button"],
        ],
    )

    def confirm_action_with_countdown(action):
        import time
        for i in range(5, 0, -1):
            yield (
                gr.update(visible=True),
                f"### Action will proceed in **{i}**...",
                gr.update(),
                gr.update()
            )
            time.sleep(1)

        if action == "restart":
            status_update = ui_restart_application()
            yield (
                gr.update(visible=False),
                "",
                status_update,
                gr.update()
            )
        elif action == "clear_conversations":
            status_update = clear_all_conversations()
            yield (
                gr.update(visible=False),
                "",
                gr.update(),
                status_update,
            )

        # Reset modal state after completion
        yield cancel_confirmation()


    settings_tab_refs["confirm_button"].click(
        fn=confirm_action_with_countdown,
        inputs=[settings_tab_refs["action_to_confirm"]],
        outputs=[
            settings_tab_refs["confirmation_modal"],
            settings_tab_refs["countdown_display"],
            settings_tab_refs["restart_status"],
            settings_tab_refs["chat_output"],
        ],
    )


    # Conversation management event handlers
    settings_tab_refs["list_conversations_btn"].click(
        fn=list_conversations,
        outputs=settings_tab_refs["chat_output"],
    )

    def trigger_clear_conversations_confirmation():
        return (
            gr.update(visible=True),
            gr.update(value="### 🗑️ Confirm Clear Conversations\n\nAre you sure you want to permanently delete all conversation history? This action cannot be undone."),
            gr.update(value=False),
            gr.update(interactive=False),
            "clear_conversations"
        )

    settings_tab_refs["clear_all_conversations_btn"].click(
        fn=trigger_clear_conversations_confirmation,
        outputs=[
            settings_tab_refs["confirmation_modal"],
            settings_tab_refs["confirmation_message"],
            settings_tab_refs["confirmation_checkbox"],
            settings_tab_refs["confirm_button"],
            settings_tab_refs["action_to_confirm"],
        ],
    )

    demo.load(
        fn=refresh_artifact_sessions,
        outputs=artifacts_tab_refs["session_picker"]
    )

    def _init_load_campaign():
        """Initialize the UI state from the persisted campaign ID on page load."""
        # Ensure campaign names are up to date
        names = _refresh_campaign_names()
        # Load the persisted ID from disk
        persisted = ui_state_store.load_active_campaign(names.keys())
        # Fallback to the first available campaign if persistence is empty/invalid
        campaign_id = persisted or next(iter(names.keys()), None)

        logger.info(f"Initializing UI with campaign: {campaign_id}")

        # Generate all UI updates for this campaign
        summary = _campaign_summary_message(campaign_id)
        manifest = _build_campaign_manifest(campaign_id)
        ui_updates = _build_full_ui_update(campaign_id, campaign_names_map=names)

        return (
            ui_updates[0], # active_campaign_state
            summary,
            manifest,
            *ui_updates[1:] # Rest of UI updates
        )

    # Restore active campaign state on page load
    demo.load(
        fn=_init_load_campaign,
        outputs=load_campaign_outputs
    )

    def _handle_refresh_campaign_list():
        # Refresh once and return
        names = _refresh_campaign_names()
        return gr.update(choices=list(names.values()))

    refresh_campaign_list_btn.click(
        fn=_handle_refresh_campaign_list,
        outputs=existing_campaign_dropdown,
    )

    # Why: This completes the fix for BUG-20251103-026. The `_load_campaign` function
    # now requires the current state of all UI components to be passed in so it can
    # return them unchanged if the campaign is not being switched. This change wires
    # up all the necessary components from `shared_ui_outputs` and `campaign_summary_md`
    # etc., as inputs to the event handler.
    load_campaign_btn.click(
        fn=_load_campaign,
        inputs=[
            existing_campaign_dropdown,
            active_campaign_state,
            campaign_summary_md,
            campaign_manifest_md,
            *shared_ui_outputs[1:]
        ],
        outputs=load_campaign_outputs,
    )

    start_new_campaign_btn.click(
        fn=_create_new_campaign,
        inputs=[new_campaign_name],
        outputs=create_campaign_outputs,
    )

    # Pipeline Stage Control
    process_tab_refs["run_until_stage_input"].change(
        fn=update_skip_flags_from_stage,
        inputs=process_tab_refs["run_until_stage_input"],
        outputs=[
            process_tab_refs["skip_diarization_input"],
            process_tab_refs["skip_classification_input"],
            process_tab_refs["skip_snippets_input"],
            process_tab_refs["skip_knowledge_input"],
        ],
    )

    # Resume from Intermediate Outputs controls
    process_tab_refs["resume_refresh_btn"].click(
        fn=refresh_resume_sessions,
        outputs=process_tab_refs["resume_session_dropdown"],
    )

    process_tab_refs["resume_session_dropdown"].change(
        fn=update_resume_session_info,
        inputs=process_tab_refs["resume_session_dropdown"],
        outputs=process_tab_refs["resume_session_info"],
    )

    process_tab_refs["resume_process_btn"].click(
        fn=process_from_intermediate_ui,
        inputs=[
            process_tab_refs["resume_session_dropdown"],
            process_tab_refs["resume_stage_dropdown"],
        ],
        outputs=process_tab_refs["resume_status"],
    )

    # Campaign Tab interactive controls
    campaign_tab_refresh_args = {
        "fn": _refresh_campaign_tab,
        "inputs": [campaign_tab_refs["campaign_selector"], active_campaign_state],
        "outputs": [
            campaign_tab_refs["campaign_selector"],
            campaign_tab_refs["overview"],
            campaign_tab_refs["knowledge"],
            campaign_tab_refs["session_library"],
            campaign_tab_refs["new_campaign_name_input"],
        ],
    }
    campaign_tab_refs["campaign_selector"].change(**campaign_tab_refresh_args)
    campaign_tab_refs["refresh_btn"].click(**campaign_tab_refresh_args)

    # Wire new campaign management buttons
    campaign_tab_refs["rename_campaign_btn"].click(
        fn=_handle_rename_campaign,
        inputs=[
            campaign_tab_refs["campaign_selector"],
            campaign_tab_refs["new_campaign_name_input"],
            active_campaign_state
        ],
        outputs=rename_campaign_outputs
    )

    campaign_tab_refs["delete_campaign_btn"].click(
        fn=_handle_delete_campaign,
        inputs=[
            campaign_tab_refs["campaign_selector"],
            active_campaign_state
        ],
        outputs=delete_campaign_outputs,
        # Add confirmation dialog for safety
        js="() => confirm('Are you sure you want to permanently delete this campaign? This action cannot be undone.')"
    )

    # Why: This is the implementation for UX-17 (Keyboard Shortcuts).
    # Gradio doesn't natively support keyboard shortcuts, so this HTML component
    # injects a small JavaScript snippet into the page. The script listens for
    # global keydown events. When a user presses Ctrl+L, it finds the button
    # with the ID `load_campaign_btn` and programmatically clicks it.
    gr.HTML(
        """
        <script>
            document.addEventListener('keydown', function(event) {
                // Shortcut for loading a campaign: Ctrl + L
                if (event.ctrlKey && event.key === 'l') {
                    event.preventDefault(); // Prevent default browser action
                    const loadButton = document.getElementById('load_campaign_btn');
                    if (loadButton) {
                        loadButton.click();
                        console.log('Ctrl+L pressed, "Load Campaign" clicked.');
                    } else {
                        console.error('Could not find load campaign button for shortcut.');
                    }
                }
            });
        </script>
        """,
        visible=False  # This component is only for JS, it shouldn't be visible
    )


def is_port_in_use(port):
    """Check if a port is already in use"""
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        try:
            s.bind(('127.0.0.1', port))
            return False
        except OSError:
            return True


if __name__ == "__main__":
    # Check if port is already in use
    if is_port_in_use(7860):
        logger.error("=" * 80)
        logger.error("WARNING: Gradio app already running on port 7860!")
        logger.error("=" * 80)
        logger.error("Another instance of the application is already running.")
        logger.error("Please close the existing instance before starting a new one.")
        logger.info("To kill the existing process:")
        logger.info("  1. Find the process ID (PID) monitoring port 7860:")
        logger.info("     netstat -ano | findstr :7860 | findstr LISTENING")
        logger.info("  2. The PID appears in the last column on the LISTENING entry.")
        logger.info("  3. Kill the process using its PID: taskkill /PID <process_id> /F")
        logger.error("=" * 80)
        sys.exit(1)

    logger.info("Starting D&D Session Processor - Modern UI")
    logger.info("Access the interface at http://127.0.0.1:7860")
    demo.launch(
        server_name="127.0.0.1",
        server_port=7860,
        share=False,
        show_error=True
    )