package parsekit

// RouteTo tells the parser what StateHandler function to invoke
// in the next parsing cycle.
func (p *P) RouteTo(state StateHandler) *routeFollowupAction {
	p.nextState = state
	return &routeFollowupAction{chainAction: chainAction{p, true}}
}

// RouteRepeat indicates that on the next parsing cycle, the current
// StateHandler must be reinvoked.
func (p *P) RouteRepeat() *chainAction {
	p.RouteTo(p.state)
	return &chainAction{nil, true}
}

// RouteReturn tells the parser that on the next cycle the last
// StateHandler that was pushed on the route stack must be invoked.
//
// Using this method is optional. When implementating a StateHandler that
// is used as a sort of subroutine (using constructions like
// p.RouteTo(subroutine).ThenReturnHere()), you can refrain from
// providing an explicit routing decision from that handler. The parser will
// automatically assume a RouteReturn() in that case.
func (p *P) RouteReturn() *chainAction {
	p.nextState = p.popRoute()
	return &chainAction{nil, true}
}

// pushRoute adds the StateHandler to the route stack.
// This is used for implementing nested parsing.
func (p *P) pushRoute(state StateHandler) {
	p.routeStack = append(p.routeStack, state)
}

// popRoute pops the last pushed StateHandler from the route stack.
func (p *P) popRoute() StateHandler {
	last := len(p.routeStack) - 1
	head, tail := p.routeStack[:last], p.routeStack[last]
	p.routeStack = head
	return tail
}