import enum
from transitions.extensions.nesting import HierarchicalMachine, NestedState

NestedState.separator = "__"


class States(enum.StrEnum):
    home = "a home"
    on_a_walk = "on a walk"
    walking = "currently walking"
    sitting = "currently sitting"
    currently__sitting = "currently sleeping"


class Event:
    go_home = "go_home"
    go_walk = "go_walk"
    sit = "sit"
    walk = "walk"


transitions = [
    {
        "source": States.on_a_walk,
        "dest": States.home,
        "trigger": Event.go_home,
        "before": [lambda: print("going home")],
    },
    {
        "source": States.home,
        "dest": States.on_a_walk,
        "trigger": Event.go_walk,
        "before": [lambda: print("going home")],
    },
    {"source": States.home, "dest": States.on_a_walk, "trigger": Event.go_walk},
    {
        "source": States.walking,
        "dest": States.sitting,
        "trigger": Event.sit,
        "before": [lambda: print("sitting")],
    },
    {"source": States.sitting, "dest": States.walking, "trigger": Event.walk},
]

# === Uncomment to observe crash at intialization
# machine_1 = HierarchicalMachine(
#     states=[
#         States.home,
#         {
#             "name": States.on_a_walk,
#             "children": [States.walking, States.sitting],
#             "initial": States.walking,
#         },
#     ],
#     initial=States.walking,
#     transitions=transitions,
# )


# This crashes with a KeyError("currently") instead of
# The ValueError explaining not to use the separator

# machine_2 = HierarchicalMachine(
#     states=[
#         States.currently__sleeping,
#         States.home,
#         {
#             "name": States.on_a_walk,
#             "children": [States.walking, States.sitting],
#             "initial": States.walking,
#         },
#     ],
#     transitions=transitions,
# )

machine_3 = HierarchicalMachine(
    states=[
        States.home,
        {
            "name": States.on_a_walk,
            "children": [States.walking, States.sitting],
            "initial": States.walking,
        },
    ],
    transitions=transitions,
)

# set_state works as expected
machine_3.set_state(States.walking)

# Should include a transitions for go_home and sit
# as well as to_* transitions
# assert machine_3.get_transitions("", States.walking, delegate=True) != []

# This is needed instead
target_transitions = machine_3.get_transitions(
    "", machine_3._get_enum_path(States.walking), delegate=True
)

    def __call__(self, to_scope=None):
        if isinstance(to_scope, string_types):
            state_name = to_scope.split(self.state_cls.separator)[0]
            state = self.states[state_name]
            to_scope = (state, state.states, state.events, self.prefix_path + [state_name])
        elif isinstance(to_scope, Enum):
            state = self.states[to_scope.name]
            to_scope = (state, state.states, state.events, self.prefix_path + [to_scope.name])
        elif to_scope is None:
            if self._stack:
                to_scope = self._stack[0]
            else:
                to_scope = (self, self.states, self.events, [])
        self._next_scope = to_scope

        with self():
            source_path = [] if source == "*" \
                else source.split(self.state_cls.separator) if isinstance(source, string_types) \
                else self._get_enum_path(source) if isinstance(source, Enum) \
                else self._get_state_path(source)
            dest_path = [] if dest == "*" \
                else dest.split(self.state_cls.separator) if isinstance(dest, string_types) \
                else self._get_enum_path(dest) if isinstance(dest, Enum) \
                else self._get_state_path(dest)
            matches = self.get_nested_transitions(trigger, source_path, dest_path)
            # only consider delegations when source_path contains a nested state (len > 1)
            if delegate is False or len(source_path) < 2:
                return matches
            source_path.pop()
            while source_path:
                matches.extend(self.get_nested_transitions(trigger,
                                                           src_path=source_path,
                                                           dest_path=dest_path))
                source_path.pop()
            return matches

        for state in listify(states):
            if isinstance(state, Enum):
                if isinstance(state.value, EnumMeta):
                    state = {'name': state, 'children': state.value}
                elif isinstance(state.value, dict):
                    state = dict(name=state, **state.value)
            if isinstance(state, string_types):
                self._add_string_state(state, on_enter, on_exit, ignore, remap, **kwargs)
            elif isinstance(state, Enum):
                self._add_enum_state(state, on_enter, on_exit, ignore, remap, **kwargs)
            elif isinstance(state, dict):
                self._add_dict_state(state, ignore, remap, **kwargs)
            elif isinstance(state, NestedState):
                if state.name in self.states:
                    raise ValueError("State {0} cannot be added since it already exists.".format(state.name))
                self.states[state.name] = state
                self._init_state(state)
            elif isinstance(state, HierarchicalMachine):
                self._add_machine_states(state, remap)
            elif isinstance(state, State) and not isinstance(state, NestedState):
                raise ValueError("A passed state object must derive from NestedState! "
                                 "A default State object is not sufficient")
            else:
                raise ValueError("Cannot add state of type {0}. ".format(type(state).__name__))