class KeyIdentifier:
    _layer_index: int
    _key_index: int

    def __init__(self, layer_index: int, key_index: int) -> None:
        assert layer_index is not None
        assert key_index is not None
        self._layer_index = layer_index
        self._key_index = key_index


class LayerChange:
    _issued_by: KeyIdentifier
    _to_layer: int
    _is_toggle: bool

    def __init__(self, to_layer: int, is_toggle: bool = False) -> None:
        assert to_layer is not None
        self._issued_by = None
        self._to_layer = to_layer
        self._is_toggle = is_toggle

    def get_layer(self) -> int:
        return self._to_layer

    def is_toggle_layer_change(self) -> bool:
        return self._is_toggle


class LayerDelta:
    _layers_to_apply: list[LayerChange]
    _layers_to_remove: list[LayerChange]

    def __init__(self) -> None:
        self._layers_to_remove = []
        self._layers_to_apply = []

    def contains_layer_change(self) -> bool:
        return len(self._layers_to_apply) + len(self._layers_to_remove) > 0

    def contains_layers_to_apply(self) -> bool:
        return len(self.get_layers_to_apply()) > 0

    def contains_layers_to_remove(self) -> bool:
        return len(self.get_layers_to_remove()) > 0

    def get_hold_layers_to_apply(self) -> list[LayerChange]:
        return filter(lambda delta: not delta.is_toggle_layer_change(), self._layers_to_apply)

    def get_hold_layers_to_remove(self) -> list[LayerChange]:
        return filter(lambda delta: not delta.is_toggle_layer_change(), self._layers_to_remove)

    def get_toggle_layers_to_apply(self) -> list[LayerChange]:
        return filter(lambda delta: delta.is_toggle_layer_change(), self._layers_to_apply)

    def get_toggle_layers_to_remove(self) -> list[LayerChange]:
        return filter(lambda delta: delta.is_toggle_layer_change(), self._layers_to_remove)

    def get_layers_to_apply(self) -> list[LayerChange]:
        return self._layers_to_apply

    def get_layers_to_remove(self) -> list[LayerChange]:
        return self._layers_to_remove

    def apply_layer(self, layer_change: LayerChange) -> None:
        assert layer_change is not None
        self._layers_to_apply.append(layer_change)

    def remove_layer(self, layer_change: LayerChange) -> None:
        assert layer_change is not None
        self._layers_to_remove.append(layer_change)

    def merge_deltas(self, other_delta) -> None:
        for layer in other_delta.get_layers_to_apply():
            self.apply_layer(layer)
        for layer in other_delta.get_layers_to_remove():
            self.remove_layer(layer)


class KeymapDelta:
    _keycodes_to_press: set[int]
    _keycodes_to_unpress: set[int]

    def __init__(self) -> None:
        self._keycodes_to_press = set()
        self._keycodes_to_unpress = set()

    def get_to_press(self) -> set[int]:
        return self._keycodes_to_press

    def get_to_unpress(self) -> set[int]:
        return self._keycodes_to_unpress

    def contains_keycode_changes(self) -> bool:
        return len(self._keycodes_to_unpress) + len(self._keycodes_to_press) > 0

    def press(self, keycode: int) -> None:
        self._keycodes_to_press.add(keycode)
        try:
            self._keycodes_to_unpress.remove(keycode)
        except KeyError:
            pass

    def unpress(self, keycode: int) -> None:
        self._keycodes_to_unpress.add(keycode)
        try:
            self._keycodes_to_press.remove(keycode)
        except KeyError:
            pass

    def merge_deltas(self, other_delta) -> None:
        for keycode in other_delta.get_to_press():
            self.press(keycode)
        for keycode in other_delta.get_to_unpress():
            self.unpress(keycode)