"""Async gunicorn worker for aiohttp.web"""

import asyncio
import logging
import os
import re
import signal
import socket
import ssl
import sys

import gunicorn.workers.base as base
from gunicorn.config import AccessLogFormat as GunicornAccessLogFormat

from aiohttp.helpers import AccessLogger, ensure_future
from aiohttp.web_server import Server
from aiohttp.wsgi import WSGIServerHttpProtocol

__all__ = ('GunicornWebWorker', 'GunicornUVLoopWebWorker')


class GunicornWebWorker(base.Worker):

    DEFAULT_AIOHTTP_LOG_FORMAT = AccessLogger.LOG_FORMAT
    DEFAULT_GUNICORN_LOG_FORMAT = GunicornAccessLogFormat.default

    def __init__(self, *args, **kw):  # pragma: no cover
        super().__init__(*args, **kw)

        self.servers = {}
        self.exit_code = 0
        self._notify_waiter = None

    def init_process(self):
        # create new event_loop after fork
        asyncio.get_event_loop().close()

        self.loop = asyncio.new_event_loop()
        asyncio.set_event_loop(self.loop)

        super().init_process()

    def run(self):
        if hasattr(self.wsgi, 'startup'):
            self.loop.run_until_complete(self.wsgi.startup())
        self._runner = ensure_future(self._run(), loop=self.loop)

        try:
            self.loop.run_until_complete(self._runner)
        finally:
            self.loop.close()

        sys.exit(self.exit_code)

    def make_handler(self, app):
        if hasattr(self.wsgi, 'make_handler'):
            return app.make_handler(
                logger=self.log,
                slow_request_timeout=self.cfg.timeout,
                keepalive_timeout=self.cfg.keepalive,
                access_log=self.log.access_log,
                access_log_format=self._get_valid_log_format(
                    self.cfg.access_log_format))
        else:
            return WSGIServer(self.wsgi, self)

    @asyncio.coroutine
    def close(self):
        if self.servers:
            servers = self.servers
            self.servers = None

            # stop accepting connections
            for server, handler in servers.items():
                self.log.info("Stopping server: %s, connections: %s",
                              self.pid, len(handler.connections))
                server.close()
                yield from server.wait_closed()

            # send on_shutdown event
            if hasattr(self.wsgi, 'shutdown'):
                yield from self.wsgi.shutdown()

            # stop alive connections
            tasks = [
                handler.shutdown(
                    timeout=self.cfg.graceful_timeout / 100 * 95)
                for handler in servers.values()]
            yield from asyncio.gather(*tasks, loop=self.loop)

            # cleanup application
            if hasattr(self.wsgi, 'cleanup'):
                yield from self.wsgi.cleanup()

    @asyncio.coroutine
    def _run(self):

        ctx = self._create_ssl_context(self.cfg) if self.cfg.is_ssl else None

        for sock in self.sockets:
            handler = self.make_handler(self.wsgi)

            if hasattr(socket, 'AF_UNIX') and sock.family == socket.AF_UNIX:
                srv = yield from self.loop.create_unix_server(
                    handler, sock=sock.sock, ssl=ctx)
            else:
                srv = yield from self.loop.create_server(
                    handler, sock=sock.sock, ssl=ctx)
            self.servers[srv] = handler

        # If our parent changed then we shut down.
        pid = os.getpid()
        try:
            while self.alive:
                self.notify()

                cnt = sum(handler.requests_count
                          for handler in self.servers.values())
                if self.cfg.max_requests and cnt > self.cfg.max_requests:
                    self.alive = False
                    self.log.info("Max requests, shutting down: %s", self)

                elif pid == os.getpid() and self.ppid != os.getppid():
                    self.alive = False
                    self.log.info("Parent changed, shutting down: %s", self)
                else:
                    yield from self._wait_next_notify()

        except BaseException:
            pass

        yield from self.close()

    def _wait_next_notify(self):
        self._notify_waiter_done()

        self._notify_waiter = waiter = asyncio.Future(loop=self.loop)
        self.loop.call_later(1.0, self._notify_waiter_done)

        return waiter

    def _notify_waiter_done(self):
        waiter = self._notify_waiter
        if waiter is not None and not waiter.done():
            waiter.set_result(True)

        self._notify_waiter = None

    def init_signals(self):
        # Set up signals through the event loop API.

        self.loop.add_signal_handler(signal.SIGQUIT, self.handle_quit,
                                     signal.SIGQUIT, None)

        self.loop.add_signal_handler(signal.SIGTERM, self.handle_exit,
                                     signal.SIGTERM, None)

        self.loop.add_signal_handler(signal.SIGINT, self.handle_quit,
                                     signal.SIGINT, None)

        self.loop.add_signal_handler(signal.SIGWINCH, self.handle_winch,
                                     signal.SIGWINCH, None)

        self.loop.add_signal_handler(signal.SIGUSR1, self.handle_usr1,
                                     signal.SIGUSR1, None)

        self.loop.add_signal_handler(signal.SIGABRT, self.handle_abort,
                                     signal.SIGABRT, None)

        # Don't let SIGTERM and SIGUSR1 disturb active requests
        # by interrupting system calls
        signal.siginterrupt(signal.SIGTERM, False)
        signal.siginterrupt(signal.SIGUSR1, False)

    def handle_quit(self, sig, frame):
        self.alive = False

        # worker_int callback
        self.cfg.worker_int(self)

        # init closing process
        self._closing = ensure_future(self.close(), loop=self.loop)

        # close loop
        self.loop.call_later(0.1, self._notify_waiter_done)

    def handle_abort(self, sig, frame):
        self.alive = False
        self.exit_code = 1
        self.cfg.worker_abort(self)
        sys.exit(1)

    @staticmethod
    def _create_ssl_context(cfg):
        """ Creates SSLContext instance for usage in asyncio.create_server.

        See ssl.SSLSocket.__init__ for more details.
        """
        ctx = ssl.SSLContext(cfg.ssl_version)
        ctx.load_cert_chain(cfg.certfile, cfg.keyfile)
        ctx.verify_mode = cfg.cert_reqs
        if cfg.ca_certs:
            ctx.load_verify_locations(cfg.ca_certs)
        if cfg.ciphers:
            ctx.set_ciphers(cfg.ciphers)
        return ctx

    def _get_valid_log_format(self, source_format):
        if source_format == self.DEFAULT_GUNICORN_LOG_FORMAT:
            return self.DEFAULT_AIOHTTP_LOG_FORMAT
        elif re.search(r'%\([^\)]+\)', source_format):
            raise ValueError(
                "Gunicorn's style options in form of `%(name)s` are not "
                "supported for the log formatting. Please use aiohttp's "
                "format specification to configure access log formatting: "
                "http://aiohttp.readthedocs.io/en/stable/logging.html"
                "#format-specification"
            )
        else:
            return source_format


class WSGIServer(Server):

    def __init__(self, app, worker):
        super().__init__(app, loop=worker.loop)

        self.worker = worker
        self.access_log_format = worker._get_valid_log_format(
            worker.cfg.access_log_format)

    def __call__(self):
        return WSGIServerHttpProtocol(
            self.handler, readpayload=True,
            loop=self._loop,
            logger=self.worker.log,
            debug=self.worker.log.loglevel == logging.DEBUG,
            keep_alive=self.worker.cfg.keepalive,
            access_log=self.worker.log.access_log,
            access_log_format=self.access_log_format)


class GunicornUVLoopWebWorker(GunicornWebWorker):

    def init_process(self):
        import uvloop

        # Close any existing event loop before setting a
        # new policy.
        asyncio.get_event_loop().close()

        # Setup uvloop policy, so that every
        # asyncio.get_event_loop() will create an instance
        # of uvloop event loop.
        asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())

        super().init_process()