"""Tests for session management functionality."""

from pathlib import Path
import tempfile
from datetime import datetime

import session_manager


def test_create_session_id():
    """Test session ID generation."""
    session_id = session_manager.create_session_id()
    assert isinstance(session_id, str)
    assert len(session_id) == 15  # YYYYMMDD_HHMMSS format
    assert "_" in session_id


def test_create_session():
    """Test session creation."""
    run_config = {
        "snowflake_user": "test_user",
        "period_id": "322"
    }
    output_dir = "./output"
    files = ["file1.txt", "file2.csv"]

    session = session_manager.create_session(run_config, output_dir, files)

    assert "id" in session
    assert "created_at" in session
    assert session["run_config"] == run_config
    assert session["output_directory"] == output_dir
    assert session["files"] == files
    assert session["status"] == "generated"
    assert session["delivery_info"] is None


def test_save_and_load_sessions(tmp_path):
    """Test saving and loading sessions."""
    # Temporarily override SESSIONS_FILE
    original_file = session_manager.SESSIONS_FILE
    test_file = tmp_path / "test_sessions.json"
    session_manager.SESSIONS_FILE = test_file

    try:
        sessions = [
            {
                "id": "20260119_120000",
                "created_at": datetime.now().isoformat(),
                "run_config": {},
                "output_directory": "./output",
                "files": ["file1.txt"],
                "status": "generated",
                "delivery_info": None,
            }
        ]

        # Save
        session_manager.save_sessions(sessions)
        assert test_file.exists()

        # Load
        loaded = session_manager.load_sessions()
        assert len(loaded) == 1
        assert loaded[0]["id"] == "20260119_120000"

    finally:
        session_manager.SESSIONS_FILE = original_file


def test_add_session(tmp_path):
    """Test adding a new session."""
    original_file = session_manager.SESSIONS_FILE
    test_file = tmp_path / "test_sessions.json"
    session_manager.SESSIONS_FILE = test_file

    try:
        sessions = []
        new_session = {
            "id": "20260119_130000",
            "created_at": datetime.now().isoformat(),
            "run_config": {},
            "output_directory": "./output",
            "files": [],
            "status": "generated",
            "delivery_info": None,
        }

        updated = session_manager.add_session(new_session, sessions)

        assert len(updated) == 1
        assert updated[0]["id"] == "20260119_130000"
        # Verify it was saved
        assert test_file.exists()

    finally:
        session_manager.SESSIONS_FILE = original_file


def test_get_session():
    """Test retrieving a specific session."""
    sessions = [
        {"id": "session1", "status": "generated"},
        {"id": "session2", "status": "delivered"},
    ]

    session = session_manager.get_session("session2", sessions)
    assert session is not None
    assert session["id"] == "session2"
    assert session["status"] == "delivered"

    # Test non-existent session
    session = session_manager.get_session("session3", sessions)
    assert session is None


def test_update_session_status(tmp_path):
    """Test updating session status."""
    original_file = session_manager.SESSIONS_FILE
    test_file = tmp_path / "test_sessions.json"
    session_manager.SESSIONS_FILE = test_file

    try:
        sessions = [
            {
                "id": "session1",
                "created_at": datetime.now().isoformat(),
                "status": "generated",
                "delivery_info": None,
            }
        ]

        delivery_info = {
            "delivered_at": datetime.now().isoformat(),
            "host": "ftp.example.com",
            "files_uploaded": 5,
        }

        updated = session_manager.update_session_status(
            "session1",
            "delivered",
            sessions,
            delivery_info
        )

        assert updated[0]["status"] == "delivered"
        assert updated[0]["delivery_info"] == delivery_info
        assert "updated_at" in updated[0]

    finally:
        session_manager.SESSIONS_FILE = original_file


def test_delete_session(tmp_path):
    """Test deleting a session."""
    original_file = session_manager.SESSIONS_FILE
    test_file = tmp_path / "test_sessions.json"
    session_manager.SESSIONS_FILE = test_file

    try:
        sessions = [
            {"id": "session1", "status": "generated"},
            {"id": "session2", "status": "delivered"},
        ]

        updated = session_manager.delete_session("session1", sessions)

        assert len(updated) == 1
        assert updated[0]["id"] == "session2"

    finally:
        session_manager.SESSIONS_FILE = original_file


def test_format_session_display():
    """Test session display formatting."""
    session = {
        "id": "20260119_120000",
        "created_at": "2026-01-19T12:00:00",
        "status": "generated",
        "files": ["file1.txt", "file2.txt", "file3.txt"],
    }

    display = session_manager.format_session_display(session)

    assert "📝" in display  # generated emoji
    assert "2026-01-19" in display
    assert "3 files" in display


def test_get_session_files_absolute():
    """Test getting absolute file paths from session."""
    # Create temporary directory with test files
    with tempfile.TemporaryDirectory() as tmpdir:
        output_dir = Path(tmpdir) / "output"
        output_dir.mkdir()

        # Create test files
        file1 = output_dir / "file1.txt"
        file1.write_text("test")

        subdir = output_dir / "subdir"
        subdir.mkdir()
        file2 = subdir / "file2.txt"
        file2.write_text("test")

        # Test with relative paths
        session = {
            "output_directory": str(output_dir),
            "files": ["file1.txt", "subdir/file2.txt"],
        }

        abs_files = session_manager.get_session_files_absolute(session)

        assert len(abs_files) == 2
        assert all(isinstance(f, Path) for f in abs_files)
        assert all(f.is_absolute() for f in abs_files)
        assert all(f.exists() for f in abs_files)

        # Test with absolute paths
        session2 = {
            "output_directory": str(output_dir),
            "files": [str(file1.absolute()), str(file2.absolute())],
        }

        abs_files2 = session_manager.get_session_files_absolute(session2)
        assert len(abs_files2) == 2
        assert all(f.exists() for f in abs_files2)