import os
import json
import logging

from http.server import HTTPServer, BaseHTTPRequestHandler

from .dispatcher import dispatchRequest
from .createresponse import buildResponse
from plugins.rmass.listeners import synapselistener
from core.server.createlistener import buildListener
from plugins.rmass.actions import synapsesetbridgeonline

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


class RequestHandler(BaseHTTPRequestHandler):
    def do_POST(self):
        if self.path == "/_matrix/app/v1/ping":

            from core.execution.createthread import buildThread
            thread = buildThread(synapsesetbridgeonline)

            self.send_response(200)
            self.send_header("Content-Type", "application/json")
            self.send_header("Content-Length", "2")
            self.end_headers()
            self.wfile.write(b"{}")
            return

        else:
            #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)

    logging.info(f"Server listening on port {port}")
    #outputs = {}
    #outputs, response = buildAction(pingsynapse, outputs)    

    server.serve_forever()