import os
import json
from http.server import HTTPServer, BaseHTTPRequestHandler

from .dispatcher import dispatchRequest
from .createresponse import buildResponse
from core.runtime.outputs import buildOutput
from core.runtime.resolver import resolveItem
from plugins.rmass.listeners import synapselistener
from plugins.rmass.operations import rmassmessagepush
from core.execution.operation import buildOperation
from core.server.createlistener import buildListener

port = int(os.environ.get("SERVER_PORT", 19001))


class RequestHandler(BaseHTTPRequestHandler):
    def do_POST(self):
        lifecycles = {}
        print("POST request received")

        max_request_size = 1024

        content_length = self.headers.get("Content-Length")

        # Check whether Content-Length exists
        if content_length is None:
            response = {
                "status": "error",
                "message": "Content length required"
            }
            status = 411

        else:
            # Attempt to convert the header into an integer
            try:
                length = int(content_length)
            except ValueError:
                length = None

            # Validate the converted length
            if length is None:
                response = {
                    "status": "error",
                    "message": "Invalid Content-Length"
                }
                status = 400

            elif length < 0:
                response = {
                    "status": "error",
                    "message": "Bad Request"
                }
                status = 400

            elif length > max_request_size:
                response = {
                    "status": "error",
                    "message": "Content exceeds maximum request size"
                }
                status = 413

            else:
                # Content-Length is valid, so read the body
                data = self.rfile.read(length)

                try:
                    request = json.loads(data)

                except json.JSONDecodeError:
                    response = {
                        "status": "error",
                        "message": "Invalid JSON received"
                    }
                    status = 400

                else:
                    # Only valid JSON reaches the dispatcher
                    thread, lifecycles, module, mode = dispatchRequest(
                        request, lifecycles
                    )

                    response = buildResponse(module, thread, mode)
                    status = 200

        # Serialize the response
        responsebytes = json.dumps(response).encode("utf-8")

        # Send one HTTP response
        self.send_response(status)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(responsebytes)))
        self.end_headers()

        self.wfile.write(responsebytes)


    def do_PUT(self):
        print("PUT request received")

        outputs = buildListener(synapselistener, self)

def startServer():
    server = HTTPServer(("0.0.0.0", port), RequestHandler)

    print(f"Server listening on port {port}")

    server.serve_forever()