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

import (

	"bytes"

	"math"

	"reflect"

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

)

// Equal reports whether two messages are equal.

// If two messages marshal to the same bytes under deterministic serialization,

// then Equal is guaranteed to report true.

//

// Two messages are equal if they belong to the same message descriptor,

// have the same set of populated known and extension field values,

// and the same set of unknown fields values. If either of the top-level

// messages are invalid, then Equal reports true only if both are invalid.

//

// Scalar values are compared with the equivalent of the == operator in Go,

// except bytes values which are compared using bytes.Equal and

// floating point values which specially treat NaNs as equal.

// Message values are compared by recursively calling Equal.

// Lists are equal if each element value is also equal.

// Maps are equal if they have the same set of keys, where the pair of values

// for each key is also equal.

func Equal(x, y Message) bool {

	if x == nil || y == nil {

		return x == nil && y == nil

	}

	mx := x.ProtoReflect()

	my := y.ProtoReflect()

	if mx.IsValid() != my.IsValid() {

		return false

	}

	return equalMessage(mx, my)

}

// equalMessage compares two messages.

	if mx.Descriptor() != my.Descriptor() {

		return false

	}

	nx := 0

	equal := true

		nx++

		vy := my.Get(fd)

		equal = my.Has(fd) && equalField(fd, vx, vy)

		return equal

	})

	if !equal {

		return false

	}

	ny := 0

		ny++

		return true

	})

	if nx != ny {

		return false

	}

	return equalUnknown(mx.GetUnknown(), my.GetUnknown())

}

// equalField compares two fields.

	switch {

	case fd.IsList():

		return equalList(fd, x.List(), y.List())

	case fd.IsMap():

		return equalMap(fd, x.Map(), y.Map())

	default:

		return equalValue(fd, x, y)

	}

}

// equalMap compares two maps.

	if x.Len() != y.Len() {

		return false

	}

	equal := true

		vy := y.Get(k)

		equal = y.Has(k) && equalValue(fd.MapValue(), vx, vy)

		return equal

	})

	return equal

}

// equalList compares two lists.

	if x.Len() != y.Len() {

		return false

	}

	for i := x.Len() - 1; i >= 0; i-- {

		if !equalValue(fd, x.Get(i), y.Get(i)) {

			return false

		}

	}

	return true

}

// equalValue compares two singular values.

	switch fd.Kind() {

		return x.Bool() == y.Bool()

		return x.Enum() == y.Enum()

		return x.Int() == y.Int()

		return x.Uint() == y.Uint()

		fx := x.Float()

		fy := y.Float()

		if math.IsNaN(fx) || math.IsNaN(fy) {

			return math.IsNaN(fx) && math.IsNaN(fy)

		}

		return fx == fy

		return x.String() == y.String()

		return bytes.Equal(x.Bytes(), y.Bytes())

		return equalMessage(x.Message(), y.Message())

	default:

		return x.Interface() == y.Interface()

	}

}

// equalUnknown compares unknown fields by direct comparison on the raw bytes

// of each individual field number.

	if len(x) != len(y) {

		return false

	}

	if bytes.Equal([]byte(x), []byte(y)) {

		return true

	}

	for len(x) > 0 {

		fnum, _, n := protowire.ConsumeField(x)

		mx[fnum] = append(mx[fnum], x[:n]...)

		x = x[n:]

	}

	for len(y) > 0 {

		fnum, _, n := protowire.ConsumeField(y)

		my[fnum] = append(my[fnum], y[:n]...)

		y = y[n:]

	}

	return reflect.DeepEqual(mx, my)

}