"""Tests unitaires pour le client Pronote via pronotepy.

Ce module vérifie le comportement du client ``PronoteClient`` et de son
protocole ``PronoteClientProtocol``. Tous les tests sont unitaires et
utilisent des mocks pour éviter tout accès réseau réel à Pronote.
"""

from __future__ import annotations

from datetime import date, datetime

import pronotepy
import pytest
import pytest_mock
from pydantic import SecretStr

from pronote_sync.config.settings import PronoteSettings
from pronote_sync.models.agenda import Lesson, LessonStatus
from pronote_sync.models.homework import Homework
from pronote_sync.models.message import Message, MessageType
from pronote_sync.sources.pronote.client import PronoteClient, PronoteClientProtocol

# --- Protocol tests ---


def test_protocol_methods(mocker: pytest_mock.MockerFixture) -> None:
    """Vérifie que le protocole PronoteClientProtocol expose les méthodes attendues.

    :param mocker: Fixture pytest-mock pour le mocking.
    :return: None
    """
    assert hasattr(PronoteClientProtocol, "get_messages")
    assert hasattr(PronoteClientProtocol, "get_informations")
    assert hasattr(PronoteClientProtocol, "get_agenda_fallback")


# --- Client with mocked pronotepy ---


@pytest.fixture
def pronote_settings() -> PronoteSettings:
    """Fournit des paramètres Pronote valides pour les tests.

    :return: Instance de PronoteSettings avec des valeurs par défaut.
    :rtype: PronoteSettings
    """
    return PronoteSettings(
        username="testuser",
        password=SecretStr("testpass"),
        ent="testent",
    )


@pytest.fixture
def empty_pronote_settings() -> PronoteSettings:
    """Fournit des paramètres Pronote vides pour les tests.

    :return: Instance de PronoteSettings avec tous les champs à None.
    :rtype: PronoteSettings
    """
    return PronoteSettings(username=None, password=None, ent=None)


def test_get_messages_success(
    mocker: pytest_mock.MockerFixture, pronote_settings: PronoteSettings
) -> None:
    """Vérifie que get_messages retourne une liste de Message en cas de succès.

    :param mocker: Fixture pytest-mock pour le mocking.
    :param pronote_settings: Paramètres Pronote valides.
    :return: None
    """
    # Mock du client pronotepy
    mock_client = mocker.MagicMock()
    mock_discussion = mocker.MagicMock()
    mock_discussion.subject = "Test Subject"
    mock_message = mocker.MagicMock()
    mock_message.id = "msg-123"
    mock_message.content = "Test message content"
    mock_message.author = "Teacher Test"
    mock_message.created = datetime(2024, 9, 1, 10, 0, 0)
    mock_message.seen = True
    mock_discussion.messages = [mock_message]
    mock_client.discussions.return_value = [mock_discussion]
    mocker.patch("pronotepy.Client", return_value=mock_client)

    client = PronoteClient(pronote_settings)
    messages = client.get_messages()

    assert isinstance(messages, list)
    assert len(messages) == 1
    message = messages[0]
    assert isinstance(message, Message)
    assert message.id == "msg-123"
    assert message.type == MessageType.DISCUSSION
    assert message.title == "Test Subject"
    assert message.content == "Test message content"
    assert message.author == "Teacher Test"
    assert message.date == datetime(2024, 9, 1, 10, 0, 0)
    assert message.read is True


def test_get_messages_empty_on_error(
    mocker: pytest_mock.MockerFixture, pronote_settings: PronoteSettings
) -> None:
    """Vérifie que get_messages retourne une liste vide en cas d'erreur API.

    :param mocker: Fixture pytest-mock pour le mocking.
    :param pronote_settings: Paramètres Pronote valides.
    :return: None
    """
    mock_client = mocker.MagicMock()
    mock_client.discussions.side_effect = pronotepy.PronoteAPIError("API error")
    mocker.patch("pronotepy.Client", return_value=mock_client)

    client = PronoteClient(pronote_settings)
    messages = client.get_messages()

    assert messages == []


def test_get_informations_success(
    mocker: pytest_mock.MockerFixture, pronote_settings: PronoteSettings
) -> None:
    """Vérifie que get_informations retourne une liste de Message en cas de succès.

    :param mocker: Fixture pytest-mock pour le mocking.
    :param pronote_settings: Paramètres Pronote valides.
    :return: None
    """
    mock_client = mocker.MagicMock()
    mock_info = mocker.MagicMock()
    mock_info.id = "info-456"
    mock_info.title = "Important Info"
    mock_info.content.return_value = "Important content"
    mock_info.author = "Admin"
    mock_info.creation_date = datetime(2024, 9, 2, 14, 30, 0)
    mock_info.read = False
    mock_info.survey = True
    mock_client.information_and_surveys.return_value = [mock_info]
    mocker.patch("pronotepy.Client", return_value=mock_client)

    client = PronoteClient(pronote_settings)
    messages = client.get_informations()

    assert isinstance(messages, list)
    assert len(messages) == 1
    message = messages[0]
    assert isinstance(message, Message)
    assert message.id == "info-456"
    assert message.type == MessageType.SURVEY
    assert message.title == "Important Info"
    assert message.content == "Important content"
    assert message.author == "Admin"
    assert message.date == datetime(2024, 9, 2, 14, 30, 0)
    assert message.read is False


def test_get_informations_empty_on_error(
    mocker: pytest_mock.MockerFixture, pronote_settings: PronoteSettings
) -> None:
    """Vérifie que get_informations retourne une liste vide en cas d'erreur API.

    :param mocker: Fixture pytest-mock pour le mocking.
    :param pronote_settings: Paramètres Pronote valides.
    :return: None
    """
    mock_client = mocker.MagicMock()
    mock_client.information_and_surveys.side_effect = pronotepy.PronoteAPIError("API error")
    mocker.patch("pronotepy.Client", return_value=mock_client)

    client = PronoteClient(pronote_settings)
    messages = client.get_informations()

    assert messages == []


def test_get_agenda_fallback_success(
    mocker: pytest_mock.MockerFixture, pronote_settings: PronoteSettings
) -> None:
    """Vérifie que get_agenda_fallback retourne un tuple de listes en cas de succès.

    :param mocker: Fixture pytest-mock pour le mocking.
    :param pronote_settings: Paramètres Pronote valides.
    :return: None
    """
    mock_client = mocker.MagicMock()

    # Mock des cours
    mock_lesson = mocker.MagicMock()
    mock_lesson.id = "lesson-789"
    mock_lesson.start = datetime(2024, 9, 1, 8, 0, 0)
    mock_lesson.end = datetime(2024, 9, 1, 9, 30, 0)
    mock_lesson.subject = mocker.MagicMock()
    mock_lesson.subject.name = "Maths"
    mock_lesson.teacher_names = ["Prof A", "Prof B"]
    mock_lesson.classrooms = ["Salle 101", "Salle 102"]
    mock_lesson.group_name = "Classe 1"
    mock_lesson.canceled = False
    mock_content = mocker.MagicMock()
    mock_content.description = "Lesson content"
    mock_lesson.content = mock_content

    # Mock des devoirs
    mock_hw = mocker.MagicMock()
    mock_hw.id = "hw-101"
    mock_hw.subject = mocker.MagicMock()
    mock_hw.subject.name = "Maths"
    mock_hw.date = date(2024, 9, 15)
    mock_hw.description = "Do your homework"

    mock_client.lessons.return_value = [mock_lesson]
    mock_client.homework.return_value = [mock_hw]
    mocker.patch("pronotepy.Client", return_value=mock_client)

    client = PronoteClient(pronote_settings)
    lessons, homeworks = client.get_agenda_fallback(date(2024, 9, 1), date(2024, 9, 30))

    assert isinstance(lessons, list)
    assert len(lessons) == 1
    lesson = lessons[0]
    assert isinstance(lesson, Lesson)
    assert lesson.id == "lesson-789"
    assert lesson.start == datetime(2024, 9, 1, 8, 0, 0)
    assert lesson.end == datetime(2024, 9, 1, 9, 30, 0)
    assert lesson.subject == "Maths"
    assert lesson.teachers == ("Prof A", "Prof B")
    assert lesson.rooms == ("Salle 101", "Salle 102")
    assert lesson.group == "Classe 1"
    assert lesson.status == LessonStatus.NORMAL
    assert lesson.content == "Lesson content"

    assert isinstance(homeworks, list)
    assert len(homeworks) == 1
    homework = homeworks[0]
    assert isinstance(homework, Homework)
    assert homework.id == "hw-101"
    assert homework.subject == "Maths"
    assert homework.teachers == ()
    assert homework.assigned_on is None
    assert homework.due_on == date(2024, 9, 15)
    assert homework.text == "Do your homework"
    assert homework.html == "Do your homework"


def test_get_agenda_fallback_empty_on_error(
    mocker: pytest_mock.MockerFixture, pronote_settings: PronoteSettings
) -> None:
    """Vérifie que get_agenda_fallback retourne des listes vides en cas d'erreur API.

    :param mocker: Fixture pytest-mock pour le mocking.
    :param pronote_settings: Paramètres Pronote valides.
    :return: None
    """
    mock_client = mocker.MagicMock()
    mock_client.lessons.side_effect = pronotepy.PronoteAPIError("API error")
    mocker.patch("pronotepy.Client", return_value=mock_client)

    client = PronoteClient(pronote_settings)
    lessons, homeworks = client.get_agenda_fallback(date(2024, 9, 1), date(2024, 9, 30))

    assert lessons == []
    assert homeworks == []


def test_missing_credentials_returns_empty(empty_pronote_settings: PronoteSettings) -> None:
    """Vérifie que les méthodes retournent une liste vide si les identifiants sont manquants.

    :param empty_pronote_settings: Paramètres Pronote avec tous les champs à None.
    :return: None
    """
    client = PronoteClient(empty_pronote_settings)

    messages = client.get_messages()
    assert messages == []

    informations = client.get_informations()
    assert informations == []

    lessons, homeworks = client.get_agenda_fallback(date(2024, 9, 1), date(2024, 9, 30))
    assert lessons == []
    assert homeworks == []


def test_password_used_in_connection(
    mocker: pytest_mock.MockerFixture, pronote_settings: PronoteSettings
) -> None:
    """Vérifie que le mot de passe est bien utilisé pour la connexion.

    :param mocker: Fixture pytest-mock pour le mocking.
    :param pronote_settings: Paramètres Pronote valides.
    :return: None
    """
    # Patch pronotepy.Client to return our mock
    from pronote_sync.sources.pronote import client as client_module

    mock_client = mocker.MagicMock()
    mock_discussion = mocker.MagicMock()
    mock_message = mocker.MagicMock()
    mock_message.id = "msg-123"
    mock_message.content = "Test"
    mock_message.author = "Teacher"
    mock_message.created = datetime(2024, 9, 1, 10, 0, 0)
    mock_message.seen = False
    mock_discussion.messages = [mock_message]
    mock_discussion.subject = "Test Subject"
    mock_client.discussions.return_value = [mock_discussion]

    # Patch pronotepy.Client to return our mock
    mocker.patch.object(client_module, "pronotepy")
    client_module.pronotepy.Client = lambda u, p, e: mock_client  # type: ignore[attr-defined]  # noqa: ARG005

    # Setup mock client
    mock_client = mocker.MagicMock()
    mock_discussion = mocker.MagicMock()
    mock_message = mocker.MagicMock()
    mock_message.id = "msg-123"
    mock_message.content = "Test"
    mock_message.author = "Teacher"
    mock_message.created = datetime(2024, 9, 1, 10, 0, 0)
    mock_message.seen = False
    mock_discussion.messages = [mock_message]
    mock_discussion.subject = "Test Subject"
    mock_client.discussions.return_value = [mock_discussion]

    # Patch pronotepy.Client to return our mock
    mocker.patch("pronote_sync.sources.pronote.client.pronotepy.Client", return_value=mock_client)

    client = PronoteClient(pronote_settings)
    _ = client.get_messages()

    # Vérifie que le client a été créé avec le mot de passe
    # Le mock de Client doit avoir été appelé avec username, password, ent
    client_class_mock = client_module.pronotepy.Client  # type: ignore[attr-defined]
    client_class_mock.assert_called_once()
    call_args = client_class_mock.call_args
    assert call_args is not None
    assert len(call_args.args) >= 3
    assert call_args.args[0] == "testuser"
    assert call_args.args[1] == "testpass"
    assert call_args.args[2] == "testent"


# Ensure trailing newline