// Copyright 2019 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 impl

import (

	"fmt"

	"reflect"

	"sync"

	"google.golang.org/protobuf/encoding/protowire"

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

	"google.golang.org/protobuf/proto"

)

type errInvalidUTF8 struct{}

func (errInvalidUTF8) Error() string     { return "string field contains invalid UTF-8" }

func (errInvalidUTF8) InvalidUTF8() bool { return true }

func (errInvalidUTF8) Unwrap() error     { return errors.Error }

// initOneofFieldCoders initializes the fast-path functions for the fields in a oneof.

//

// For size, marshal, and isInit operations, functions are set only on the first field

// in the oneof. The functions are called when the oneof is non-nil, and will dispatch

// to the appropriate field-specific function as necessary.

//

// The unmarshal function is set on each field individually as usual.

	fs := si.oneofsByName[od.Name()]

	ft := fs.Type

	oneofFields := make(map[reflect.Type]*coderFieldInfo)

	needIsInit := false

	fields := od.Fields()

	for i, lim := 0, fields.Len(); i < lim; i++ {

		fd := od.Fields().Get(i)

		num := fd.Number()

		// Make a copy of the original coderFieldInfo for use in unmarshaling.

		//

		// oneofFields[oneofType].funcs.marshal is the field-specific marshal function.

		//

		// mi.coderFields[num].marshal is set on only the first field in the oneof,

		// and dispatches to the field-specific marshaler in oneofFields.

		cf := *mi.coderFields[num]

		ot := si.oneofWrappersByNumber[num]

		cf.ft = ot.Field(0).Type

		cf.mi, cf.funcs = fieldCoder(fd, cf.ft)

		oneofFields[ot] = &cf

		if cf.funcs.isInit != nil {

			needIsInit = true

		}

		mi.coderFields[num].funcs.unmarshal = func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {

			var vw reflect.Value         // pointer to wrapper type

			vi := p.AsValueOf(ft).Elem() // oneof field value of interface kind

			if !vi.IsNil() && !vi.Elem().IsNil() && vi.Elem().Elem().Type() == ot {

				vw = vi.Elem()

			} else {

				vw = reflect.New(ot)

			}

			out, err := cf.funcs.unmarshal(b, pointerOfValue(vw).Apply(zeroOffset), wtyp, &cf, opts)

			if err != nil {

				return out, err

			}

			vi.Set(vw)

			return out, nil

		}

	}

	getInfo := func(p pointer) (pointer, *coderFieldInfo) {

		v := p.AsValueOf(ft).Elem()

		if v.IsNil() {

			return pointer{}, nil

		}

		v = v.Elem() // interface -> *struct

		if v.IsNil() {

			return pointer{}, nil

		}

		return pointerOfValue(v).Apply(zeroOffset), oneofFields[v.Elem().Type()]

	}

	first := mi.coderFields[od.Fields().Get(0).Number()]

	first.funcs.size = func(p pointer, _ *coderFieldInfo, opts marshalOptions) int {

		p, info := getInfo(p)

		if info == nil || info.funcs.size == nil {

			return 0

		}

		return info.funcs.size(p, info, opts)

	}

	first.funcs.marshal = func(b []byte, p pointer, _ *coderFieldInfo, opts marshalOptions) ([]byte, error) {

		p, info := getInfo(p)

		if info == nil || info.funcs.marshal == nil {

			return b, nil

		}

		return info.funcs.marshal(b, p, info, opts)

	}

	first.funcs.merge = func(dst, src pointer, _ *coderFieldInfo, opts mergeOptions) {

		srcp, srcinfo := getInfo(src)

		if srcinfo == nil || srcinfo.funcs.merge == nil {

			return

		}

		dstp, dstinfo := getInfo(dst)

		if dstinfo != srcinfo {

			dst.AsValueOf(ft).Elem().Set(reflect.New(src.AsValueOf(ft).Elem().Elem().Elem().Type()))

			dstp = pointerOfValue(dst.AsValueOf(ft).Elem().Elem()).Apply(zeroOffset)

		}

		srcinfo.funcs.merge(dstp, srcp, srcinfo, opts)

	}

	if needIsInit {

		first.funcs.isInit = func(p pointer, _ *coderFieldInfo) error {

			p, info := getInfo(p)

			if info == nil || info.funcs.isInit == nil {

				return nil

			}

			return info.funcs.isInit(p, info)

		}

	}

}

	var once sync.Once

	lazyInit := func() {

		once.Do(func() {

			messageName := fd.Message().FullName()

		})

	}

	return pointerCoderFuncs{

		size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {

			m, ok := p.WeakFields().get(f.num)

			if !ok {

				return 0

			}

			lazyInit()

			if messageType == nil {

				panic(fmt.Sprintf("weak message %v is not linked in", fd.Message().FullName()))

			}

			return sizeMessage(m, f.tagsize, opts)

		},

		marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {

			m, ok := p.WeakFields().get(f.num)

			if !ok {

				return b, nil

			}

			lazyInit()

			if messageType == nil {

				panic(fmt.Sprintf("weak message %v is not linked in", fd.Message().FullName()))

			}

			return appendMessage(b, m, f.wiretag, opts)

		},

		unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {

			fs := p.WeakFields()

			m, ok := fs.get(f.num)

			if !ok {

				lazyInit()

				if messageType == nil {

					return unmarshalOutput{}, errUnknown

				}

				m = messageType.New().Interface()

				fs.set(f.num, m)

			}

			return consumeMessage(b, m, wtyp, opts)

		},

		isInit: func(p pointer, f *coderFieldInfo) error {

			m, ok := p.WeakFields().get(f.num)

			if !ok {

				return nil

			}

			return proto.CheckInitialized(m)

		},

		merge: func(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {

			sm, ok := src.WeakFields().get(f.num)

			if !ok {

				return

			}

			dm, ok := dst.WeakFields().get(f.num)

			if !ok {

				lazyInit()

				if messageType == nil {

					panic(fmt.Sprintf("weak message %v is not linked in", fd.Message().FullName()))

				}

				dm = messageType.New().Interface()

				dst.WeakFields().set(f.num, dm)

			}

			opts.Merge(dm, sm)

		},

	}

}

	if mi := getMessageInfo(ft); mi != nil {

		funcs := pointerCoderFuncs{

			size:      sizeMessageInfo,

			marshal:   appendMessageInfo,

			unmarshal: consumeMessageInfo,

			merge:     mergeMessage,

		}

		if needsInitCheck(mi.Desc) {

			funcs.isInit = isInitMessageInfo

		}

		return funcs

	} else {

		return pointerCoderFuncs{

			size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {

				m := asMessage(p.AsValueOf(ft).Elem())

				return sizeMessage(m, f.tagsize, opts)

			},

			marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {

				m := asMessage(p.AsValueOf(ft).Elem())

				return appendMessage(b, m, f.wiretag, opts)

			},

			unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {

				mp := p.AsValueOf(ft).Elem()

				if mp.IsNil() {

					mp.Set(reflect.New(ft.Elem()))

				}

				return consumeMessage(b, asMessage(mp), wtyp, opts)

			},

			isInit: func(p pointer, f *coderFieldInfo) error {

				m := asMessage(p.AsValueOf(ft).Elem())

				return proto.CheckInitialized(m)

			},

			merge: mergeMessage,

		}

	}

}

func sizeMessageInfo(p pointer, f *coderFieldInfo, opts marshalOptions) int {

	return protowire.SizeBytes(f.mi.sizePointer(p.Elem(), opts)) + f.tagsize

}

func appendMessageInfo(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {

	b = protowire.AppendVarint(b, f.wiretag)

	b = protowire.AppendVarint(b, uint64(f.mi.sizePointer(p.Elem(), opts)))

	return f.mi.marshalAppendPointer(b, p.Elem(), opts)

}

func consumeMessageInfo(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {

	if wtyp != protowire.BytesType {

		return out, errUnknown

	}

	v, n := protowire.ConsumeBytes(b)

	if n < 0 {

		return out, errDecode

	}

	if p.Elem().IsNil() {

		p.SetPointer(pointerOfValue(reflect.New(f.mi.GoReflectType.Elem())))

	}

	o, err := f.mi.unmarshalPointer(v, p.Elem(), 0, opts)

	if err != nil {

		return out, err

	}

	out.n = n

	out.initialized = o.initialized

	return out, nil

}

func isInitMessageInfo(p pointer, f *coderFieldInfo) error {

	return f.mi.checkInitializedPointer(p.Elem())

}

func sizeMessage(m proto.Message, tagsize int, _ marshalOptions) int {

	return protowire.SizeBytes(proto.Size(m)) + tagsize

}

func appendMessage(b []byte, m proto.Message, wiretag uint64, opts marshalOptions) ([]byte, error) {

	b = protowire.AppendVarint(b, wiretag)

	b = protowire.AppendVarint(b, uint64(proto.Size(m)))

	return opts.Options().MarshalAppend(b, m)

}

func consumeMessage(b []byte, m proto.Message, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {

	if wtyp != protowire.BytesType {

		return out, errUnknown

	}

	v, n := protowire.ConsumeBytes(b)

	if n < 0 {

		return out, errDecode

	}

		Buf:     v,

		Message: m.ProtoReflect(),

	})

	if err != nil {

		return out, err

	}

	out.n = n

	return out, nil

}

	m := v.Message().Interface()

	return sizeMessage(m, tagsize, opts)

}

	m := v.Message().Interface()

	return appendMessage(b, m, wiretag, opts)

}

	m := v.Message().Interface()

	out, err := consumeMessage(b, m, wtyp, opts)

	return v, out, err

}

	m := v.Message().Interface()

	return proto.CheckInitialized(m)

}

var coderMessageValue = valueCoderFuncs{

	size:      sizeMessageValue,

	marshal:   appendMessageValue,

	unmarshal: consumeMessageValue,

	isInit:    isInitMessageValue,

	merge:     mergeMessageValue,

}

	m := v.Message().Interface()

	return sizeGroup(m, tagsize, opts)

}

	m := v.Message().Interface()

	return appendGroup(b, m, wiretag, opts)

}

	m := v.Message().Interface()

	out, err := consumeGroup(b, m, num, wtyp, opts)

	return v, out, err

}

var coderGroupValue = valueCoderFuncs{

	size:      sizeGroupValue,

	marshal:   appendGroupValue,

	unmarshal: consumeGroupValue,

	isInit:    isInitMessageValue,

	merge:     mergeMessageValue,

}

	num := fd.Number()

	if mi := getMessageInfo(ft); mi != nil {

		funcs := pointerCoderFuncs{

			size:      sizeGroupType,

			marshal:   appendGroupType,

			unmarshal: consumeGroupType,

			merge:     mergeMessage,

		}

		if needsInitCheck(mi.Desc) {

			funcs.isInit = isInitMessageInfo

		}

		return funcs

	} else {

		return pointerCoderFuncs{

			size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {

				m := asMessage(p.AsValueOf(ft).Elem())