"""Tests für src.error_handler — Einheitliche JSON-Error-Responses."""

from __future__ import annotations

from pydantic import BaseModel
from werkzeug.exceptions import BadRequest

from src.app import create_app
from src.config import settings
from src.error_handler import register_error_handlers


class TestErrorHandlers:
    """Tests fuer zentrale Error-Handler."""

    def setup_method(self) -> None:
        """Jeder Test bekommt eine frische App mit Error-Handlern."""
        self.app = create_app()
        self.app.queue_handler.redis.close()  # Redis-Verbindung trennen
        self.client = self.app.test_client()

    def test_404_returnt_json(self) -> None:
        """Nichtexistente Route → 404 mit JSON."""
        response = self.client.get("/nicht_existent")
        assert response.status_code == 404
        data = response.get_json()
        assert data["error"] == "Not Found"
        assert isinstance(data["message"], str)
        assert data["status"] == 404

    def test_400_returnt_json(self) -> None:
        """HTTP 400 → JSON-Response mit einheitlichem Format."""

        @self.app.route("/abort400")
        def abort400():
            raise BadRequest("Ungueltige Eingabe")

        response = self.client.get("/abort400")
        assert response.status_code == 400
        data = response.get_json()
        assert data["error"] == "Bad Request"
        assert data["status"] == 400

    def test_422_returnt_json(self) -> None:
        """ValidationError → 422 mit JSON."""

        class UserSchema(BaseModel):
            name: str

        @self.app.route("/validate", methods=["POST"])
        def validate():
            UserSchema.model_validate({})
            return "ok"

        response = self.client.post("/validate", json={})
        assert response.status_code == 422
        data = response.get_json()
        assert data["status"] == 422
        assert "error" in data

    def test_500_returnt_json(self) -> None:
        """Interner Serverfehler → 500 mit JSON."""

        @self.app.route("/crash")
        def crash():
            raise RuntimeError("Test-Fehler")

        response = self.client.get("/crash")
        assert response.status_code == 500
        data = response.get_json()
        assert data["error"] == "Internal Server Error"
        assert data["status"] == 500

    def test_error_handler_alle_status_codes(self) -> None:
        """Alle Error-Handler sind registriert."""
        specs = self.app.error_handler_spec
        found = set()
        for blueprint_name, codes in (specs or {}).items():
            if bp_codes := codes:
                for code in bp_codes:
                    if code is not None:
                        found.add(int(code))
        for required in (400, 401, 404, 422, 500):
            assert required in found, f"Error handler {required} fehlt"