from collections import namedtuple, OrderedDict

from migen.fhdl.std import *
from migen.fhdl.visit import NodeTransformer

class AnonymousState:
    pass

NextState = namedtuple("NextState", "state")

class _LowerNextState(NodeTransformer):
    def __init__(self, state_signal, next_state_signal, encoding, aliases):
        self.state_signal = state_signal
        self.next_state_signal = next_state_signal
        self.encoding = encoding
        self.aliases = aliases

    def visit_unknown(self, node):
        if isinstance(node, NextState):
            index = _index_is(self.states, node.target_state)
            estate = getattr(self.fsm, self.stnames[index])
            return self.fsm.next_state(estate)
        else:
            return node

class FSM(Module):
    def __init__(self):
        self._actions = OrderedDict()
        self._state_aliases = dict()
        self.reset_state = None

    def act(self, state, *statements):
        if state not in self._actions:
            self._actions[state] = []
        self._actions[state] += statements

    def delayed_enter(self, name, target, delay):
        if delay:
            state = name
            for i in range(delay):
                if i == delay - 1:
                    next_state = target
                else:
                    next_state = AnonymousState()
                self.act(state, NextState(next_state))
                state = next_state
        else:
            self._state_aliases[name] = target

    def finalize(self):
        nstates = len(self._actions)
        encoding = dict((s, n) for n, s in enumerate(self._actions.keys()))
        state = Signal(max=nstates)
        next_state = Signal(max=nstates)
        lns = _LowerNextState(state, next_state, encoding, self._state_aliases)
        cases = dict((encoding[k], lns.visit(v)) for k, v in self._actions.items() if v)
        self.comb += [
            next_state.eq(state),
            Case(state, cases)
        ]
        self.sync += state.eq(next_state)