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, matrixpinglistener
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):
        logging.debug("POST request received")

        buildListener(matrixpinglistener, 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:
        #     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):
        logging.debug("PUT request received")

        buildListener(synapselistener, self)

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

    logging.info(f"Server listening on port {port}")  

    server.serve_forever()