journal

def add_entry(self, id_: Hashable, entry: JournalEntry | JournalEntryGroup):
    """
    Journaleintrag hinzufügen

    Args:
        id_: Identifikation des Eintrags. Anhand der ID kann er später wieder gelöscht werden.
        entry: Eintrag oder Gruppe
    """
    self.entries[id_] = entry

def clear(self):
    """
    Alle Journaleinträge löschen
    """
    self.entries.clear()

def delete_entry(self, id_: Hashable):
    """
    Journaleintrag löschen

    Args:
        id_: ID, die in add_entry verwendet wurde.

    Raises:
        KeyError: Eintrag existiert nicht.
    """
    del self.entries[id_]

def replay(self, graph_map: Mapping[Hashable, nx.Graph] | None = None):
    """
    Journal abspielen

    Die Zielgraphen werden anhand des target_graph-Attributs der JournalEntry bestimmt.
    target_graph kann entweder einen Identifikationsschlüssel enthalten, der mittels der graph_map zugeordnet wird,
    oder direkt eine Graphinstanz.

    Args:
        graph_map: Ordnet den target_graph-Attributen der Einträge die Graphen zu, die verändert werden.
            Wird keine Zuordnung angegeben, müssen die Graphen direkt in den Einträgen angegeben sein.
    """
    for entry in self.entries.values():
        entry.replay(graph_map=graph_map)

def add_edge(self, u: N, v: N, **data):
    """
    Kante hinzufügen

    Pro Kante enthält das Journal nur einen Eintrag.
    Ein allfällig vorhandener Eintrag wird überschrieben.
    """

    self.added_edges[(u, v)] = data

def add_node(self, n: N, **data):
    """
    Knoten hinzufügen

    Pro Knoten enthält das Journal nur einen Eintrag.
    Ein allfällig vorhandener Eintrag wird überschrieben.
    """

    self.added_nodes[n] = data

def change_edge(self, u: N, v: N, **data):
    """
    Kantenanttribute ändern

    Pro Kante enthält das Journal nur einen Eintrag.
    Die zu ändernden Attribute werden in einen allfällig existierenden Eintrag übernommen.

    Vorsicht: Die Kantendaten sollten keine Attribute mit Defaultwerten enthalten!
    """

    if (u, v) in self.changed_edges:
        self.changed_edges[(u, v)].update(data)
    else:
        self.changed_edges[(u, v)] = data

def change_node(self, n: N, **data):
    """
    Knoten ändern

    Pro Knoten enthält das Journal nur einen Eintrag.
    Die zu ändernden Attribute werden in einen allfällig existierenden Eintrag übernommen.

    Vorsicht: Die Knotendaten sollten keine Attribute mit Defaultwerten enthalten!
    """

    if n in self.changed_nodes:
        self.changed_nodes[n].update(data)
    else:
        self.changed_nodes[n] = data

def clear(self):
    """
    Journal löschen
    """

    self.removed_nodes = set()
    self.added_nodes = {}
    self.changed_nodes = {}
    self.removed_edges = set()
    self.added_edges = {}
    self.changed_edges = {}

def merge(self, other: JournalEntry):
    """
    Mit anderem Journal zusammenführen

    Hat den gleichen Effekt, wie wenn die add-, change-, remove-Methoden für jedes Element aufgerufen würden.
    """

    if self.target_graph != other.target_graph or self.target_node != other.target_node:
        raise ValueError(f"JournalEntry.merge: Inkompatibler Journaleintrag {other.target_graph}/{other.target_node} "
                         f"zu {self.target_graph}/{self.target_node}")

    self.removed_edges.update(other.removed_edges)
    self.removed_nodes.update(other.removed_nodes)
    self.added_edges.update(other.added_edges)
    self.removed_nodes.update(other.removed_nodes)
    for edge, data in other.changed_edges.items():
        self.change_edge(*edge, **data)
    for node, data in other.changed_nodes.items():
        self.change_node(node, **data)

def nodes(self) -> set[tuple[G, N]]:
    """
    Betroffene Knoten auflisten
    """

    _nodes = {self.target_node}
    _nodes.update(self.removed_nodes)
    _nodes.update(self.added_nodes)
    _nodes.update(self.changed_nodes)
    _nodes.update((e[0] for e in self.removed_edges))
    _nodes.update((e[1] for e in self.removed_edges))
    _nodes.update((e[0] for e in self.added_edges))
    _nodes.update((e[1] for e in self.added_edges))
    _nodes.update((e[0] for e in self.changed_edges))
    _nodes.update((e[1] for e in self.changed_edges))
    _nodes.discard(None)
    _nodes = set(((self.target_graph, node) for node in _nodes))

    return _nodes

def remove_edge(self, u: N, v: N):
    """
    Kante löschen
    """

    self.removed_edges.add((u, v))

def remove_node(self, n: N):
    """
    Knoten löschen
    """

    self.removed_nodes.add(n)

def replay(self, graph: nx.Graph | None = None, graph_map: Mapping[G, nx.Graph] | None = None) -> dict[str, set[N]]:
    """
    Journal abspielen

    Die Abspielreihenfolge ist:

    1. Kanten löschen.
       Der Knoten muss existieren, ansonsten bleibt die Änderung wirkungslos.
    2. Knoten löschen.
       Die Kante muss existieren, ansonsten bleibt die Änderung wirkungslos.
    3. Knoten hinzufügen.
       Wenn der Knoten existiert, werden die Attribute gelöscht und überschrieben.
    4. Kanten hinzufügen.
       Wenn die Kante existiert, werden die Attribute gelöscht und überschrieben.
    5. Knoten ändern.
       Der Knoten muss existieren, ansonsten bleibt die Änderung wirkungslos.
       Im Änderungseintrag erfasste Attribute werden überschrieben, die übrigen bleiben bestehen.
    6. Knoten ändern.
       Die Kante muss existieren, ansonsten bleibt die Änderung wirkungslos.
       Im Änderungseintrag erfasste Attribute werden überschrieben, die übrigen bleiben bestehen.

    Returns:
        Dictionary mit Fehlermeldungen.
        Mögliche Keys: 'remove_edge', 'add_edge', 'change_edge', 'remove_node', 'add_node', 'change_node'.
        Values: set von edge oder node Labels.
    """

    fails = {}
    def _failed(operation, item):
        if operation in fails:
            fails[operation].add(item)
        else:
            fails[operation] = {item}

    if graph is None:
        graph = self.target_graph
    if not isinstance(graph, nx.Graph):
        graph = graph_map.get(graph)
    if graph is None:
        _failed('unresolved_target', self.target_graph)

    for edge in self.removed_edges:
        try:
            graph.remove_edge(*edge)
        except (AttributeError, nx.NetworkXError):
            _failed('remove_edge', edge)

    for label in self.removed_nodes:
        try:
            graph.remove_node(label)
        except (AttributeError, nx.NetworkXError):
            _failed('remove_node', label)

    for label, data in self.added_nodes.items():
        try:
            if graph.has_node(label):
                graph.nodes[label].clear()
            graph.add_node(label, **data)
        except (AttributeError, nx.NetworkXError):
            _failed('add_node', label)

    for edge, data in self.added_edges.items():
        try:
            if graph.has_edge(*edge):
                graph.edges[edge].clear()
            graph.add_edge(*edge, **data)
        except (AttributeError, nx.NetworkXError):
            _failed('add_edge', edge)

    for label, data in self.changed_nodes.items():
        try:
            if graph.has_node(label):
                graph.add_node(label, **data)
            else:
                _failed('change_node', label)
        except (AttributeError, nx.NetworkXError):
            _failed('change_node', label)

    for edge, data in self.changed_edges.items():
        try:
            if graph.has_edge(*edge):
                graph.add_edge(*edge, **data)
            else:
                _failed('change_edge', edge)
        except (AttributeError, nx.NetworkXError):
            _failed('change_edge', edge)

    return fails

def summary(self) -> dict[tuple[G, N], set[str]]:
    """
    Zusammenfassung von Änderungen

    Listet zu jedem betroffenen Knoten die gemachten Änderungen.
    Die Änderungen werden als String in einem Set wiedergegeben.
    '.' steht für den Targetknoten, '+' für einen neuen Knoten, '-' für einen gelöschten Knoten
    und '*' für einen geänderten Knoten.
    """

    target = defaultdict(set)
    if self.target_node is not None:
        target[(self.target_graph, self.target_node)] = {'.'}

    removed = defaultdict(set)
    removed.update({(self.target_graph, n): {'-'} for n in self.removed_nodes})
    removed.update({(self.target_graph, e[0]): {'-'} for e in self.removed_edges})
    removed.update({(self.target_graph, e[1]): {'-'} for e in self.removed_edges})

    added = defaultdict(set)
    added.update({(self.target_graph, n): {'+'} for n in self.added_nodes})
    added.update({(self.target_graph, e[0]): {'+'} for e in self.added_edges})
    added.update({(self.target_graph, e[1]): {'+'} for e in self.added_edges})

    changed = defaultdict(set)
    changed.update({(self.target_graph, n): {'*'} for n in self.changed_nodes})
    changed.update({(self.target_graph, e[0]): {'*'} for e in self.changed_edges})
    changed.update({(self.target_graph, e[1]): {'*'} for e in self.changed_edges})

    nodes = target | removed | added | changed
    result = {n: target[n] | removed[n] | added[n] | changed[n] for n in nodes}

    return result

def nodes(self) -> set[tuple[Hashable, Hashable]]:
    """
    Betroffene Knoten auflisten
    """

    nodes = [entry.nodes() for entry in self.entries]
    return set().union(*nodes)

def summary(self) -> dict[tuple[Hashable, Hashable], set[str]]:
    """
    Zusammenfassung von Änderungen

    Listet zu jedem betroffenen Knoten die gemachten Änderungen.
    Die Änderungen werden als String in einem Set wiedergegeben.
    '.' steht für den Targetknoten, '+' für einen neuen Knoten, '-' für einen geloeschten Knoten
    und '*' für einen geänderten Knoten.
    """

    summary: dict[tuple[Hashable, Hashable], set[str]] = defaultdict(set)
    for entry in self.entries:
        entry_summary = entry.summary()
        for n in entry_summary:
            summary[n].update(entry_summary[n])

    return summary