// Copyright 2018 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

package text

import (

	"bytes"

	"fmt"

	"io"

	"regexp"

	"strconv"

	"unicode/utf8"

	"google.golang.org/protobuf/internal/errors"

)

// Decoder is a token-based textproto decoder.

type Decoder struct {

	// lastCall is last method called, either readCall or peekCall.

	// Initial value is readCall.

	lastCall call

	// lastToken contains the last read token.

	lastToken Token

	// lastErr contains the last read error.

	lastErr error

	// openStack is a stack containing the byte characters for MessageOpen and

	// ListOpen kinds. The top of stack represents the message or the list that

	// the current token is nested in. An empty stack means the current token is

	// at the top level message. The characters '{' and '<' both represent the

	// MessageOpen kind.

	openStack []byte

	// orig is used in reporting line and column.

	orig []byte

	// in contains the unconsumed input.

	in []byte

}

// NewDecoder returns a Decoder to read the given []byte.

func NewDecoder(b []byte) *Decoder {

	return &Decoder{orig: b, in: b}

}

// ErrUnexpectedEOF means that EOF was encountered in the middle of the input.

var ErrUnexpectedEOF = errors.New("%v", io.ErrUnexpectedEOF)

// call specifies which Decoder method was invoked.

type call uint8

const (

	readCall call = iota

	peekCall

)

// Peek looks ahead and returns the next token and error without advancing a read.

func (d *Decoder) Peek() (Token, error) {

	defer func() { d.lastCall = peekCall }()

	if d.lastCall == readCall {

		d.lastToken, d.lastErr = d.Read()

	}

	return d.lastToken, d.lastErr

}

// Read returns the next token.

// It will return an error if there is no valid token.

func (d *Decoder) Read() (Token, error) {

	defer func() { d.lastCall = readCall }()

	if d.lastCall == peekCall {

		return d.lastToken, d.lastErr

	}

	tok, err := d.parseNext(d.lastToken.kind)

	if err != nil {

		return Token{}, err

	}

	switch tok.kind {

	case comma, semicolon:

		tok, err = d.parseNext(tok.kind)

		if err != nil {

			return Token{}, err

		}

	}

	d.lastToken = tok

	return tok, nil

}

const (

	mismatchedFmt = "mismatched close character %q"

	unexpectedFmt = "unexpected character %q"

)

// parseNext parses the next Token based on given last kind.

func (d *Decoder) parseNext(lastKind Kind) (Token, error) {

	// Trim leading spaces.

	d.consume(0)

	isEOF := false

	if len(d.in) == 0 {

		isEOF = true

	}

	switch lastKind {

	case EOF:

		return d.consumeToken(EOF, 0, 0), nil

	case bof:

		// Start of top level message. Next token can be EOF or Name.

		if isEOF {

			return d.consumeToken(EOF, 0, 0), nil

		}

		return d.parseFieldName()

	case Name:

		// Next token can be MessageOpen, ListOpen or Scalar.

		if isEOF {

			return Token{}, ErrUnexpectedEOF

		}

		switch ch := d.in[0]; ch {

		case '{', '<':

			d.pushOpenStack(ch)

			return d.consumeToken(MessageOpen, 1, 0), nil

		case '[':

			d.pushOpenStack(ch)

			return d.consumeToken(ListOpen, 1, 0), nil

		default:

			return d.parseScalar()

		}

	case Scalar:

		openKind, closeCh := d.currentOpenKind()

		switch openKind {

		case bof:

			// Top level message.

			// 	Next token can be EOF, comma, semicolon or Name.

			if isEOF {

				return d.consumeToken(EOF, 0, 0), nil

			}

			switch d.in[0] {

			case ',':

				return d.consumeToken(comma, 1, 0), nil

			case ';':

				return d.consumeToken(semicolon, 1, 0), nil

			default:

				return d.parseFieldName()

			}

		case MessageOpen:

			// Next token can be MessageClose, comma, semicolon or Name.

			if isEOF {

				return Token{}, ErrUnexpectedEOF

			}

			switch ch := d.in[0]; ch {

			case closeCh:

				d.popOpenStack()

				return d.consumeToken(MessageClose, 1, 0), nil

			case otherCloseChar[closeCh]:

				return Token{}, d.newSyntaxError(mismatchedFmt, ch)

			case ',':

				return d.consumeToken(comma, 1, 0), nil

			case ';':

				return d.consumeToken(semicolon, 1, 0), nil

			default:

				return d.parseFieldName()

			}

		case ListOpen:

			// Next token can be ListClose or comma.

			if isEOF {

				return Token{}, ErrUnexpectedEOF

			}

			switch ch := d.in[0]; ch {

			case ']':

				d.popOpenStack()

				return d.consumeToken(ListClose, 1, 0), nil

			case ',':

				return d.consumeToken(comma, 1, 0), nil

			default:

				return Token{}, d.newSyntaxError(unexpectedFmt, ch)

			}

		}

	case MessageOpen:

		// Next token can be MessageClose or Name.

		if isEOF {

			return Token{}, ErrUnexpectedEOF

		}

		_, closeCh := d.currentOpenKind()

		switch ch := d.in[0]; ch {

		case closeCh:

			d.popOpenStack()

			return d.consumeToken(MessageClose, 1, 0), nil

		case otherCloseChar[closeCh]:

			return Token{}, d.newSyntaxError(mismatchedFmt, ch)

		default:

			return d.parseFieldName()

		}

	case MessageClose:

		openKind, closeCh := d.currentOpenKind()

		switch openKind {

		case bof:

			// Top level message.

			// Next token can be EOF, comma, semicolon or Name.

			if isEOF {

				return d.consumeToken(EOF, 0, 0), nil

			}

			switch ch := d.in[0]; ch {

			case ',':

				return d.consumeToken(comma, 1, 0), nil

			case ';':

				return d.consumeToken(semicolon, 1, 0), nil

			default:

				return d.parseFieldName()

			}

		case MessageOpen:

			// Next token can be MessageClose, comma, semicolon or Name.

			if isEOF {

				return Token{}, ErrUnexpectedEOF

			}

			switch ch := d.in[0]; ch {

			case closeCh:

				d.popOpenStack()

				return d.consumeToken(MessageClose, 1, 0), nil

			case otherCloseChar[closeCh]:

				return Token{}, d.newSyntaxError(mismatchedFmt, ch)

			case ',':

				return d.consumeToken(comma, 1, 0), nil

			case ';':

				return d.consumeToken(semicolon, 1, 0), nil

			default:

				return d.parseFieldName()

			}

		case ListOpen:

			// Next token can be ListClose or comma

			if isEOF {

				return Token{}, ErrUnexpectedEOF

			}

			switch ch := d.in[0]; ch {

			case closeCh:

				d.popOpenStack()

				return d.consumeToken(ListClose, 1, 0), nil

			case ',':

				return d.consumeToken(comma, 1, 0), nil

			default:

				return Token{}, d.newSyntaxError(unexpectedFmt, ch)

			}

		}

	case ListOpen:

		// Next token can be ListClose, MessageStart or Scalar.

		if isEOF {

			return Token{}, ErrUnexpectedEOF

		}

		switch ch := d.in[0]; ch {

		case ']':

			d.popOpenStack()

			return d.consumeToken(ListClose, 1, 0), nil

		case '{', '<':

			d.pushOpenStack(ch)

			return d.consumeToken(MessageOpen, 1, 0), nil

		default:

			return d.parseScalar()

		}

	case ListClose:

		openKind, closeCh := d.currentOpenKind()

		switch openKind {

		case bof:

			// Top level message.

			// Next token can be EOF, comma, semicolon or Name.

			if isEOF {

				return d.consumeToken(EOF, 0, 0), nil

			}

			switch ch := d.in[0]; ch {

			case ',':

				return d.consumeToken(comma, 1, 0), nil

			case ';':

				return d.consumeToken(semicolon, 1, 0), nil

			default:

				return d.parseFieldName()

			}

		case MessageOpen:

			// Next token can be MessageClose, comma, semicolon or Name.

			if isEOF {

				return Token{}, ErrUnexpectedEOF

			}

			switch ch := d.in[0]; ch {

			case closeCh:

				d.popOpenStack()

				return d.consumeToken(MessageClose, 1, 0), nil

			case otherCloseChar[closeCh]:

				return Token{}, d.newSyntaxError(mismatchedFmt, ch)

			case ',':

				return d.consumeToken(comma, 1, 0), nil

			case ';':

				return d.consumeToken(semicolon, 1, 0), nil

			default:

				return d.parseFieldName()

			}

		default:

			// It is not possible to have this case. Let it panic below.

		}

	case comma, semicolon:

		openKind, closeCh := d.currentOpenKind()

		switch openKind {

		case bof:

			// Top level message. Next token can be EOF or Name.

			if isEOF {

				return d.consumeToken(EOF, 0, 0), nil

			}

			return d.parseFieldName()

		case MessageOpen:

			// Next token can be MessageClose or Name.

			if isEOF {

				return Token{}, ErrUnexpectedEOF

			}

			switch ch := d.in[0]; ch {

			case closeCh:

				d.popOpenStack()

				return d.consumeToken(MessageClose, 1, 0), nil

			case otherCloseChar[closeCh]:

				return Token{}, d.newSyntaxError(mismatchedFmt, ch)

			default:

				return d.parseFieldName()

			}

		case ListOpen:

			if lastKind == semicolon {

				// It is not be possible to have this case as logic here

				// should not have produced a semicolon Token when inside a

				// list. Let it panic below.

				break

			}

			// Next token can be MessageOpen or Scalar.

			if isEOF {

				return Token{}, ErrUnexpectedEOF

			}

			switch ch := d.in[0]; ch {

			case '{', '<':

				d.pushOpenStack(ch)

				return d.consumeToken(MessageOpen, 1, 0), nil

			default:

				return d.parseScalar()

			}

		}

	}

	line, column := d.Position(len(d.orig) - len(d.in))

	panic(fmt.Sprintf("Decoder.parseNext: bug at handling line %d:%d with lastKind=%v", line, column, lastKind))

}

var otherCloseChar = map[byte]byte{

	'}': '>',

	'>': '}',

}

// currentOpenKind indicates whether current position is inside a message, list

// or top-level message by returning MessageOpen, ListOpen or bof respectively.

// If the returned kind is either a MessageOpen or ListOpen, it also returns the

// corresponding closing character.

func (d *Decoder) currentOpenKind() (Kind, byte) {

	if len(d.openStack) == 0 {

		return bof, 0

	}

	openCh := d.openStack[len(d.openStack)-1]

	switch openCh {

	case '{':

		return MessageOpen, '}'

	case '<':

		return MessageOpen, '>'

	case '[':

		return ListOpen, ']'

	}

	panic(fmt.Sprintf("Decoder: openStack contains invalid byte %s", string(openCh)))

}

func (d *Decoder) pushOpenStack(ch byte) {

	d.openStack = append(d.openStack, ch)

}

func (d *Decoder) popOpenStack() {

	d.openStack = d.openStack[:len(d.openStack)-1]

}

// parseFieldName parses field name and separator.

func (d *Decoder) parseFieldName() (tok Token, err error) {

	defer func() {

		if err == nil && d.tryConsumeChar(':') {

			tok.attrs |= hasSeparator

		}

	}()

	// Extension or Any type URL.

	if d.in[0] == '[' {

		return d.parseTypeName()

	}

	// Identifier.

	if size := parseIdent(d.in, false); size > 0 {

		return d.consumeToken(Name, size, uint8(IdentName)), nil

	}

	// Field number. Identify if input is a valid number that is not negative

	// and is decimal integer within 32-bit range.