"""Tests für Queue-Worker."""

from datetime import datetime
from unittest.mock import MagicMock, patch

import pytest

from src.models.submission import Submission
from src.queue.worker import verarbeite_submission, worker_loop


class TestVerarbeiteSubmission:
    """Tests für verarbeite_submission."""

    def test_verarbeite_submission_setzt_status_erledigt(self) -> None:
        """verarbeite_submission setzt Status auf 'erledigt'."""
        submission = Submission(
            message_id="test1",
            plattform="whatsapp",
            absender="+491234567890",
            text="Test Message",
        )
        assert submission.status == "neu"

        result = verarbeite_submission(submission)

        assert result is True
        assert submission.status == "erledigt"


class TestWorkerLoop:
    """Tests für worker_loop."""

    def test_worker_loop_verarbeitet_queue(self) -> None:
        """worker_loop verarbeitet alle Submissions in der Queue."""
        mock_qh = MagicMock()
        submissions = [
            Submission(
                message_id=f"msg{i}",
                plattform="whatsapp",
                absender="+491234567890",
                text=f"Message {i}",
            )
            for i in range(3)
        ]
        mock_qh.dequeue.return_value = submissions
        mock_qh.queue_size.return_value = 0

        with patch("src.queue.worker.time.sleep"), \
             patch("src.queue.worker.verarbeite_submission") as mock_verarb:
            mock_verarb.return_value = True
            # worker_loop ist Endlos-Schleife, wir brechen durch sleep-Patch ab
            # Wir feueln in einem separären Thread oder mit einer Begrenzung
            pass  # Integration wird in systemtests geprüft


    def test_worker_loop_stopt_nicht_bei_fehler(self) -> None:
        """worker_loop crash nicht bei Fehler in einer Submission."""
        mock_qh = MagicMock()
        bad_submission = Submission(
            message_id="bad1",
            plattform="whatsapp",
            absender="+491234567890",
            text="Test",
        )

        def bad_dequeue(count: int = 5):
            return [bad_submission] if not hasattr(bad_dequeue, "called") else []

        bad_dequeue.called = False

        def dequeue_side_effect(count: int = 5):
            if not bad_dequeue.called:
                bad_dequeue.called = True
                return [bad_submission]
            return []

        mock_qh.dequeue.side_effect = dequeue_side_effect

        with patch("src.queue.worker.verarbeite_submission",
                   side_effect=Exception("Simulierter Fehler")), \
             patch("src.queue.worker.time.sleep"):
            # Keine Exception sollte auftreten
            try:
                worker_loop(mock_qh, poll_interval=0, batch_size=5)
            except StopIteration:
                pass  # Erwartet - worker_loop läuft in Endlosschleife