import logging
import ssl
import typing
import unittest
import unittest.mock

from stapler.params import Parameters
from stapler.server import StaplerServer

from . import BaseTestCase


class TestStaplerServer(BaseTestCase):
    @typing.override
    def setUp(self) -> None:
        self.server = StaplerServer(Parameters())
        self.server.logger = unittest.mock.Mock(logging.Logger)
        self.registry = self.server.registry = self.new_mock()
        self.cert_manager = self.server.cert_manager = self.new_mock()
        self.token_manager = self.server.token_manager = self.new_mock()
        self.data_dir = self.server.data_dir = self.new_mock()
        self.server_mock = unittest.mock.MagicMock()
        self.context_mock = unittest.mock.Mock(ssl.SSLContext)
        super().setUp()

    def test_renew(self) -> None:
        with (
            self.mock_call(self.registry.load_pages),
            self.mock_calls(self.registry.get_hosts, [[]], [["host_1"]]),
            self.mock_call(self.cert_manager.init),
            self.mock_calls(
                self.cert_manager.create_or_update, [["localhost"], ["host_1"]]
            ),
            self.seal_mocks(),
        ):
            self.assertEqual(self.server.renew(), 0)

    def test_renew_without_certificates(self) -> None:
        self.server.params = Parameters(with_certificates=False)
        self.seal_mocks()
        self.assertEqual(self.server.renew(), 1)

    def test_token(self) -> None:
        with (
            self.mock_call(self.registry.load_pages),
            self.mock_call(self.token_manager.init),
            self.mock_call(self.token_manager.new_token),
            self.seal_mocks(),
        ):
            self.assertEqual(self.server.token(), 0)

    def test_run_http(self) -> None:
        self.server.params = Parameters(https=False, with_certificates=False)
        self.token_manager.detect_file_change.side_effect = KeyboardInterrupt
        with (
            self.mock_call(self.registry.load_pages),
            self.mock_call(self.data_dir.init),
            self.mock_call(self.token_manager.init),
            self.patch("http.server.ThreadingHTTPServer", self.server_mock),
            self.mock_call(self.server_mock.serve_forever),
            self.seal_mocks(),
        ):
            self.assertEqual(self.server.run(), 0)
        self.token_manager.detect_file_change.assert_called_once()

    def test_run_https(self) -> None:
        self.token_manager.detect_file_change.side_effect = KeyboardInterrupt
        self.cert_manager.servername_callback = unittest.mock.Mock()
        with (
            self.mock_call(self.registry.load_pages),
            self.mock_call(self.cert_manager.init),
            self.mock_call(self.data_dir.init),
            self.mock_call(self.token_manager.init),
            self.patch("ssl.create_default_context", return_value=self.context_mock),
            self.patch("http.server.ThreadingHTTPServer", self.server_mock, 2),
            self.mock_call_unchecked(self.context_mock.wrap_socket),
            self.mock_call_unchecked(self.context_mock.set_servername_callback),
            self.mock_calls_unchecked(self.server_mock.serve_forever, 2),
            self.mock_call(self.server_mock.shutdown),
            self.seal_mocks(),
        ):
            self.assertEqual(self.server.run(), 0)
        self.token_manager.detect_file_change.assert_called_once()