import threading
import time
from socketserver import ThreadingMixIn
from wsgiref.simple_server import WSGIRequestHandler, WSGIServer, make_server

import requests

import socketio


class SocketIOWebServer:
    """A simple web server used for running Socket.IO servers in tests.

    :param sio: a Socket.IO server instance.

    Note 1: This class is not production-ready and is intended for testing.
    Note 2: This class only supports the "threading" async_mode, with WebSocket
    support provided by the simple-websocket package.
    """

    def __init__(self, sio):
        if sio.async_mode != "threading":
            raise ValueError('The async_mode must be "threading"')

        def http_app(environ, start_response):
            start_response("200 OK", [("Content-Type", "text/plain")])
            return [b"OK"]

        self.sio = sio
        self.app = socketio.WSGIApp(sio, http_app)
        self.httpd = None
        self.thread = None

    def start(self, port=8900):
        """Start the web server.

        :param port: the port to listen on. Defaults to 8900.

        The server is started in a background thread.
        """

        class ThreadingWSGIServer(ThreadingMixIn, WSGIServer):
            pass

        class WebSocketRequestHandler(WSGIRequestHandler):
            def get_environ(self):
                env = super().get_environ()

                # pass the raw socket to the WSGI app so that it can be used
                # by WebSocket connections (hack copied from gunicorn)
                env["gunicorn.socket"] = self.connection
                return env

        self.httpd = make_server(
            "", port, self._app_wrapper, ThreadingWSGIServer, WebSocketRequestHandler
        )
        self.thread = threading.Thread(target=self.httpd.serve_forever)
        self.thread.start()

        # wait for the server to start
        while True:
            try:
                r = requests.get(f"http://localhost:{port}/")
                r.raise_for_status()
                if r.text == "OK":
                    break
            except:
                time.sleep(0.1)

    def stop(self):
        """Stop the web server."""
        self.sio.shutdown()
        self.httpd.shutdown()
        self.httpd.server_close()
        self.thread.join()
        self.httpd = None
        self.thread = None

    def _app_wrapper(self, environ, start_response):
        try:
            return self.app(environ, start_response)
        except StopIteration:
            # end the WebSocket request without sending a response
            # (this is a hack that was copied from gunicorn's threaded worker)
            start_response("200 OK", [])
            return []