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

import (

	"fmt"

	"math"

)

// Value is a union where only one Go type may be set at a time.

// The Value is used to represent all possible values a field may take.

// The following shows which Go type is used to represent each proto Kind:

//

//	╔════════════╤═════════════════════════════════════╗

//	║ Go type    │ Protobuf kind                       ║

//	╠════════════╪═════════════════════════════════════╣

//	║ bool       │ BoolKind                            ║

//	║ int32      │ Int32Kind, Sint32Kind, Sfixed32Kind ║

//	║ int64      │ Int64Kind, Sint64Kind, Sfixed64Kind ║

//	║ uint32     │ Uint32Kind, Fixed32Kind             ║

//	║ uint64     │ Uint64Kind, Fixed64Kind             ║

//	║ float32    │ FloatKind                           ║

//	║ float64    │ DoubleKind                          ║

//	║ string     │ StringKind                          ║

//	║ []byte     │ BytesKind                           ║

//	║ EnumNumber │ EnumKind                            ║

//	║ Message    │ MessageKind, GroupKind              ║

//	╚════════════╧═════════════════════════════════════╝

//

// Multiple protobuf Kinds may be represented by a single Go type if the type

// can losslessly represent the information for the proto kind. For example,

// Int64Kind, Sint64Kind, and Sfixed64Kind are all represented by int64,

// but use different integer encoding methods.

//

// The List or Map types are used if the field cardinality is repeated.

// A field is a List if FieldDescriptor.IsList reports true.

// A field is a Map if FieldDescriptor.IsMap reports true.

//

// Converting to/from a Value and a concrete Go value panics on type mismatch.

// For example, ValueOf("hello").Int() panics because this attempts to

// retrieve an int64 from a string.

type Value value

// The protoreflect API uses a custom Value union type instead of interface{}

// to keep the future open for performance optimizations. Using an interface{}

// always incurs an allocation for primitives (e.g., int64) since it needs to

// be boxed on the heap (as interfaces can only contain pointers natively).

// Instead, we represent the Value union as a flat struct that internally keeps

// track of which type is set. Using unsafe, the Value union can be reduced

// down to 24B, which is identical in size to a slice.

//

// The latest compiler (Go1.11) currently suffers from some limitations:

//	• With inlining, the compiler should be able to statically prove that

//	only one of these switch cases are taken and inline one specific case.

//	See https://golang.org/issue/22310.

// ValueOf returns a Value initialized with the concrete value stored in v.

// This panics if the type does not match one of the allowed types in the

// Value union.

func ValueOf(v interface{}) Value {

	switch v := v.(type) {

	case nil:

		return Value{}

	case bool:

		return ValueOfBool(v)

	case int32:

		return ValueOfInt32(v)

	case int64:

		return ValueOfInt64(v)

	case uint32:

		return ValueOfUint32(v)

	case uint64:

		return ValueOfUint64(v)

	case float32:

		return ValueOfFloat32(v)

	case float64:

		return ValueOfFloat64(v)

	case string:

		return ValueOfString(v)

	case []byte:

		return ValueOfBytes(v)

	case EnumNumber:

		return ValueOfEnum(v)

	case Message, List, Map:

		return valueOfIface(v)

	case ProtoMessage:

		panic(fmt.Sprintf("invalid proto.Message(%T) type, expected a protoreflect.Message type", v))

	default:

		panic(fmt.Sprintf("invalid type: %T", v))

	}

}

// ValueOfBool returns a new boolean value.

func ValueOfBool(v bool) Value {

	if v {

		return Value{typ: boolType, num: 1}

	} else {

		return Value{typ: boolType, num: 0}

	}

}

// ValueOfInt32 returns a new int32 value.

func ValueOfInt32(v int32) Value {

	return Value{typ: int32Type, num: uint64(v)}

}

// ValueOfInt64 returns a new int64 value.

func ValueOfInt64(v int64) Value {

	return Value{typ: int64Type, num: uint64(v)}

}

// ValueOfUint32 returns a new uint32 value.

func ValueOfUint32(v uint32) Value {

	return Value{typ: uint32Type, num: uint64(v)}

}

// ValueOfUint64 returns a new uint64 value.

func ValueOfUint64(v uint64) Value {

	return Value{typ: uint64Type, num: v}

}

// ValueOfFloat32 returns a new float32 value.

func ValueOfFloat32(v float32) Value {

	return Value{typ: float32Type, num: uint64(math.Float64bits(float64(v)))}

}

// ValueOfFloat64 returns a new float64 value.

func ValueOfFloat64(v float64) Value {

	return Value{typ: float64Type, num: uint64(math.Float64bits(float64(v)))}

}

// ValueOfString returns a new string value.

func ValueOfString(v string) Value {

	return valueOfString(v)

}

// ValueOfBytes returns a new bytes value.

func ValueOfBytes(v []byte) Value {

	return valueOfBytes(v[:len(v):len(v)])

}

// ValueOfEnum returns a new enum value.

func ValueOfEnum(v EnumNumber) Value {

	return Value{typ: enumType, num: uint64(v)}

}

// ValueOfMessage returns a new Message value.

func ValueOfMessage(v Message) Value {

	return valueOfIface(v)

}

// ValueOfList returns a new List value.

func ValueOfList(v List) Value {

	return valueOfIface(v)

}

// ValueOfMap returns a new Map value.

func ValueOfMap(v Map) Value {

	return valueOfIface(v)

}

// IsValid reports whether v is populated with a value.

func (v Value) IsValid() bool {

	return v.typ != nilType

}

// Interface returns v as an interface{}.

//

// Invariant: v == ValueOf(v).Interface()

func (v Value) Interface() interface{} {

	switch v.typ {

	case nilType:

		return nil

	case boolType:

		return v.Bool()

	case int32Type:

		return int32(v.Int())

	case int64Type:

		return int64(v.Int())

	case uint32Type:

		return uint32(v.Uint())

	case uint64Type:

		return uint64(v.Uint())

	case float32Type:

		return float32(v.Float())

	case float64Type:

		return float64(v.Float())

	case stringType:

		return v.String()

	case bytesType:

		return v.Bytes()

	case enumType:

		return v.Enum()

	default:

		return v.getIface()

	}

}

func (v Value) typeName() string {

	switch v.typ {

	case nilType:

		return "nil"

	case boolType:

		return "bool"

	case int32Type:

		return "int32"

	case int64Type:

		return "int64"

	case uint32Type:

		return "uint32"

	case uint64Type:

		return "uint64"

	case float32Type:

		return "float32"

	case float64Type:

		return "float64"

	case stringType:

		return "string"

	case bytesType:

		return "bytes"

	case enumType:

		return "enum"

	default:

		switch v := v.getIface().(type) {

		case Message:

			return "message"

		case List:

			return "list"

		case Map:

			return "map"

		default:

			return fmt.Sprintf("<unknown: %T>", v)

		}

	}

}

func (v Value) panicMessage(what string) string {

	return fmt.Sprintf("type mismatch: cannot convert %v to %s", v.typeName(), what)

}

// Bool returns v as a bool and panics if the type is not a bool.

func (v Value) Bool() bool {

	switch v.typ {

	case boolType:

		return v.num > 0

	default:

		panic(v.panicMessage("bool"))

	}

}

// Int returns v as a int64 and panics if the type is not a int32 or int64.

func (v Value) Int() int64 {

	switch v.typ {

	case int32Type, int64Type:

		return int64(v.num)

	default:

		panic(v.panicMessage("int"))

	}

}

// Uint returns v as a uint64 and panics if the type is not a uint32 or uint64.

func (v Value) Uint() uint64 {

	switch v.typ {

	case uint32Type, uint64Type:

		return uint64(v.num)

	default:

		panic(v.panicMessage("uint"))

	}

}

// Float returns v as a float64 and panics if the type is not a float32 or float64.

func (v Value) Float() float64 {

	switch v.typ {

	case float32Type, float64Type:

		return math.Float64frombits(uint64(v.num))

	default:

		panic(v.panicMessage("float"))

	}

}

// String returns v as a string. Since this method implements fmt.Stringer,

// this returns the formatted string value for any non-string type.

func (v Value) String() string {

	switch v.typ {

	case stringType:

		return v.getString()

	default:

		return fmt.Sprint(v.Interface())

	}

}

// Bytes returns v as a []byte and panics if the type is not a []byte.

func (v Value) Bytes() []byte {

	switch v.typ {

	case bytesType:

		return v.getBytes()

	default:

		panic(v.panicMessage("bytes"))

	}

}

// Enum returns v as a EnumNumber and panics if the type is not a EnumNumber.

func (v Value) Enum() EnumNumber {

	switch v.typ {

	case enumType:

		return EnumNumber(v.num)

	default:

		panic(v.panicMessage("enum"))

	}

}

// Message returns v as a Message and panics if the type is not a Message.

func (v Value) Message() Message {

	switch vi := v.getIface().(type) {

	case Message:

		return vi

	default:

		panic(v.panicMessage("message"))

	}

}

// List returns v as a List and panics if the type is not a List.

func (v Value) List() List {

	switch vi := v.getIface().(type) {

	case List:

		return vi

	default:

		panic(v.panicMessage("list"))

	}

}

// Map returns v as a Map and panics if the type is not a Map.

func (v Value) Map() Map {

	switch vi := v.getIface().(type) {

	case Map:

		return vi

	default:

		panic(v.panicMessage("map"))

	}

}

// MapKey returns v as a MapKey and panics for invalid MapKey types.

func (v Value) MapKey() MapKey {

	switch v.typ {

	case boolType, int32Type, int64Type, uint32Type, uint64Type, stringType:

		return MapKey(v)

	default:

		panic(v.panicMessage("map key"))

	}

}

// MapKey is used to index maps, where the Go type of the MapKey must match

// the specified key Kind (see MessageDescriptor.IsMapEntry).

// The following shows what Go type is used to represent each proto Kind:

//

//	╔═════════╤═════════════════════════════════════╗

//	║ Go type │ Protobuf kind                       ║

//	╠═════════╪═════════════════════════════════════╣

//	║ bool    │ BoolKind                            ║

//	║ int32   │ Int32Kind, Sint32Kind, Sfixed32Kind ║

//	║ int64   │ Int64Kind, Sint64Kind, Sfixed64Kind ║

//	║ uint32  │ Uint32Kind, Fixed32Kind             ║

//	║ uint64  │ Uint64Kind, Fixed64Kind             ║

//	║ string  │ StringKind                          ║

//	╚═════════╧═════════════════════════════════════╝

//

// A MapKey is constructed and accessed through a Value:

//	k := ValueOf("hash").MapKey() // convert string to MapKey

//	s := k.String()               // convert MapKey to string

//

// The MapKey is a strict subset of valid types used in Value;

// converting a Value to a MapKey with an invalid type panics.

type MapKey value

// IsValid reports whether k is populated with a value.

func (k MapKey) IsValid() bool {

	return Value(k).IsValid()

}

// Interface returns k as an interface{}.

func (k MapKey) Interface() interface{} {

	return Value(k).Interface()

}

// Bool returns k as a bool and panics if the type is not a bool.

func (k MapKey) Bool() bool {

	return Value(k).Bool()

}

// Int returns k as a int64 and panics if the type is not a int32 or int64.

func (k MapKey) Int() int64 {

	return Value(k).Int()

}

// Uint returns k as a uint64 and panics if the type is not a uint32 or uint64.

func (k MapKey) Uint() uint64 {

	return Value(k).Uint()

}

// String returns k as a string. Since this method implements fmt.Stringer,

// this returns the formatted string value for any non-string type.

func (k MapKey) String() string {

	return Value(k).String()

}

// Value returns k as a Value.

func (k MapKey) Value() Value {