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 plugins.rmass.inbound import receive

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")

        if self.path.startswith("/_matrix/app/v1/transactions/"):
            print("Matrix transaction received")
            outputs = {}
            content_length = int(self.headers["Content-Length"])
            data = self.rfile.read(content_length)
            request = json.loads(data)

            requestjson = json.dumps(request, indent=4)
            print (request)
            print(requestjson)
            outputs = buildOutput(data, receive, outputs)
            print (outputs)
            self.send_response(200)
            self.send_header("Content-Type", "application/json")
            self.send_header("Content-Length", "2")
            self.end_headers()
            self.wfile.write(b"{}")

        else:
            self.send_error(404)

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

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

    server.serve_forever()