import random

# Definition der Grammatikregeln
w3 = {
    "anfang": [(100, ["s", "vkg"])],
    ("s", "vkg"): [(100, "ende")]
}

bbd = {("kbbd",): [(100, "vbbd")]}

ba = {("kba",): [(100, "vba")]}

ae = {("kae",): [(100, "vae")]}

aa = {("kaa",): [(100, "vaa")]}

b = {("s", "bbd"): [(100, ("s", "ba"))]}

a = {("s", "ae"): [(50, ("s", "ae")), (100, ("s", "aa"))]}

vt = {("s", "b"): [(50, ("s", "b")), (100, ("s", "a"))]}

bg = {("kbg",): [(100, "vbg")]}

av = {("kav",): [(100, "vav")]}

vkg = {("s", "bg"): [(100, ("s", "vt"))],
        ("s", "vt"): [(50, ("s", "vt")), (100, ("s", "av"))]}

# Definition der Agentenklasse
class Agent:
    def __init__(self, name, grammar, starting_rule):
        self.name = name
        self.grammar = grammar
        self.rule_probs = self.compute_rule_probs()
        self.current_rule = starting_rule
        
    def compute_rule_probs(self):
        rule_probs = {}
        for rule in self.grammar:
            rule_probs[rule] = [x[0] for x in self.grammar[rule]]
            total_prob = sum(rule_probs[rule])
            rule_probs[rule] = [x / total_prob for x in rule_probs[rule]]
        return rule_probs
    
    def update_rule(self, input_symbol):
        possible_rules = [x for x in self.rule_probs if input_symbol in x]
        if not possible_rules:
            return
        self.current_rule = random.choices(possible_rules, weights=self.rule_probs[possible_rules[0]])[0]
        
    def generate_output(self):
        output = []
        for symbol in self.current_rule:
            if isinstance(symbol, tuple):
                output.extend(Agent(symbol[0], globals()[symbol[0]], symbol))
            else:
                output.append(symbol)
        return output
    
# Definition des Multiagentensystems
class MultiAgentSystem:
    def __init__(self, agent_k, agent_v):
        self.agents = {"K": agent_k, "V": agent_v}
        
    def communicate(self, input_sequence):
        agent_k_output = self.agents["K"].generate_output()
        agent_v_output = self.agents["V"].generate_output()
        
        current_agent = self.agents["K"]
        output_sequence = []
        
        for symbol in input_sequence:
            current_agent.update_rule(symbol)
            output_sequence.extend(current_agent.generate_output())
            if current_agent == self.agents["K"]:
                current_agent = self.agents["V"]
            else:
                current_agent = self.agents["K"]
        
        return output_sequence

# Beispielanwendung
agent_k = Agent("s", globals()["s"], ("s", "vkg"))
agent_v = Agent("s", globals()["s"], ("s", "vkg"))

mas = MultiAgentSystem(agent_k, agent_v)

input_sequence