import logging

from unittest.mock import Mock

import pytest

from sanic import Sanic
from sanic.response import text
from sanic.server.async_server import AsyncioServer
from sanic.signals import Event
from sanic.touchup.schemes.ode import OptionalDispatchEvent


try:
    from unittest.mock import AsyncMock
except ImportError:
    from asyncmock import AsyncMock  # type: ignore


@pytest.fixture
def app_one():
    app = Sanic("One")

    @app.get("/one")
    async def one(request):
        return text("one")

    return app


@pytest.fixture
def app_two():
    app = Sanic("Two")

    @app.get("/two")
    async def two(request):
        return text("two")

    return app


@pytest.fixture(autouse=True)
def clean():
    Sanic._app_registry = {}
    yield


def test_serve_same_app_multiple_tuples(app_one, run_multi):
    app_one.prepare(port=23456)
    app_one.prepare(port=23457)

    logs = run_multi(app_one)
    assert (
        "sanic.root",
        logging.INFO,
        "Goin' Fast @ http://127.0.0.1:23456",
    ) in logs
    assert (
        "sanic.root",
        logging.INFO,
        "Goin' Fast @ http://127.0.0.1:23457",
    ) in logs


def test_serve_multiple_apps(app_one, app_two, run_multi):
    app_one.prepare(port=23456)
    app_two.prepare(port=23457)

    logs = run_multi(app_one)
    assert (
        "sanic.root",
        logging.INFO,
        "Goin' Fast @ http://127.0.0.1:23456",
    ) in logs
    assert (
        "sanic.root",
        logging.INFO,
        "Goin' Fast @ http://127.0.0.1:23457",
    ) in logs


def test_listeners_on_secondary_app(app_one, app_two, run_multi):
    app_one.prepare(port=23456)
    app_two.prepare(port=23457)

    before_start = AsyncMock()
    after_start = AsyncMock()
    before_stop = AsyncMock()
    after_stop = AsyncMock()

    app_two.before_server_start(before_start)
    app_two.after_server_start(after_start)
    app_two.before_server_stop(before_stop)
    app_two.after_server_stop(after_stop)

    run_multi(app_one)

    before_start.assert_awaited_once()
    after_start.assert_awaited_once()
    before_stop.assert_awaited_once()
    after_stop.assert_awaited_once()


@pytest.mark.parametrize(
    "events",
    (
        (Event.HTTP_LIFECYCLE_BEGIN,),
        (Event.HTTP_LIFECYCLE_BEGIN, Event.HTTP_LIFECYCLE_COMPLETE),
        (
            Event.HTTP_LIFECYCLE_BEGIN,
            Event.HTTP_LIFECYCLE_COMPLETE,
            Event.HTTP_LIFECYCLE_REQUEST,
        ),
    ),
)
def test_signal_synchronization(app_one, app_two, run_multi, events):
    app_one.prepare(port=23456)
    app_two.prepare(port=23457)

    for event in events:
        app_one.signal(event)(AsyncMock())

    run_multi(app_one)

    assert len(app_two.signal_router.routes) == len(events) + 1

    signal_handlers = {
        signal.handler
        for signal in app_two.signal_router.routes
        if signal.name.startswith("http")
    }

    assert len(signal_handlers) == 1
    assert list(signal_handlers)[0] is OptionalDispatchEvent.noop


def test_warning_main_process_listeners_on_secondary(
    app_one, app_two, run_multi
):
    app_two.main_process_start(AsyncMock())
    app_two.main_process_stop(AsyncMock())
    app_one.prepare(port=23456)
    app_two.prepare(port=23457)

    log = run_multi(app_one)

    message = (
        f"Sanic found 2 listener(s) on "
        "secondary applications attached to the main "
        "process. These will be ignored since main "
        "process listeners can only be attached to your "
        "primary application: "
        f"{repr(app_one)}"
    )

    assert ("sanic.error", logging.WARNING, message) in log


def test_no_applications():
    Sanic._app_registry = {}
    message = "Did not find any applications."
    with pytest.raises(RuntimeError, match=message):
        Sanic.serve()


def test_oserror_warning(app_one, app_two, run_multi, capfd):
    orig = AsyncioServer.__await__
    AsyncioServer.__await__ = Mock(side_effect=OSError("foo"))
    app_one.prepare(port=23456, workers=2)
    app_two.prepare(port=23457, workers=2)

    run_multi(app_one)

    captured = capfd.readouterr()
    assert (
        "An OSError was detected on startup. The encountered error was: foo"
    ) in captured.err

    AsyncioServer.__await__ = orig


def test_running_multiple_offset_warning(app_one, app_two, run_multi, capfd):
    app_one.prepare(port=23456, workers=2)
    app_two.prepare(port=23457)

    run_multi(app_one)

    captured = capfd.readouterr()
    assert (
        f"The primary application {repr(app_one)} is running "
        "with 2 worker(s). All "
        "application instances will run with the same number. "
        f"You requested {repr(app_two)} to run with "
        "1 worker(s), which will be ignored "
        "in favor of the primary application."
    ) in captured.err


def test_running_multiple_secondary(app_one, app_two, run_multi, capfd):
    app_one.prepare(port=23456, workers=2)
    app_two.prepare(port=23457)

    before_start = AsyncMock()
    app_two.before_server_start(before_start)
    run_multi(app_one)

    before_start.await_count == 2