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

import (

	"reflect"

	"sync"

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

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

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

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

	"google.golang.org/protobuf/proto"

)

func (fd *File) lazyRawInit() {

	fd.unmarshalFull(fd.builder.RawDescriptor)

	fd.resolveMessages()

	fd.resolveExtensions()

	fd.resolveServices()

}

func (file *File) resolveMessages() {

	var depIdx int32

	for i := range file.allMessages {

		md := &file.allMessages[i]

		// Resolve message field dependencies.

		for j := range md.L2.Fields.List {

			fd := &md.L2.Fields.List[j]

			// Weak fields are resolved upon actual use.

			if fd.L1.IsWeak {

				continue

			}

			// Resolve message field dependency.

			switch fd.L1.Kind {

				fd.L1.Enum = file.resolveEnumDependency(fd.L1.Enum, listFieldDeps, depIdx)

				depIdx++

				fd.L1.Message = file.resolveMessageDependency(fd.L1.Message, listFieldDeps, depIdx)

				depIdx++

			}

			// Default is resolved here since it depends on Enum being resolved.

			if v := fd.L1.Default.val; v.IsValid() {

				fd.L1.Default = unmarshalDefault(v.Bytes(), fd.L1.Kind, file, fd.L1.Enum)

			}

		}

	}

}

func (file *File) resolveExtensions() {

	var depIdx int32

	for i := range file.allExtensions {

		xd := &file.allExtensions[i]

		// Resolve extension field dependency.

		switch xd.L1.Kind {

			xd.L2.Enum = file.resolveEnumDependency(xd.L2.Enum, listExtDeps, depIdx)

			depIdx++

			xd.L2.Message = file.resolveMessageDependency(xd.L2.Message, listExtDeps, depIdx)

			depIdx++

		}

		// Default is resolved here since it depends on Enum being resolved.

		if v := xd.L2.Default.val; v.IsValid() {

			xd.L2.Default = unmarshalDefault(v.Bytes(), xd.L1.Kind, file, xd.L2.Enum)

		}

	}

}

func (file *File) resolveServices() {

	var depIdx int32

	for i := range file.allServices {

		sd := &file.allServices[i]

		// Resolve method dependencies.

		for j := range sd.L2.Methods.List {

			md := &sd.L2.Methods.List[j]

			md.L1.Input = file.resolveMessageDependency(md.L1.Input, listMethInDeps, depIdx)

			md.L1.Output = file.resolveMessageDependency(md.L1.Output, listMethOutDeps, depIdx)

			depIdx++

		}

	}

}

	r := file.builder.FileRegistry

	if r, ok := r.(resolverByIndex); ok {

		if ed2 := r.FindEnumByIndex(i, j, file.allEnums, file.allMessages); ed2 != nil {

			return ed2

		}

	}

	for i := range file.allEnums {

		if ed2 := &file.allEnums[i]; ed2.L0.FullName == ed.FullName() {

			return ed2

		}

	}

	if d, _ := r.FindDescriptorByName(ed.FullName()); d != nil {

	}

	return ed

}

	r := file.builder.FileRegistry

	if r, ok := r.(resolverByIndex); ok {

		if md2 := r.FindMessageByIndex(i, j, file.allEnums, file.allMessages); md2 != nil {

			return md2

		}

	}

	for i := range file.allMessages {

		if md2 := &file.allMessages[i]; md2.L0.FullName == md.FullName() {

			return md2

		}

	}

	if d, _ := r.FindDescriptorByName(md.FullName()); d != nil {

	}

	return md

}

func (fd *File) unmarshalFull(b []byte) {

	sb := getBuilder()

	defer putBuilder(sb)

	var enumIdx, messageIdx, extensionIdx, serviceIdx int

	var rawOptions []byte

	fd.L2 = new(FileL2)

	for len(b) > 0 {

		num, typ, n := protowire.ConsumeTag(b)

		b = b[n:]

		switch typ {

		case protowire.VarintType:

			v, m := protowire.ConsumeVarint(b)

			b = b[m:]

			switch num {

			case genid.FileDescriptorProto_PublicDependency_field_number:

				fd.L2.Imports[v].IsPublic = true

			case genid.FileDescriptorProto_WeakDependency_field_number:

				fd.L2.Imports[v].IsWeak = true

			}

		case protowire.BytesType:

			v, m := protowire.ConsumeBytes(b)

			b = b[m:]

			switch num {

			case genid.FileDescriptorProto_Dependency_field_number:

				path := sb.MakeString(v)

				imp, _ := fd.builder.FileRegistry.FindFileByPath(path)

				if imp == nil {

					imp = PlaceholderFile(path)

				}

			case genid.FileDescriptorProto_EnumType_field_number:

				fd.L1.Enums.List[enumIdx].unmarshalFull(v, sb)

				enumIdx++

			case genid.FileDescriptorProto_MessageType_field_number:

				fd.L1.Messages.List[messageIdx].unmarshalFull(v, sb)

				messageIdx++

			case genid.FileDescriptorProto_Extension_field_number:

				fd.L1.Extensions.List[extensionIdx].unmarshalFull(v, sb)

				extensionIdx++

			case genid.FileDescriptorProto_Service_field_number:

				fd.L1.Services.List[serviceIdx].unmarshalFull(v, sb)

				serviceIdx++

			case genid.FileDescriptorProto_Options_field_number:

				rawOptions = appendOptions(rawOptions, v)

			}

		default:

			m := protowire.ConsumeFieldValue(num, typ, b)

			b = b[m:]

		}

	}

	fd.L2.Options = fd.builder.optionsUnmarshaler(&descopts.File, rawOptions)

}

func (ed *Enum) unmarshalFull(b []byte, sb *strs.Builder) {

	var rawValues [][]byte

	var rawOptions []byte

	if !ed.L1.eagerValues {

		ed.L2 = new(EnumL2)

	}

	for len(b) > 0 {

		num, typ, n := protowire.ConsumeTag(b)

		b = b[n:]

		switch typ {

		case protowire.BytesType:

			v, m := protowire.ConsumeBytes(b)

			b = b[m:]

			switch num {

			case genid.EnumDescriptorProto_Value_field_number:

				rawValues = append(rawValues, v)

			case genid.EnumDescriptorProto_ReservedName_field_number:

			case genid.EnumDescriptorProto_ReservedRange_field_number:

				ed.L2.ReservedRanges.List = append(ed.L2.ReservedRanges.List, unmarshalEnumReservedRange(v))

			case genid.EnumDescriptorProto_Options_field_number:

				rawOptions = appendOptions(rawOptions, v)

			}

		default:

			m := protowire.ConsumeFieldValue(num, typ, b)

			b = b[m:]

		}

	}

	if !ed.L1.eagerValues && len(rawValues) > 0 {

		ed.L2.Values.List = make([]EnumValue, len(rawValues))

		for i, b := range rawValues {

			ed.L2.Values.List[i].unmarshalFull(b, sb, ed.L0.ParentFile, ed, i)

		}

	}

	ed.L2.Options = ed.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Enum, rawOptions)

}

	for len(b) > 0 {

		num, typ, n := protowire.ConsumeTag(b)

		b = b[n:]

		switch typ {

		case protowire.VarintType:

			v, m := protowire.ConsumeVarint(b)

			b = b[m:]

			switch num {

			case genid.EnumDescriptorProto_EnumReservedRange_Start_field_number:

			case genid.EnumDescriptorProto_EnumReservedRange_End_field_number:

			}

		default:

			m := protowire.ConsumeFieldValue(num, typ, b)

			b = b[m:]

		}

	}

	return r

}

	vd.L0.ParentFile = pf

	vd.L0.Parent = pd

	vd.L0.Index = i

	var rawOptions []byte

	for len(b) > 0 {

		num, typ, n := protowire.ConsumeTag(b)

		b = b[n:]

		switch typ {

		case protowire.VarintType:

			v, m := protowire.ConsumeVarint(b)

			b = b[m:]

			switch num {

			case genid.EnumValueDescriptorProto_Number_field_number:

			}

		case protowire.BytesType:

			v, m := protowire.ConsumeBytes(b)

			b = b[m:]

			switch num {

			case genid.EnumValueDescriptorProto_Name_field_number:

				// NOTE: Enum values are in the same scope as the enum parent.

				vd.L0.FullName = appendFullName(sb, pd.Parent().FullName(), v)

			case genid.EnumValueDescriptorProto_Options_field_number:

				rawOptions = appendOptions(rawOptions, v)

			}

		default:

			m := protowire.ConsumeFieldValue(num, typ, b)

			b = b[m:]

		}

	}

	vd.L1.Options = pf.builder.optionsUnmarshaler(&descopts.EnumValue, rawOptions)

}

func (md *Message) unmarshalFull(b []byte, sb *strs.Builder) {

	var rawFields, rawOneofs [][]byte

	var enumIdx, messageIdx, extensionIdx int

	var rawOptions []byte

	md.L2 = new(MessageL2)

	for len(b) > 0 {

		num, typ, n := protowire.ConsumeTag(b)

		b = b[n:]

		switch typ {

		case protowire.BytesType:

			v, m := protowire.ConsumeBytes(b)

			b = b[m:]

			switch num {

			case genid.DescriptorProto_Field_field_number:

				rawFields = append(rawFields, v)

			case genid.DescriptorProto_OneofDecl_field_number:

				rawOneofs = append(rawOneofs, v)

			case genid.DescriptorProto_ReservedName_field_number:

			case genid.DescriptorProto_ReservedRange_field_number:

				md.L2.ReservedRanges.List = append(md.L2.ReservedRanges.List, unmarshalMessageReservedRange(v))

			case genid.DescriptorProto_ExtensionRange_field_number:

				r, rawOptions := unmarshalMessageExtensionRange(v)

				opts := md.L0.ParentFile.builder.optionsUnmarshaler(&descopts.ExtensionRange, rawOptions)

				md.L2.ExtensionRanges.List = append(md.L2.ExtensionRanges.List, r)

				md.L2.ExtensionRangeOptions = append(md.L2.ExtensionRangeOptions, opts)

			case genid.DescriptorProto_EnumType_field_number:

				md.L1.Enums.List[enumIdx].unmarshalFull(v, sb)

				enumIdx++

			case genid.DescriptorProto_NestedType_field_number:

				md.L1.Messages.List[messageIdx].unmarshalFull(v, sb)

				messageIdx++

			case genid.DescriptorProto_Extension_field_number:

				md.L1.Extensions.List[extensionIdx].unmarshalFull(v, sb)

				extensionIdx++

			case genid.DescriptorProto_Options_field_number:

				md.unmarshalOptions(v)

				rawOptions = appendOptions(rawOptions, v)

			}

		default:

			m := protowire.ConsumeFieldValue(num, typ, b)

			b = b[m:]

		}

	}

	if len(rawFields) > 0 || len(rawOneofs) > 0 {

		md.L2.Fields.List = make([]Field, len(rawFields))

		md.L2.Oneofs.List = make([]Oneof, len(rawOneofs))

		for i, b := range rawFields {

			fd := &md.L2.Fields.List[i]

			fd.unmarshalFull(b, sb, md.L0.ParentFile, md, i)

				md.L2.RequiredNumbers.List = append(md.L2.RequiredNumbers.List, fd.L1.Number)

			}

		}

		for i, b := range rawOneofs {

			od := &md.L2.Oneofs.List[i]

			od.unmarshalFull(b, sb, md.L0.ParentFile, md, i)

		}

	}

	md.L2.Options = md.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Message, rawOptions)

}

func (md *Message) unmarshalOptions(b []byte) {

	for len(b) > 0 {

		num, typ, n := protowire.ConsumeTag(b)

		b = b[n:]

		switch typ {

		case protowire.VarintType:

			v, m := protowire.ConsumeVarint(b)

			b = b[m:]

			switch num {

			case genid.MessageOptions_MapEntry_field_number:

				md.L1.IsMapEntry = protowire.DecodeBool(v)

			case genid.MessageOptions_MessageSetWireFormat_field_number:

				md.L1.IsMessageSet = protowire.DecodeBool(v)

			}

		default:

			m := protowire.ConsumeFieldValue(num, typ, b)

			b = b[m:]

		}

	}

}

	for len(b) > 0 {