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

import (

	"fmt"

	"unicode/utf8"

	"google.golang.org/protobuf/internal/encoding/messageset"

	"google.golang.org/protobuf/internal/encoding/text"

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

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

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

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

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

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

	"google.golang.org/protobuf/proto"

	"google.golang.org/protobuf/reflect/protoregistry"

)

// Unmarshal reads the given []byte into the given proto.Message.

// The provided message must be mutable (e.g., a non-nil pointer to a message).

func Unmarshal(b []byte, m proto.Message) error {

	return UnmarshalOptions{}.Unmarshal(b, m)

}

// UnmarshalOptions is a configurable textproto format unmarshaler.

type UnmarshalOptions struct {

	pragma.NoUnkeyedLiterals

	// AllowPartial accepts input for messages that will result in missing

	// required fields. If AllowPartial is false (the default), Unmarshal will

	// return error if there are any missing required fields.

	AllowPartial bool

	// DiscardUnknown specifies whether to ignore unknown fields when parsing.

	// An unknown field is any field whose field name or field number does not

	// resolve to any known or extension field in the message.

	// By default, unmarshal rejects unknown fields as an error.

	DiscardUnknown bool

	// Resolver is used for looking up types when unmarshaling

	// google.protobuf.Any messages or extension fields.

	// If nil, this defaults to using protoregistry.GlobalTypes.

	Resolver interface {

		protoregistry.MessageTypeResolver

		protoregistry.ExtensionTypeResolver

	}

}

// Unmarshal reads the given []byte and populates the given proto.Message

// using options in the UnmarshalOptions object.

// The provided message must be mutable (e.g., a non-nil pointer to a message).

func (o UnmarshalOptions) Unmarshal(b []byte, m proto.Message) error {

	return o.unmarshal(b, m)

}

// unmarshal is a centralized function that all unmarshal operations go through.

// For profiling purposes, avoid changing the name of this function or

// introducing other code paths for unmarshal that do not go through this.

func (o UnmarshalOptions) unmarshal(b []byte, m proto.Message) error {

	proto.Reset(m)

	if o.Resolver == nil {

		o.Resolver = protoregistry.GlobalTypes

	}

	dec := decoder{text.NewDecoder(b), o}

	if err := dec.unmarshalMessage(m.ProtoReflect(), false); err != nil {

		return err

	}

	if o.AllowPartial {

		return nil

	}

	return proto.CheckInitialized(m)

}

type decoder struct {

	*text.Decoder

	opts UnmarshalOptions

}

// newError returns an error object with position info.

func (d decoder) newError(pos int, f string, x ...interface{}) error {

	line, column := d.Position(pos)

	head := fmt.Sprintf("(line %d:%d): ", line, column)

	return errors.New(head+f, x...)

}

// unexpectedTokenError returns a syntax error for the given unexpected token.

func (d decoder) unexpectedTokenError(tok text.Token) error {

	return d.syntaxError(tok.Pos(), "unexpected token: %s", tok.RawString())

}

// syntaxError returns a syntax error for given position.

func (d decoder) syntaxError(pos int, f string, x ...interface{}) error {

	line, column := d.Position(pos)

	head := fmt.Sprintf("syntax error (line %d:%d): ", line, column)

	return errors.New(head+f, x...)

}

// unmarshalMessage unmarshals into the given protoreflect.Message.

	messageDesc := m.Descriptor()

	if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {

		return errors.New("no support for proto1 MessageSets")

	}

	if messageDesc.FullName() == genid.Any_message_fullname {

		return d.unmarshalAny(m, checkDelims)

	}

	if checkDelims {

		tok, err := d.Read()

		if err != nil {

			return err

		}

		if tok.Kind() != text.MessageOpen {

			return d.unexpectedTokenError(tok)

		}

	}

	var seenNums set.Ints

	var seenOneofs set.Ints

	fieldDescs := messageDesc.Fields()

	for {

		// Read field name.

		tok, err := d.Read()

		if err != nil {

			return err

		}

		switch typ := tok.Kind(); typ {

		case text.Name:

			// Continue below.

		case text.EOF:

			if checkDelims {

				return text.ErrUnexpectedEOF

			}

			return nil

		default:

			if checkDelims && typ == text.MessageClose {

				return nil

			}

			return d.unexpectedTokenError(tok)

		}

		// Resolve the field descriptor.

		var xtErr error

		var isFieldNumberName bool

		switch tok.NameKind() {

		case text.IdentName:

			fd = fieldDescs.ByTextName(string(name))

		case text.TypeName:

			// Handle extensions only. This code path is not for Any.

		case text.FieldNumber:

			isFieldNumberName = true

			if !num.IsValid() {

				return d.newError(tok.Pos(), "invalid field number: %d", num)

			}

			fd = fieldDescs.ByNumber(num)

			if fd == nil {

				xt, xtErr = d.opts.Resolver.FindExtensionByNumber(messageDesc.FullName(), num)

			}

		}

		if xt != nil {

			fd = xt.TypeDescriptor()

			if !messageDesc.ExtensionRanges().Has(fd.Number()) || fd.ContainingMessage().FullName() != messageDesc.FullName() {

				return d.newError(tok.Pos(), "message %v cannot be extended by %v", messageDesc.FullName(), fd.FullName())

			}

		} else if xtErr != nil && xtErr != protoregistry.NotFound {

			return d.newError(tok.Pos(), "unable to resolve [%s]: %v", tok.RawString(), xtErr)

		}

		if flags.ProtoLegacy {

			if fd != nil && fd.IsWeak() && fd.Message().IsPlaceholder() {

				fd = nil // reset since the weak reference is not linked in

			}

		}

		// Handle unknown fields.

		if fd == nil {

			if d.opts.DiscardUnknown || messageDesc.ReservedNames().Has(name) {

				d.skipValue()

				continue

			}

			return d.newError(tok.Pos(), "unknown field: %v", tok.RawString())

		}

		// Handle fields identified by field number.

		if isFieldNumberName {

			// TODO: Add an option to permit parsing field numbers.

			//

			// This requires careful thought as the MarshalOptions.EmitUnknown

			// option allows formatting unknown fields as the field number and the

			// best-effort textual representation of the field value.  In that case,

			// it may not be possible to unmarshal the value from a parser that does

			// have information about the unknown field.

			return d.newError(tok.Pos(), "cannot specify field by number: %v", tok.RawString())

		}

		switch {

		case fd.IsList():

			kind := fd.Kind()

				return d.syntaxError(tok.Pos(), "missing field separator :")

			}

			list := m.Mutable(fd).List()

			if err := d.unmarshalList(fd, list); err != nil {

				return err

			}

		case fd.IsMap():

			mmap := m.Mutable(fd).Map()

			if err := d.unmarshalMap(fd, mmap); err != nil {

				return err

			}

		default:

			kind := fd.Kind()

				return d.syntaxError(tok.Pos(), "missing field separator :")

			}

			// If field is a oneof, check if it has already been set.

			if od := fd.ContainingOneof(); od != nil {

				idx := uint64(od.Index())

				if seenOneofs.Has(idx) {

					return d.newError(tok.Pos(), "error parsing %q, oneof %v is already set", tok.RawString(), od.FullName())

				}

				seenOneofs.Set(idx)

			}

			num := uint64(fd.Number())

			if seenNums.Has(num) {

				return d.newError(tok.Pos(), "non-repeated field %q is repeated", tok.RawString())

			}

			if err := d.unmarshalSingular(fd, m); err != nil {

				return err

			}

			seenNums.Set(num)

		}

	}

	return nil

}

// unmarshalSingular unmarshals a non-repeated field value specified by the

// given FieldDescriptor.

	var err error

	switch fd.Kind() {

		val = m.NewField(fd)

		err = d.unmarshalMessage(val.Message(), true)

	default:

		val, err = d.unmarshalScalar(fd)

	}

	if err == nil {

		m.Set(fd, val)

	}

	return err

}

// unmarshalScalar unmarshals a scalar/enum protoreflect.Value specified by the

// given FieldDescriptor.

	tok, err := d.Read()

	if err != nil {

	}

	if tok.Kind() != text.Scalar {

	}

	kind := fd.Kind()

	switch kind {

		if b, ok := tok.Bool(); ok {

		}

		if n, ok := tok.Int32(); ok {

		}

		if n, ok := tok.Int64(); ok {

		}

		if n, ok := tok.Uint32(); ok {

		}

		if n, ok := tok.Uint64(); ok {

		}

		if n, ok := tok.Float32(); ok {

		}

		if n, ok := tok.Float64(); ok {

		}

		if s, ok := tok.String(); ok {

			if strs.EnforceUTF8(fd) && !utf8.ValidString(s) {

			}

		}

		if b, ok := tok.String(); ok {

		}

		if lit, ok := tok.Enum(); ok {

			// Lookup EnumNumber based on name.

			}

		}

		if num, ok := tok.Int32(); ok {

		}

	default:

		panic(fmt.Sprintf("invalid scalar kind %v", kind))

	}

}

// unmarshalList unmarshals into given protoreflect.List. A list value can

// either be in [] syntax or simply just a single scalar/message value.

	tok, err := d.Peek()

	if err != nil {

		return err

	}

	switch fd.Kind() {

		switch tok.Kind() {

		case text.ListOpen:

			d.Read()

			for {

				tok, err := d.Peek()

				if err != nil {

					return err

				}

				switch tok.Kind() {

				case text.ListClose:

					d.Read()

					return nil

				case text.MessageOpen:

					pval := list.NewElement()

					if err := d.unmarshalMessage(pval.Message(), true); err != nil {

						return err

					}

					list.Append(pval)

				default:

					return d.unexpectedTokenError(tok)

				}

			}

		case text.MessageOpen:

			pval := list.NewElement()

			if err := d.unmarshalMessage(pval.Message(), true); err != nil {