"""Pytest configuration and fixtures for webterm tests."""

from __future__ import annotations

import asyncio
from typing import TYPE_CHECKING
from unittest.mock import AsyncMock, MagicMock

import pytest

from webterm.config import App, Config
from webterm.local_server import LocalServer
from webterm.poller import Poller
from webterm.session_manager import SessionManager

if TYPE_CHECKING:
    from collections.abc import AsyncGenerator, Generator
    from pathlib import Path


@pytest.fixture
def event_loop() -> Generator[asyncio.AbstractEventLoop, None, None]:
    """Create an event loop for async tests."""
    loop = asyncio.new_event_loop()
    yield loop
    loop.close()


@pytest.fixture
def sample_terminal_app() -> App:
    """Create a sample terminal app configuration."""
    return App(
        name="Test Terminal",
        slug="test-terminal",
        terminal=True,
        command="echo hello",
    )


@pytest.fixture
def sample_config(sample_terminal_app: App) -> Config:
    """Create a sample configuration with a terminal app."""
    return Config(apps=[sample_terminal_app])


@pytest.fixture
def tmp_config_path(tmp_path: Path) -> Path:
    """Create a temporary config path."""
    return tmp_path / "config"


@pytest.fixture
def mock_request() -> MagicMock:
    """Create a mock request with common attributes."""
    request = MagicMock()
    request.headers = {}
    request.secure = False
    request.query = {}
    return request


@pytest.fixture
def screen_buffer_factory():
    def _make(rows: list[str], width: int = 80):
        return [
            [
                {
                    "data": c,
                    "fg": "default",
                    "bg": "default",
                    "bold": False,
                    "italics": False,
                    "underscore": False,
                    "reverse": False,
                }
                for c in (row + " " * width)[:width]
            ]
            for row in rows
        ]

    return _make


@pytest.fixture
def mock_session():
    session = MagicMock()
    session.get_screen_has_changes = AsyncMock(return_value=False)
    session.get_screen_state = AsyncMock(return_value=(80, 24, [], True))
    return session


@pytest.fixture
def poller() -> Poller:
    """Create a Poller instance."""
    return Poller()


@pytest.fixture
def session_manager(poller: Poller, tmp_path: Path, sample_terminal_app: App) -> SessionManager:
    """Create a SessionManager instance."""
    return SessionManager(poller, tmp_path, [sample_terminal_app])


@pytest.fixture
async def local_server(
    tmp_config_path: Path, sample_config: Config
) -> AsyncGenerator[LocalServer, None]:
    """Create a LocalServer instance for testing."""
    server = LocalServer(
        str(tmp_config_path),
        sample_config,
        host="127.0.0.1",
        port=0,  # Use random available port
    )
    yield server
    # Cleanup
    server.force_exit()