// Go support for Protocol Buffers - Google's data interchange format

//

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

// https://github.com/golang/protobuf

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package proto

import (

	"errors"

	"fmt"

	"math"

	"reflect"

	"sort"

	"strconv"

	"strings"

	"sync"

	"sync/atomic"

	"unicode/utf8"

)

// a sizer takes a pointer to a field and the size of its tag, computes the size of

// the encoded data.

type sizer func(pointer, int) int

// a marshaler takes a byte slice, a pointer to a field, and its tag (in wire format),

// marshals the field to the end of the slice, returns the slice and error (if any).

type marshaler func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error)

// marshalInfo is the information used for marshaling a message.

type marshalInfo struct {

	typ          reflect.Type

	fields       []*marshalFieldInfo

	unrecognized field                      // offset of XXX_unrecognized

	extensions   field                      // offset of XXX_InternalExtensions

	v1extensions field                      // offset of XXX_extensions

	sizecache    field                      // offset of XXX_sizecache

	initialized  int32                      // 0 -- only typ is set, 1 -- fully initialized

	messageset   bool                       // uses message set wire format

	hasmarshaler bool                       // has custom marshaler

	sync.RWMutex                            // protect extElems map, also for initialization

	extElems     map[int32]*marshalElemInfo // info of extension elements

}

// marshalFieldInfo is the information used for marshaling a field of a message.

type marshalFieldInfo struct {

	field      field

	wiretag    uint64 // tag in wire format

	tagsize    int    // size of tag in wire format

	sizer      sizer

	marshaler  marshaler

	isPointer  bool

	required   bool                              // field is required

	name       string                            // name of the field, for error reporting

	oneofElems map[reflect.Type]*marshalElemInfo // info of oneof elements

}

// marshalElemInfo is the information used for marshaling an extension or oneof element.

type marshalElemInfo struct {

	wiretag   uint64 // tag in wire format

	tagsize   int    // size of tag in wire format

	sizer     sizer

	marshaler marshaler

	isptr     bool // elem is pointer typed, thus interface of this type is a direct interface (extension only)

}

var (

	marshalInfoMap  = map[reflect.Type]*marshalInfo{}

	marshalInfoLock sync.Mutex

)

// getMarshalInfo returns the information to marshal a given type of message.

// The info it returns may not necessarily initialized.

// t is the type of the message (NOT the pointer to it).

func getMarshalInfo(t reflect.Type) *marshalInfo {

	marshalInfoLock.Lock()

	u, ok := marshalInfoMap[t]

	if !ok {

		u = &marshalInfo{typ: t}

		marshalInfoMap[t] = u

	}

	marshalInfoLock.Unlock()

	return u

}

// Size is the entry point from generated code,

// and should be ONLY called by generated code.

// It computes the size of encoded data of msg.

// a is a pointer to a place to store cached marshal info.

func (a *InternalMessageInfo) Size(msg Message) int {

	u := getMessageMarshalInfo(msg, a)

	ptr := toPointer(&msg)

	if ptr.isNil() {

		// We get here if msg is a typed nil ((*SomeMessage)(nil)),

		// so it satisfies the interface, and msg == nil wouldn't

		// catch it. We don't want crash in this case.

		return 0

	}

	return u.size(ptr)

}

// Marshal is the entry point from generated code,

// and should be ONLY called by generated code.

// It marshals msg to the end of b.

// a is a pointer to a place to store cached marshal info.

func (a *InternalMessageInfo) Marshal(b []byte, msg Message, deterministic bool) ([]byte, error) {

	u := getMessageMarshalInfo(msg, a)

	ptr := toPointer(&msg)

	if ptr.isNil() {

		// We get here if msg is a typed nil ((*SomeMessage)(nil)),

		// so it satisfies the interface, and msg == nil wouldn't

		// catch it. We don't want crash in this case.

		return b, ErrNil

	}

	return u.marshal(b, ptr, deterministic)

}

func getMessageMarshalInfo(msg interface{}, a *InternalMessageInfo) *marshalInfo {

	// u := a.marshal, but atomically.

	// We use an atomic here to ensure memory consistency.

	u := atomicLoadMarshalInfo(&a.marshal)

	if u == nil {

		// Get marshal information from type of message.

		t := reflect.ValueOf(msg).Type()

		if t.Kind() != reflect.Ptr {

			panic(fmt.Sprintf("cannot handle non-pointer message type %v", t))

		}

		u = getMarshalInfo(t.Elem())

		// Store it in the cache for later users.

		// a.marshal = u, but atomically.

		atomicStoreMarshalInfo(&a.marshal, u)

	}

	return u

}

// size is the main function to compute the size of the encoded data of a message.

// ptr is the pointer to the message.

func (u *marshalInfo) size(ptr pointer) int {

	if atomic.LoadInt32(&u.initialized) == 0 {

		u.computeMarshalInfo()

	}

	// If the message can marshal itself, let it do it, for compatibility.

	// NOTE: This is not efficient.

	if u.hasmarshaler {

		m := ptr.asPointerTo(u.typ).Interface().(Marshaler)

		b, _ := m.Marshal()

		return len(b)

	}

	n := 0

	for _, f := range u.fields {

		if f.isPointer && ptr.offset(f.field).getPointer().isNil() {

			// nil pointer always marshals to nothing

			continue

		}

		n += f.sizer(ptr.offset(f.field), f.tagsize)

	}

	if u.extensions.IsValid() {

		e := ptr.offset(u.extensions).toExtensions()

		if u.messageset {

			n += u.sizeMessageSet(e)

		} else {

			n += u.sizeExtensions(e)

		}

	}

	if u.v1extensions.IsValid() {

		m := *ptr.offset(u.v1extensions).toOldExtensions()

		n += u.sizeV1Extensions(m)

	}

	if u.unrecognized.IsValid() {

		s := *ptr.offset(u.unrecognized).toBytes()

		n += len(s)

	}

	// cache the result for use in marshal

	if u.sizecache.IsValid() {

		atomic.StoreInt32(ptr.offset(u.sizecache).toInt32(), int32(n))

	}

	return n

}

// cachedsize gets the size from cache. If there is no cache (i.e. message is not generated),

// fall back to compute the size.

func (u *marshalInfo) cachedsize(ptr pointer) int {

	if u.sizecache.IsValid() {

		return int(atomic.LoadInt32(ptr.offset(u.sizecache).toInt32()))

	}

	return u.size(ptr)

}

// marshal is the main function to marshal a message. It takes a byte slice and appends

// the encoded data to the end of the slice, returns the slice and error (if any).

// ptr is the pointer to the message.

// If deterministic is true, map is marshaled in deterministic order.

func (u *marshalInfo) marshal(b []byte, ptr pointer, deterministic bool) ([]byte, error) {

	if atomic.LoadInt32(&u.initialized) == 0 {

		u.computeMarshalInfo()

	}

	// If the message can marshal itself, let it do it, for compatibility.

	// NOTE: This is not efficient.

	if u.hasmarshaler {

		m := ptr.asPointerTo(u.typ).Interface().(Marshaler)

		b1, err := m.Marshal()

		b = append(b, b1...)

		return b, err

	}

	var err, errLater error

	// The old marshaler encodes extensions at beginning.

	if u.extensions.IsValid() {

		e := ptr.offset(u.extensions).toExtensions()

		if u.messageset {

			b, err = u.appendMessageSet(b, e, deterministic)

		} else {

			b, err = u.appendExtensions(b, e, deterministic)

		}

		if err != nil {

			return b, err

		}

	}

	if u.v1extensions.IsValid() {

		m := *ptr.offset(u.v1extensions).toOldExtensions()

		b, err = u.appendV1Extensions(b, m, deterministic)

		if err != nil {

			return b, err

		}

	}

	for _, f := range u.fields {

		if f.required {

			if ptr.offset(f.field).getPointer().isNil() {

				// Required field is not set.

				// We record the error but keep going, to give a complete marshaling.

				if errLater == nil {

					errLater = &RequiredNotSetError{f.name}

				}

				continue

			}

		}

		if f.isPointer && ptr.offset(f.field).getPointer().isNil() {

			// nil pointer always marshals to nothing

			continue

		}

		b, err = f.marshaler(b, ptr.offset(f.field), f.wiretag, deterministic)

		if err != nil {

			if err1, ok := err.(*RequiredNotSetError); ok {

				// Required field in submessage is not set.

				// We record the error but keep going, to give a complete marshaling.

				if errLater == nil {

					errLater = &RequiredNotSetError{f.name + "." + err1.field}

				}

				continue

			}

			if err == errRepeatedHasNil {

				err = errors.New("proto: repeated field " + f.name + " has nil element")

			}

			if err == errInvalidUTF8 {

				if errLater == nil {

					fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name

					errLater = &invalidUTF8Error{fullName}

				}

				continue

			}

			return b, err

		}

	}

	if u.unrecognized.IsValid() {

		s := *ptr.offset(u.unrecognized).toBytes()

		b = append(b, s...)

	}

	return b, errLater

}

// computeMarshalInfo initializes the marshal info.

func (u *marshalInfo) computeMarshalInfo() {

	u.Lock()

	defer u.Unlock()

	if u.initialized != 0 { // non-atomic read is ok as it is protected by the lock

		return

	}

	t := u.typ

	u.unrecognized = invalidField

	u.extensions = invalidField

	u.v1extensions = invalidField

	u.sizecache = invalidField

	// If the message can marshal itself, let it do it, for compatibility.

	// NOTE: This is not efficient.

	if reflect.PtrTo(t).Implements(marshalerType) {

		u.hasmarshaler = true

		atomic.StoreInt32(&u.initialized, 1)

		return

	}

	// get oneof implementers

	var oneofImplementers []interface{}

		_, _, _, oneofImplementers = m.XXX_OneofFuncs()

	}

	n := t.NumField()

	// deal with XXX fields first

	for i := 0; i < t.NumField(); i++ {

		f := t.Field(i)

		if !strings.HasPrefix(f.Name, "XXX_") {

			continue

		}

		switch f.Name {

		case "XXX_sizecache":

			u.sizecache = toField(&f)

		case "XXX_unrecognized":

			u.unrecognized = toField(&f)

		case "XXX_InternalExtensions":

			u.extensions = toField(&f)

			u.messageset = f.Tag.Get("protobuf_messageset") == "1"

		case "XXX_extensions":

			u.v1extensions = toField(&f)

		case "XXX_NoUnkeyedLiteral":

			// nothing to do

		default:

			panic("unknown XXX field: " + f.Name)

		}

		n--

	}

	// normal fields

	fields := make([]marshalFieldInfo, n) // batch allocation

	u.fields = make([]*marshalFieldInfo, 0, n)

	for i, j := 0, 0; i < t.NumField(); i++ {

		f := t.Field(i)

		if strings.HasPrefix(f.Name, "XXX_") {

			continue

		}

		field := &fields[j]

		j++

		field.name = f.Name

		u.fields = append(u.fields, field)

		if f.Tag.Get("protobuf_oneof") != "" {

			field.computeOneofFieldInfo(&f, oneofImplementers)

			continue

		}

		if f.Tag.Get("protobuf") == "" {

			// field has no tag (not in generated message), ignore it

			u.fields = u.fields[:len(u.fields)-1]

			j--

			continue

		}

		field.computeMarshalFieldInfo(&f)

	}

	// fields are marshaled in tag order on the wire.

	sort.Sort(byTag(u.fields))

	atomic.StoreInt32(&u.initialized, 1)

}

// helper for sorting fields by tag

type byTag []*marshalFieldInfo

func (a byTag) Len() int           { return len(a) }

func (a byTag) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

func (a byTag) Less(i, j int) bool { return a[i].wiretag < a[j].wiretag }

// getExtElemInfo returns the information to marshal an extension element.

// The info it returns is initialized.

func (u *marshalInfo) getExtElemInfo(desc *ExtensionDesc) *marshalElemInfo {

	// get from cache first

	u.RLock()

	e, ok := u.extElems[desc.Field]

	u.RUnlock()

	if ok {

		return e

	}

	t := reflect.TypeOf(desc.ExtensionType) // pointer or slice to basic type or struct

	tags := strings.Split(desc.Tag, ",")