// 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"

	"math"

	"strconv"

	"strings"

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

)

// Kind represents a token kind expressible in the textproto format.

type Kind uint8

// Kind values.

const (

	Invalid Kind = iota

	EOF

	Name   // Name indicates the field name.

	Scalar // Scalar are scalar values, e.g. "string", 47, ENUM_LITERAL, true.

	MessageOpen

	MessageClose

	ListOpen

	ListClose

	// comma and semi-colon are only for parsing in between values and should not be exposed.

	comma

	semicolon

	// bof indicates beginning of file, which is the default token

	// kind at the beginning of parsing.

	bof = Invalid

)

func (t Kind) String() string {

	switch t {

	case Invalid:

		return "<invalid>"

	case EOF:

		return "eof"

	case Scalar:

		return "scalar"

	case Name:

		return "name"

	case MessageOpen:

		return "{"

	case MessageClose:

		return "}"

	case ListOpen:

		return "["

	case ListClose:

		return "]"

	case comma:

		return ","

	case semicolon:

		return ";"

	default:

		return fmt.Sprintf("<invalid:%v>", uint8(t))

	}

}

// NameKind represents different types of field names.

type NameKind uint8

// NameKind values.

const (

	IdentName NameKind = iota + 1

	TypeName

	FieldNumber

)

func (t NameKind) String() string {

	switch t {

	case IdentName:

		return "IdentName"

	case TypeName:

		return "TypeName"

	case FieldNumber:

		return "FieldNumber"

	default:

		return fmt.Sprintf("<invalid:%v>", uint8(t))

	}

}

// Bit mask in Token.attrs to indicate if a Name token is followed by the

// separator char ':'. The field name separator char is optional for message

// field or repeated message field, but required for all other types. Decoder

// simply indicates whether a Name token is followed by separator or not.  It is

// up to the prototext package to validate.

const hasSeparator = 1 << 7

// Scalar value types.

const (

	numberValue = iota + 1

	stringValue

	literalValue

)

// Bit mask in Token.numAttrs to indicate that the number is a negative.

const isNegative = 1 << 7

// Token provides a parsed token kind and value. Values are provided by the

// different accessor methods.

type Token struct {

	// Kind of the Token object.

	kind Kind

	// attrs contains metadata for the following Kinds:

	// Name: hasSeparator bit and one of NameKind.

	// Scalar: one of numberValue, stringValue, literalValue.

	attrs uint8

	// numAttrs contains metadata for numberValue:

	// - highest bit is whether negative or positive.

	// - lower bits indicate one of numDec, numHex, numOct, numFloat.

	numAttrs uint8

	// pos provides the position of the token in the original input.

	pos int

	// raw bytes of the serialized token.

	// This is a subslice into the original input.

	raw []byte

	// str contains parsed string for the following:

	// - stringValue of Scalar kind

	// - numberValue of Scalar kind

	// - TypeName of Name kind

	str string

}

// Kind returns the token kind.

func (t Token) Kind() Kind {

	return t.kind

}

// RawString returns the read value in string.

func (t Token) RawString() string {

	return string(t.raw)

}

// Pos returns the token position from the input.

func (t Token) Pos() int {

	return t.pos

}

// NameKind returns IdentName, TypeName or FieldNumber.

// It panics if type is not Name.

func (t Token) NameKind() NameKind {

	if t.kind == Name {

		return NameKind(t.attrs &^ hasSeparator)

	}

	panic(fmt.Sprintf("Token is not a Name type: %s", t.kind))

}

// HasSeparator returns true if the field name is followed by the separator char

// ':', else false. It panics if type is not Name.

func (t Token) HasSeparator() bool {

	if t.kind == Name {

		return t.attrs&hasSeparator != 0

	}

	panic(fmt.Sprintf("Token is not a Name type: %s", t.kind))

}

// IdentName returns the value for IdentName type.

func (t Token) IdentName() string {

	if t.kind == Name && t.attrs&uint8(IdentName) != 0 {

		return string(t.raw)

	}

	panic(fmt.Sprintf("Token is not an IdentName: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))

}

// TypeName returns the value for TypeName type.

func (t Token) TypeName() string {

	if t.kind == Name && t.attrs&uint8(TypeName) != 0 {

		return t.str

	}

	panic(fmt.Sprintf("Token is not a TypeName: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))

}

// FieldNumber returns the value for FieldNumber type. It returns a

// non-negative int32 value. Caller will still need to validate for the correct

// field number range.

func (t Token) FieldNumber() int32 {

	if t.kind != Name || t.attrs&uint8(FieldNumber) == 0 {

		panic(fmt.Sprintf("Token is not a FieldNumber: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))

	}

	// Following should not return an error as it had already been called right

	// before this Token was constructed.

	num, _ := strconv.ParseInt(string(t.raw), 10, 32)

	return int32(num)

}

// String returns the string value for a Scalar type.

func (t Token) String() (string, bool) {

	if t.kind != Scalar || t.attrs != stringValue {

		return "", false

	}

	return t.str, true

}

// Enum returns the literal value for a Scalar type for use as enum literals.

func (t Token) Enum() (string, bool) {

	if t.kind != Scalar || t.attrs != literalValue || (len(t.raw) > 0 && t.raw[0] == '-') {

		return "", false

	}

	return string(t.raw), true

}

// Bool returns the bool value for a Scalar type.

func (t Token) Bool() (bool, bool) {

	if t.kind != Scalar {

		return false, false

	}

	switch t.attrs {

	case literalValue:

		if b, ok := boolLits[string(t.raw)]; ok {

			return b, true

		}

	case numberValue:

		// Unsigned integer representation of 0 or 1 is permitted: 00, 0x0, 01,

		// 0x1, etc.

		n, err := strconv.ParseUint(t.str, 0, 64)

		if err == nil {

			switch n {

			case 0:

				return false, true

			case 1:

				return true, true

			}

		}

	}

	return false, false

}

// These exact boolean literals are the ones supported in C++.

var boolLits = map[string]bool{

	"t":     true,

	"true":  true,

	"True":  true,

	"f":     false,

	"false": false,

	"False": false,

}

// Uint64 returns the uint64 value for a Scalar type.

func (t Token) Uint64() (uint64, bool) {

	if t.kind != Scalar || t.attrs != numberValue ||

		t.numAttrs&isNegative > 0 || t.numAttrs&numFloat > 0 {

		return 0, false

	}

	n, err := strconv.ParseUint(t.str, 0, 64)

	if err != nil {

		return 0, false

	}

	return n, true

}

// Uint32 returns the uint32 value for a Scalar type.

func (t Token) Uint32() (uint32, bool) {

	if t.kind != Scalar || t.attrs != numberValue ||

		t.numAttrs&isNegative > 0 || t.numAttrs&numFloat > 0 {

		return 0, false

	}

	n, err := strconv.ParseUint(t.str, 0, 32)

	if err != nil {

		return 0, false

	}

	return uint32(n), true

}

// Int64 returns the int64 value for a Scalar type.

func (t Token) Int64() (int64, bool) {

	if t.kind != Scalar || t.attrs != numberValue || t.numAttrs&numFloat > 0 {

		return 0, false

	}

	if n, err := strconv.ParseInt(t.str, 0, 64); err == nil {

		return n, true

	}

	// C++ accepts large positive hex numbers as negative values.

	// This feature is here for proto1 backwards compatibility purposes.

	if flags.ProtoLegacy && (t.numAttrs == numHex) {

		if n, err := strconv.ParseUint(t.str, 0, 64); err == nil {

			return int64(n), true

		}

	}

	return 0, false

}

// Int32 returns the int32 value for a Scalar type.

func (t Token) Int32() (int32, bool) {

	if t.kind != Scalar || t.attrs != numberValue || t.numAttrs&numFloat > 0 {

		return 0, false

	}

	if n, err := strconv.ParseInt(t.str, 0, 32); err == nil {

		return int32(n), true

	}

	// C++ accepts large positive hex numbers as negative values.

	// This feature is here for proto1 backwards compatibility purposes.

	if flags.ProtoLegacy && (t.numAttrs == numHex) {

		if n, err := strconv.ParseUint(t.str, 0, 32); err == nil {

			return int32(n), true

		}

	}

	return 0, false

}

// Float64 returns the float64 value for a Scalar type.

func (t Token) Float64() (float64, bool) {

	if t.kind != Scalar {

		return 0, false

	}

	switch t.attrs {

	case literalValue:

		if f, ok := floatLits[strings.ToLower(string(t.raw))]; ok {

			return f, true

		}

	case numberValue:

		n, err := strconv.ParseFloat(t.str, 64)

		if err == nil {

			return n, true

		}

		nerr := err.(*strconv.NumError)

		if nerr.Err == strconv.ErrRange {

			return n, true

		}

	}

	return 0, false

}

// Float32 returns the float32 value for a Scalar type.

func (t Token) Float32() (float32, bool) {

	if t.kind != Scalar {

		return 0, false

	}

	switch t.attrs {

	case literalValue:

		if f, ok := floatLits[strings.ToLower(string(t.raw))]; ok {

			return float32(f), true

		}

	case numberValue:

		n, err := strconv.ParseFloat(t.str, 64)

		if err == nil {

			// Overflows are treated as (-)infinity.

			return float32(n), true

		}

		nerr := err.(*strconv.NumError)

		if nerr.Err == strconv.ErrRange {

			return float32(n), true

		}

	}

	return 0, false

}

// These are the supported float literals which C++ permits case-insensitive

// variants of these.

var floatLits = map[string]float64{

	"nan":       math.NaN(),

	"inf":       math.Inf(1),

	"infinity":  math.Inf(1),

	"-inf":      math.Inf(-1),

	"-infinity": math.Inf(-1),

}

// TokenEquals returns true if given Tokens are equal, else false.

func TokenEquals(x, y Token) bool {

	return x.kind == y.kind &&

		x.attrs == y.attrs &&

		x.numAttrs == y.numAttrs &&

		x.pos == y.pos &&

		bytes.Equal(x.raw, y.raw) &&

		x.str == y.str

}