import socket
from multiprocessing import Pipe
from threading import Thread
from time import time, sleep
from numpy import std, floor, log10

from meow_base.patterns.network_event_pattern import NetworkMonitor, \
    NetworkEventPattern
from meow_base.recipes.jupyter_notebook_recipe import JupyterNotebookRecipe
from meow_base.tests.shared import BAREBONES_NOTEBOOK

def send(port):
    sender = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    while True:
        try:
            sender.connect(("127.0.0.1", port))
            sender.sendall(b'test')
            sender.close()
            break
        except:
            continue

def get_all(from_monitor_reader, event_count):
    for _ in range(event_count):
        if from_monitor_reader.poll(3):
            event = from_monitor_reader.recv()
        else:
            raise Exception("Did not receive all events")

def test_network(monitor_count: int, patterns_per_monitor: int,
                 events_per_pattern: int, start_port: int):

    monitors = []
    port = start_port


    recipe = JupyterNotebookRecipe(
        "recipe_one", BAREBONES_NOTEBOOK)
    recipes = {
        recipe.name: recipe
    }

    from_monitor_reader, from_monitor_writer = Pipe()

    for _ in range(monitor_count):
        patterns = {}
        for p in range(patterns_per_monitor):
            pattern_name = f"pattern_{p}"
            patterns[pattern_name] = NetworkEventPattern(
                pattern_name,
                port,
                recipe.name
            )
            port += 1

        monitor = NetworkMonitor(patterns, recipes)
        monitor.to_runner_event = from_monitor_writer
        monitors.append(monitor)
        monitor.start()


    event_count = monitor_count*patterns_per_monitor*events_per_pattern

    receiver = Thread(target=get_all, args=(from_monitor_reader, event_count,))
    receiver.start()

    start_time = time()


    for p in range(start_port, port):
        for _ in range(events_per_pattern):
            send(p)
            # Thread(target=send, args=(p,)).start()

    receiver.join()

    duration = time() - start_time

    for monitor in monitors:
        monitor.stop()

    return duration

def sigfigs(num):
    if num < 10:
        return round(num, -int(floor(log10(abs(num))-1)))
    else:
        return int(num)

def main():
    monitors = 1
    patterns = 1000
    events   = 1

    n = 100

    durations = []
    for i in range(n):
        print(" ", i, end=" \r")
        durations.append(test_network(monitors,patterns,events,1024))
        sleep(0.5)

    print(f"({monitors}, {patterns}, {events}) min: {min(durations)}, max: {max(durations)}, avg: {sum(durations)/n}, std: {std(durations)}")

    # print(f"{sigfigs(min(durations)*1000)}ms & {sigfigs((min(durations)*1000)/events)}ms & {sigfigs(max(durations)*1000)}ms & {sigfigs((max(durations)*1000)/events)}ms & {sigfigs((sum(durations)/n)*1000)}ms & {sigfigs(((sum(durations)/n)*1000)/events)}ms & {sigfigs(std(durations)*1000)}ms")
    print(f"{sigfigs(min(durations)*1000)}ms & {sigfigs(max(durations)*1000)}ms & {sigfigs((sum(durations)/n)*1000)}ms & {sigfigs(std(durations)*1000)}ms")

if __name__ == "__main__":
    main()