import ssl
import json
import sqlite3
from flask import Flask
from urllib.parse import urlparse, parse_qs, unquote
from consts import SSL_CERT_PATH, SSL_KEY_PATH, HOST, PORT
from http.server import HTTPServer, BaseHTTPRequestHandler

from map_handler.add_lake import cut_map
from server.consts import LAKE_RELATIONS_PATH
from map_handler.get_lake import get_divided_map
from map_handler.get_measurements import get_all_markers
from map_handler.input_new_data import input_new_Lidar_data

app = Flask(__name__)
terminate_server = 0


class IceHTTPServer(HTTPServer):
    def __init__(self, server_address, handler_class, cursor):
        super().__init__(server_address, handler_class)
        self.cursor = cursor

    def get_request(self):
        request, client_address = super().get_request()
        return request, client_address


# Custom HTTP class
class IceHTTP(BaseHTTPRequestHandler):

    def __init__(self, request, client_address, server):
        self.cursor = server.cursor
        super().__init__(request, client_address, server)

    def do_GET(self):

        # Root path
        if self.path == '/':  # NB: temporary root path behavior
            self.send_response(200)
            self.send_header("Content-type", "text/plain")
            self.end_headers()

            self.wfile.write(b"Root path hit!")
        elif self.path == '/get_lake_names':
            with open(LAKE_RELATIONS_PATH + 'all_lake_names.json', 'r') as file:
                lake_names = json.load(file)

            # Disable ensure_ascii to keep 'ø'
            json_data = json.dumps(lake_names, ensure_ascii=False)

            self.send_response(200)
            self.send_header('Content-type', 'application/json')
            self.end_headers()

            self.wfile.write(json_data.encode('iso-8859-1'))  # Special character encoding
        elif self.path.startswith('/update_map'):  # NB: should be POST?
            parsed_path = urlparse(self.path)
            query_params = parse_qs(parsed_path.query)
            get_all_markers(self, self.cursor, 'mjosa')  # Get all markers
            # NB: temporary hardcoded waterBodyName
        elif self.path.startswith('/get_relation'):
            parsed_path = urlparse(self.path)
            query_params = parse_qs(parsed_path.query)

            lake_name_param = query_params.get('lake', [''])[0]
            lake_name = unquote(lake_name_param)  # Decode url param

            get_divided_map(self, lake_name)
        elif self.path.startswith('/add_new_lake'):
            parsed_path = urlparse(self.path)
            query_params = parse_qs(parsed_path.query)

            lake_name = query_params.get('lake', [None])[0]
            if lake_name is not None:
                cut_map(self, lake_name)
            else:
                self.send_response(400)
                self.send_header('Content-type', 'application/json')
                self.end_headers()

    def do_POST(self):
        if self.path == '/new_lidar_data':
            input_new_Lidar_data(self, self.cursor, 1, 'Mjosa')  # hardcoded body of water must change later


# Start a server on port 8443 using self defined HTTP class
if __name__ == "__main__":
    try:
        # Initialize database connection
        conn = sqlite3.connect('server/database/icedb')
        cursor = conn.cursor()

        # Load SSL certificate and private key
        ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
        ssl_context.load_cert_chain(SSL_CERT_PATH, SSL_KEY_PATH)

        # Create HTTP server with SSL support
        server = IceHTTPServer((HOST, PORT), IceHTTP, cursor)
        server.socket = ssl_context.wrap_socket(server.socket, server_side=True)

        print("Server running on port ", PORT)

        # Run server indefinitely
        server.serve_forever()

    except Exception as e:
        print(f"Server terminated: {PORT}: {e}")