package scanner

// Peeker is a utility that wraps a token channel returned by Scan and
// provides an interface that allows a caller (e.g. the parser) to
// work with the token stream in a mode that allows one token of lookahead,
// and provides utilities for more convenient processing of the stream.
type Peeker struct {
	ch     <-chan *Token
	peeked *Token
}

func NewPeeker(ch <-chan *Token) *Peeker {
	return &Peeker{
		ch: ch,
	}
}

// Peek returns the next token in the stream without consuming it. A
// subsequent call to Read will return the same token.
func (p *Peeker) Peek() *Token {
	if p.peeked == nil {
		p.peeked = <-p.ch
	}
	return p.peeked
}

// Read consumes the next token in the stream and returns it.
func (p *Peeker) Read() *Token {
	token := p.Peek()

	// As a special case, we will produce the EOF token forever once
	// it is reached.
	if token.Type != EOF {
		p.peeked = nil
	}

	return token
}

// Close ensures that the token stream has been exhausted, to prevent
// the goroutine in the underlying scanner from leaking.
//
// It's not necessary to call this if the caller reads the token stream
// to EOF, since that implicitly closes the scanner.
func (p *Peeker) Close() {
	for _ = range p.ch {
		// discard
	}
	// Install a synthetic EOF token in 'peeked' in case someone
	// erroneously calls Peek() or Read() after we've closed.
	p.peeked = &Token{
		Type:    EOF,
		Content: "",
	}
}