"""Migration and compatibility layer between old Session and new Session/Operation.

This module provides backward-compatible wrappers to allow existing code to work
with the new Session → Operation architecture without immediate refactoring.
"""

from typing import Dict, List, Optional, Any
import operation_manager
from pathlib import Path


def migrate_old_session_to_operation(old_session: Dict[str, Any]) -> Dict[str, Any]:
    """Convert an old session dict to a new operation dict.

    Args:
        old_session: Old session structure

    Returns:
        New operation structure
    """
    return {
        "id": old_session.get('id'),
        "created_at": old_session.get('created_at'),
        "operation_type": "generation+delivery",  # Assume both
        "run_config": old_session.get('run_config', {}),
        "output_directory": old_session.get('output_directory', ''),
        "files": old_session.get('files', []),
        "status": old_session.get('status', 'completed'),
        "delivery_info": old_session.get('delivery_info'),
        "execution_start": old_session.get('created_at'),
        "execution_end": old_session.get('updated_at'),
        "error": None,
    }


def wrap_operation_as_old_session(operation: Dict[str, Any]) -> Dict[str, Any]:
    """Wrap an operation to look like an old session for backward compatibility.

    Args:
        operation: New operation structure

    Returns:
        Old session structure
    """
    return {
        "id": operation.get('id'),
        "created_at": operation.get('created_at'),
        "run_config": operation.get('run_config', {}),
        "output_directory": operation.get('output_directory', ''),
        "files": operation.get('files', []),
        "status": operation.get('status', 'generated'),
        "delivery_info": operation.get('delivery_info'),
        "updated_at": operation.get('updated_at', operation.get('created_at')),
    }


# ============================================================================
# BACKWARD-COMPATIBLE FUNCTION WRAPPERS
# ============================================================================

def create_session(
    run_config: Dict[str, Any],
    output_directory: str,
    files: List[str]
) -> Dict[str, Any]:
    """Backward-compatible: Creates a single-operation session.

    For compatibility with existing code, this creates a session with
    one operation automatically.
    """
    operation = operation_manager.create_operation(
        run_config=run_config,
        output_directory=output_directory,
        files=files,
        operation_type="generation+delivery"
    )

    # Return operation wrapped as old session for compatibility
    return wrap_operation_as_old_session(operation)


def create_session_id() -> str:
    """Backward-compatible: Generate session/operation ID."""
    return operation_manager.create_operation_id()


def format_session_display(session_or_operation: Dict[str, Any]) -> str:
    """Backward-compatible: Format for display."""
    # Check if it's an operation
    if 'operation_type' in session_or_operation:
        return operation_manager.format_operation_display(session_or_operation)
    else:
        # Treat as old session
        return operation_manager.format_operation_display(
            migrate_old_session_to_operation(session_or_operation)
        )


def get_session_files_absolute(session_or_operation: Dict[str, Any]) -> List[Path]:
    """Backward-compatible: Get absolute file paths."""
    return operation_manager.get_operation_files_absolute(session_or_operation)


def update_session_status(
    session_id: str,
    status: str,
    sessions: List[Dict[str, Any]],
    delivery_info: Optional[Dict[str, Any]] = None
) -> List[Dict[str, Any]]:
    """Backward-compatible: Update session/operation status."""
    # For now, update the operation within its session
    # This maintains backward compatibility
    for session in sessions:
        if session.get('id') == session_id:
            session['status'] = status
            session['updated_at'] = operation_manager.datetime.now().isoformat()
            if delivery_info:
                session['delivery_info'] = delivery_info
            break

    # Save using old session manager for compatibility
    from session_manager import save_sessions as old_save_sessions
    old_save_sessions(sessions)
    return sessions


def get_session(
    session_id: str,
    sessions: List[Dict[str, Any]]
) -> Optional[Dict[str, Any]]:
    """Backward-compatible: Get session by ID."""
    for session in sessions:
        if session.get('id') == session_id:
            return session
    return None


def add_session(
    session: Dict[str, Any],
    sessions: List[Dict[str, Any]]
) -> List[Dict[str, Any]]:
    """Backward-compatible: Add session to list."""
    sessions.insert(0, session)
    from session_manager import save_sessions as old_save_sessions
    old_save_sessions(sessions)
    return sessions


def load_sessions() -> List[Dict[str, Any]]:
    """Backward-compatible: Load sessions from old location."""
    from session_manager import load_sessions as old_load_sessions
    return old_load_sessions()


def save_sessions(sessions: List[Dict[str, Any]]) -> None:
    """Backward-compatible: Save sessions to old location."""
    from session_manager import save_sessions as old_save_sessions
    old_save_sessions(sessions)


def delete_session(
    session_id: str,
    sessions: List[Dict[str, Any]]
) -> List[Dict[str, Any]]:
    """Backward-compatible: Delete session."""
    from session_manager import delete_session as old_delete_session
    return old_delete_session(session_id, sessions)


# Re-export for compatibility
SESSIONS_FILE = Path("tmp/streamlit_sessions.json")