import json
import random
import math
from typing import List, Dict, Tuple


# ---- Hilfsfunktionen ----
def generate_id():
    """Generiert eine eindeutige ID basierend auf Zufallszahlen."""
    return random.random()


def create_neural_weights(vector_length: int):
    """Erstellt eine Liste von Gewichten für eine Verbindung."""
    return [random.uniform(-0.5, 0.5) for _ in range(vector_length)]


# ---- Klassen ----
class Sensor:
    def __init__(self, name: str, vector_length: int):
        self.id = generate_id()
        self.name = name
        self.vector_length = vector_length
        self.cx_id = None  # Wird später hinzugefügt
        self.fanout_ids = []  # Verbindungen zu Neuronen

    def to_dict(self):
        return {
            "id": self.id,
            "name": self.name,
            "vector_length": self.vector_length,
            "cx_id": self.cx_id,
            "fanout_ids": self.fanout_ids,
        }


class Actuator:
    def __init__(self, name: str, vector_length: int):
        self.id = generate_id()
        self.name = name
        self.vector_length = vector_length
        self.cx_id = None  # Wird später hinzugefügt
        self.fanin_ids = []  # Verbindungen von Neuronen

    def to_dict(self):
        return {
            "id": self.id,
            "name": self.name,
            "vector_length": self.vector_length,
            "cx_id": self.cx_id,
            "fanin_ids": self.fanin_ids,
        }


class Neuron:
    def __init__(self, layer_index: int, input_ids: List[Tuple[float, int]], output_ids: List[float], cx_id: float):
        self.id = generate_id()
        self.layer_index = layer_index
        self.cx_id = cx_id
        self.activation_function = "tanh"
        self.input_weights = [
            {"input_id": input_id, "weights": create_neural_weights(vector_length)}
            for input_id, vector_length in input_ids
        ]
        self.output_ids = output_ids

    def to_dict(self):
        return {
            "id": self.id,
            "layer_index": self.layer_index,
            "cx_id": self.cx_id,
            "activation_function": self.activation_function,
            "input_weights": self.input_weights,
            "output_ids": self.output_ids,
        }


class Cortex:
    def __init__(self, sensor_ids: List[float], actuator_ids: List[float], neuron_ids: List[float]):
        self.id = generate_id()
        self.sensor_ids = sensor_ids
        self.actuator_ids = actuator_ids
        self.neuron_ids = neuron_ids

    def to_dict(self):
        return {
            "id": self.id,
            "sensor_ids": self.sensor_ids,
            "actuator_ids": self.actuator_ids,
            "neuron_ids": self.neuron_ids,
        }

    # ---- Hauptfunktionen ----


def construct_genotype(sensor_name: str, actuator_name: str, hidden_layer_densities: List[int], file_name: str):
    """
    Konstruktion eines Genotyps und Speicherung in einer JSON-Datei.
    """
    # Sensor erstellen
    if sensor_name == "rng":
        sensor = Sensor(name="rng", vector_length=2)
    else:
        raise ValueError(f"System does not support a sensor by the name: {sensor_name}")

        # Aktuator erstellen
    if actuator_name == "pts":
        actuator = Actuator(name="pts", vector_length=1)
    else:
        raise ValueError(f"System does not support an actuator by the name: {actuator_name}")

        # Neuronenschichten erstellen
    output_layer_density = actuator.vector_length
    layer_densities = hidden_layer_densities + [output_layer_density]
    cortex_id = generate_id()

    neurons = create_neuro_layers(
        cortex_id,
        sensor,
        actuator,
        layer_densities
    )

    # Sensor und Aktuator mit Cortex-Informationen aktualisieren
    input_layer_neurons = neurons[0]
    output_layer_neurons = neurons[-1]

    sensor.cx_id = cortex_id
    sensor.fanout_ids = [neuron.id for neuron in input_layer_neurons]

    actuator.cx_id = cortex_id
    actuator.fanin_ids = [neuron.id for neuron in output_layer_neurons]

    # Cortex erstellen
    neuron_ids = [neuron.id for layer in neurons for neuron in layer]
    cortex = Cortex(
        sensor_ids=[sensor.id],
        actuator_ids=[actuator.id],
        neuron_ids=neuron_ids
    )

    # Genotyp erstellen
    genotype = {
        "cortex": cortex.to_dict(),
        "sensor": sensor.to_dict(),
        "actuator": actuator.to_dict(),
        "neurons": [neuron.to_dict() for layer in neurons for neuron in layer]
    }

    # Genotyp in Datei speichern
    with open(file_name, "w") as file:
        json.dump(genotype, file, indent=4)
    print(f"Genotype saved to {file_name}")


def create_neuro_layers(cortex_id: float, sensor: Sensor, actuator: Actuator, layer_densities: List[int]) -> List[
    List[Neuron]]:
    """
    Erstellt alle Neuronen in allen Schichten des Netzwerks.
    """
    neurons = []
    input_ids = [(sensor.id, sensor.vector_length)]

    for layer_index, layer_density in enumerate(layer_densities):
        output_ids = []
        if layer_index < len(layer_densities) - 1:
            # IDs der nächsten Schicht generieren
            output_ids = [generate_id() for _ in range(layer_densities[layer_index + 1])]

            # Neuronen für die aktuelle Schicht erstellen
        layer_neurons = [
            Neuron(layer_index=layer_index, input_ids=input_ids, output_ids=output_ids, cx_id=cortex_id)
            for _ in range(layer_density)
        ]
        neurons.append(layer_neurons)

        # Aktuelle Schicht wird die Eingabe für die nächste Schicht
        input_ids = [(neuron.id, 1) for neuron in layer_neurons]

        # Letzte Schicht mit Verbindung zum Aktuator erstellen
    final_layer = neurons[-1]
    for neuron in final_layer:
        neuron.output_ids = [actuator.id]

    return neurons


# ---- Beispielverwendung ----
if __name__ == "__main__":
    # Genotyp erstellen und speichern
    construct_genotype(
        sensor_name="rng",
        actuator_name="pts",
        hidden_layer_densities=[4,3],  # Dichten der versteckten Schichten (z. B. 4 Neuronen in der ersten Schicht, 3 in der zweiten)
        file_name="genotype.json"  # Name der Datei, in der der Genotyp gespeichert wird
    )