// 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 tag marshals and unmarshals the legacy struct tags as generated

// by historical versions of protoc-gen-go.

package tag

import (

	"reflect"

	"strconv"

	"strings"

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

)

var byteType = reflect.TypeOf(byte(0))

// Unmarshal decodes the tag into a prototype.Field.

//

// The goType is needed to determine the original protoreflect.Kind since the

// tag does not record sufficient information to determine that.

// The type is the underlying field type (e.g., a repeated field may be

// represented by []T, but the Go type passed in is just T).

// A list of enum value descriptors must be provided for enum fields.

// This does not populate the Enum or Message (except for weak message).

//

// This function is a best effort attempt; parsing errors are ignored.

	for len(tag) > 0 {

		i := strings.IndexByte(tag, ',')

		if i < 0 {

			i = len(tag)

		}

		switch s := tag[:i]; {

		case strings.HasPrefix(s, "name="):

		case strings.Trim(s, "0123456789") == "":

			n, _ := strconv.ParseUint(s, 10, 32)

		case s == "opt":

		case s == "req":

		case s == "rep":

		case s == "varint":

			switch goType.Kind() {

			case reflect.Bool:

			case reflect.Int32:

			case reflect.Int64:

			case reflect.Uint32:

			case reflect.Uint64:

			}

		case s == "zigzag32":

			if goType.Kind() == reflect.Int32 {

			}

		case s == "zigzag64":

			if goType.Kind() == reflect.Int64 {

			}

		case s == "fixed32":

			switch goType.Kind() {

			case reflect.Int32:

			case reflect.Uint32:

			case reflect.Float32:

			}

		case s == "fixed64":

			switch goType.Kind() {

			case reflect.Int64:

			case reflect.Uint64:

			case reflect.Float64:

			}

		case s == "bytes":

			switch {

			case goType.Kind() == reflect.String:

			case goType.Kind() == reflect.Slice && goType.Elem() == byteType:

			default:

			}

		case s == "group":

		case strings.HasPrefix(s, "enum="):

		case strings.HasPrefix(s, "json="):

			jsonName := s[len("json="):]

			if jsonName != strs.JSONCamelCase(string(f.L0.FullName.Name())) {

				f.L1.StringName.InitJSON(jsonName)

			}

		case s == "packed":

			f.L1.HasPacked = true

			f.L1.IsPacked = true

		case strings.HasPrefix(s, "weak="):

			f.L1.IsWeak = true

		case strings.HasPrefix(s, "def="):

			// The default tag is special in that everything afterwards is the

			// default regardless of the presence of commas.

			s, i = tag[len("def="):], len(tag)

			v, ev, _ := defval.Unmarshal(s, f.L1.Kind, evs, defval.GoTag)

		case s == "proto3":

		}

		tag = strings.TrimPrefix(tag[i:], ",")

	}

	// The generator uses the group message name instead of the field name.

	// We obtain the real field name by lowercasing the group name.

	}

	return f

}

// Marshal encodes the protoreflect.FieldDescriptor as a tag.

//

// The enumName must be provided if the kind is an enum.

// Historically, the formulation of the enum "name" was the proto package

// dot-concatenated with the generated Go identifier for the enum type.

// Depending on the context on how Marshal is called, there are different ways

// through which that information is determined. As such it is the caller's

// responsibility to provide a function to obtain that information.

	var tag []string

	switch fd.Kind() {

		tag = append(tag, "varint")

		tag = append(tag, "zigzag32")

		tag = append(tag, "zigzag64")

		tag = append(tag, "fixed32")

		tag = append(tag, "fixed64")

		tag = append(tag, "bytes")

		tag = append(tag, "group")

	}

	tag = append(tag, strconv.Itoa(int(fd.Number())))

	switch fd.Cardinality() {

		tag = append(tag, "opt")

		tag = append(tag, "req")

		tag = append(tag, "rep")

	}

	if fd.IsPacked() {

		tag = append(tag, "packed")

	}

	name := string(fd.Name())

		// The name of the FieldDescriptor for a group field is

		// lowercased. To find the original capitalization, we

		// look in the field's MessageType.

		name = string(fd.Message().Name())

	}

	tag = append(tag, "name="+name)

	if jsonName := fd.JSONName(); jsonName != "" && jsonName != name && !fd.IsExtension() {

		// NOTE: The jsonName != name condition is suspect, but it preserve

		// the exact same semantics from the previous generator.

		tag = append(tag, "json="+jsonName)

	}

	if fd.IsWeak() {

		tag = append(tag, "weak="+string(fd.Message().FullName()))

	}

	// The previous implementation does not tag extension fields as proto3,

	// even when the field is defined in a proto3 file. Match that behavior

	// for consistency.

		tag = append(tag, "proto3")

	}

		tag = append(tag, "enum="+enumName)

	}

	if fd.ContainingOneof() != nil {

		tag = append(tag, "oneof")

	}

	// This must appear last in the tag, since commas in strings aren't escaped.

	if fd.HasDefault() {

		def, _ := defval.Marshal(fd.Default(), fd.DefaultEnumValue(), fd.Kind(), defval.GoTag)

		tag = append(tag, "def="+def)

	}

	return strings.Join(tag, ",")

}