package cmd

import (
	"fmt"
	"time"

	"github.com/tinylib/msgp/msgp"
)

// unmarshalV unmarshals with a specific header version.
func (x *xlMetaV2VersionHeader) unmarshalV(v uint8, bts []byte) (o []byte, err error) {
	switch v {
	case 1:
		return x.unmarshalV1(bts)
	case 2:
		x2 := xlMetaV2VersionHeaderV2{xlMetaV2VersionHeader: x}
		return x2.UnmarshalMsg(bts)
	case xlHeaderVersion:

		}

		// Classify the callee (without allocating memory).
		argidx := -1

		recv := fn.Type().(*types.Signature).Recv()
		if fn.Name() == "Unmarshal" && recv == nil {
			// "encoding/json".Unmarshal
			// "encoding/xml".Unmarshal
			// "encoding/asn1".Unmarshal
			switch fn.Pkg().Path() {
			case "encoding/json", "encoding/xml", "encoding/asn1":
				argidx = 1 // func([]byte, interface{})
			}

// license that can be found in the LICENSE file.

// This file contains tests for the unmarshal checker.

package unmarshal

import "encoding/json"

func _() {
	type t struct {
		a int
	}
	var v t

	json.Unmarshal([]byte{}, v) // ERROR "call of Unmarshal passes non-pointer as second argument"

	"istio.io/istio/pkg/log"
)

var (
	unmarshaler       = jsonpb.Unmarshaler{AllowUnknownFields: true}
	strictUnmarshaler = jsonpb.Unmarshaler{}
)

func Unmarshal(b []byte, m proto.Message) error {
	return strictUnmarshaler.Unmarshal(bytes.NewReader(b), legacyproto.MessageV1(m))
}

func UnmarshalString(s string, m proto.Message) error {
	return Unmarshal([]byte(s), m)
}

//     unmarshal maps the sub-element to that struct field.
//
//   - An anonymous struct field is handled as if the fields of its
//     value were part of the outer struct.
//
//   - A struct field with tag "-" is never unmarshaled into.
//
// If Unmarshal encounters a field type that implements the Unmarshaler
// interface, Unmarshal calls its UnmarshalXML method to produce the value from

		reader.Reset(js)
		return m.Unmarshal(reader, pb)
	}
	return nil
}

// ApplyJSONStrict unmarshals a JSON string into a proto message.
func ApplyJSONStrict(js string, pb proto.Message) error {
	reader := strings.NewReader(js)
	m := jsonpb.Unmarshaler{}
	return m.Unmarshal(reader, pb)

// the JSON being the JSON literal null. In that case, Unmarshal sets
// the pointer to nil. Otherwise, Unmarshal unmarshals the JSON into
// the value pointed at by the pointer. If the pointer is nil, Unmarshal
// allocates a new value for it to point to.
//
// To unmarshal JSON into a value implementing [Unmarshaler],
// Unmarshal calls that value's [Unmarshaler.UnmarshalJSON] method, including
// when the input is a JSON null.

}

type tx struct {
	x int
}

type u8 uint8

// A type that can unmarshal itself.

type unmarshaler struct {
	T bool
}

func (u *unmarshaler) UnmarshalJSON(b []byte) error {
	*u = unmarshaler{true} // All we need to see that UnmarshalJSON is called.
	return nil
}

type ustruct struct {
	M unmarshaler
}

type unmarshalerText struct {
	A, B string
}

func TestHasFieldsType(t *testing.T) {
	var unmarshaled []metav1.ManagedFieldsEntry
	if err := yaml.Unmarshal([]byte(`- apiVersion: v1
  fieldsType: FieldsV1
  fieldsV1:
    f:field: {}
  manager: foo
  operation: Apply
`), &unmarshaled); err != nil {
		t.Fatalf("did not expect yaml unmarshalling error but got: %v", err)
	}
	if _, err := DecodeManagedFields(unmarshaled); err != nil {

		if err != nil {
			t.Errorf("1st marshal error: %v", err)
		}
		if err = json.Unmarshal(data, &new1); err != nil {
			t.Errorf("1st unmarshal error: %v", err)
		}
		newData, err := json.Marshal(new1)
		if err != nil {
			t.Errorf("2st marshal error: %v", err)
		}
		if err = json.Unmarshal(newData, &new2); err != nil {
			t.Errorf("2nd unmarshal error: %v", err)
		}
		if !bytes.Equal(data, newData) {