import socket
import select
from threading import Thread
import time
import sys
import logging
import logging.handlers
from logging import config

BUFFER_SIZE = 32 * 1024
CURRENT_THREADS = 0
MAX_THREADS = 10
BACKLOG = 50
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'verbose': {
            'format': '%(levelname)s %(message)s'
        },
    },
    'handlers': {
        'stdout': {
            'class': 'logging.StreamHandler',
            'stream': sys.stdout,
            'formatter': 'verbose',
        },
        'sys-logger6': {
            'class': 'logging.handlers.SysLogHandler',
            "address": ("127.0.0.1", 514),
            'facility': "local6",
            'formatter': 'verbose',
        },
    },
    'loggers': {
        'PythonProxy': {
            'handlers': ['sys-logger6', 'stdout'],
            'level': logging.DEBUG,
            'propagate': True,
        },
    }
}
config.dictConfig(LOGGING)

class Logger:
    _instance = None
    def __init__(self):
        if self._instance is not None:
            raise Exception("Logger is a singleton!")

        self.logger = logging.getLogger('PythonProxy')
        self.logger.info('Initiating Proxy logger!')

    def info(self, message:str):
        self.logger.info(message)

    def critical(self, message:str):
        self.logger.critical(message)

    @classmethod
    def instance(self):
        if self._instance is None:
            self._instance = self()
        return self._instance


class Server:
    def __init__(self, host:str, port:int):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.bind((host, port))
        self.sock.listen(BACKLOG)
        print(f"Proxy executando em: http://{host}:{port}")

    def thread_check(self):
        global CURRENT_THREADS, MAX_THREADS
        while True:
            if CURRENT_THREADS >= MAX_THREADS:
                time.sleep(1)
            else:
                return

    def start(self):
        global CURRENT_THREADS
        while True:
            conn, client_addr = self.sock.accept()
            self.thread_check()

            CURRENT_THREADS += 1
            thread = Thread(target = connectionHandle, args = (conn, client_addr, ))
            CURRENT_THREADS -= 1
            thread.start()

    def __del__(self):
        self.sock.close()

def is_valid_status_code(status_code:str):
    valid_starts = [str(i) for i in range(5)]
    if status_code.startswith(tuple(valid_starts)):
        return True
    return False

def connectionHandle(client_socket, client_address):
    request = client_socket.recv(BUFFER_SIZE)
    logger = Logger.instance()

    if len(request) == 0:
        client_socket.close()
        return

    try:
        raw_request = request.decode()
    except UnicodeDecodeError:
        client_socket.close()
        return

    if "CONNECT" in raw_request:
        client_socket.sendall(b"HTTP/1.1 200 Connection Established\r\n\r\n")
        request = client_socket.recv(BUFFER_SIZE)

    request_url = raw_request.split(' ')[1]
    request_host = ""
    request_port = 443 if 'https' in request_url else 80

    if request_url.startswith('http'):
        request_host = request_url.split('/')[2]
    else:
        request_host = request_url.split('/')[0]

    if request_host.startswith('www'):
        request_host = request_host[4:]

    if ':' in request_host:
        request_port = int(request_host.split(':')[1])
        request_host = request_host.split(':')[0]

    if "monitorando" in request_url.lower():
        body = open('forbidden.html', 'r').read()
        client_socket.sendall(b"HTTP/1.1 403 Forbidden\r\n\r\n")
        client_socket.sendall(body.encode())
        client_socket.close()
        logger.info(f"REQUEST [{client_address[0]}:{client_address[1]}] to [{request_host}:{request_port}] - 'Monitorando' - 403 Forbidden")
        return

    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.connect((request_host, request_port))
    server_socket.send(request)

    while True:
        triple = select.select([client_socket, server_socket], [], [], 10)[0]
        if not len(triple):
            break
        try:
            if server_socket in triple:
                data = server_socket.recv(BUFFER_SIZE)
                if not data:
                    break

                try:
                    status_code = data.decode().split('\r\n')[0].split(' ')[1:]
                    status_code = ' '.join(status_code)
                    if is_valid_status_code(status_code):
                        logger.info(f"REQUEST [{client_address[0]}:{client_address[1]}] to [{request_host}:{request_port}] - {status_code}")
                except UnicodeDecodeError:
                    logger.info(f"REQUEST [{client_address[0]}:{client_address[1]}] to [{request_host}:{request_port}]")
                    pass

                client_socket.send(data)
            if client_socket in triple:
                data = client_socket.recv(BUFFER_SIZE)
                if not data:
                    break

                server_socket.send(data)
        except ConnectionAbortedError:
            break

    server_socket.close()
    client_socket.close()

def verify_code_integrity():
    import hashlib
    import sys

    content = None
    shas256_hash = None

    with open(sys.argv[0], 'rb') as f:
        content = f.read()

    with open('proxy.sha256sum', 'r') as f:
        shas256_hash = f.read()

    hash = hashlib.sha256(content).hexdigest()

    if hash != shas256_hash:
        print('ERRO: Código do proxy está diferente!')
        exit(1)

    print('Arquivo do proxy verificado!')

if __name__ == '__main__':
    verify_code_integrity()

    try:
        ser = Server(host="0.0.0.0", port=8080)
        ser.start()
    except KeyboardInterrupt:
        print("Desligando proxy...")
        exit(0)