// Copyright 2017, 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.md file.

package teststructs

type InterfaceA interface {
	InterfaceA()
}

type (
	StructA struct{ X string } // Equal method on value receiver
	StructB struct{ X string } // Equal method on pointer receiver
	StructC struct{ X string } // Equal method (with interface argument) on value receiver
	StructD struct{ X string } // Equal method (with interface argument) on pointer receiver
	StructE struct{ X string } // Equal method (with interface argument on value receiver) on pointer receiver
	StructF struct{ X string } // Equal method (with interface argument on pointer receiver) on value receiver

	// These embed the above types as a value.
	StructA1 struct {
		StructA
		X string
	}
	StructB1 struct {
		StructB
		X string
	}
	StructC1 struct {
		StructC
		X string
	}
	StructD1 struct {
		StructD
		X string
	}
	StructE1 struct {
		StructE
		X string
	}
	StructF1 struct {
		StructF
		X string
	}

	// These embed the above types as a pointer.
	StructA2 struct {
		*StructA
		X string
	}
	StructB2 struct {
		*StructB
		X string
	}
	StructC2 struct {
		*StructC
		X string
	}
	StructD2 struct {
		*StructD
		X string
	}
	StructE2 struct {
		*StructE
		X string
	}
	StructF2 struct {
		*StructF
		X string
	}

	StructNo struct{ X string } // Equal method (with interface argument) on non-satisfying receiver

	AssignA func() int
	AssignB struct{ A int }
	AssignC chan bool
	AssignD <-chan bool
)

func (x StructA) Equal(y StructA) bool     { return true }
func (x *StructB) Equal(y *StructB) bool   { return true }
func (x StructC) Equal(y InterfaceA) bool  { return true }
func (x StructC) InterfaceA()              {}
func (x *StructD) Equal(y InterfaceA) bool { return true }
func (x *StructD) InterfaceA()             {}
func (x *StructE) Equal(y InterfaceA) bool { return true }
func (x StructE) InterfaceA()              {}
func (x StructF) Equal(y InterfaceA) bool  { return true }
func (x *StructF) InterfaceA()             {}
func (x StructNo) Equal(y InterfaceA) bool { return true }

func (x AssignA) Equal(y func() int) bool      { return true }
func (x AssignB) Equal(y struct{ A int }) bool { return true }
func (x AssignC) Equal(y chan bool) bool       { return true }
func (x AssignD) Equal(y <-chan bool) bool     { return true }

var _ = func(
	a StructA, b StructB, c StructC, d StructD, e StructE, f StructF,
	ap *StructA, bp *StructB, cp *StructC, dp *StructD, ep *StructE, fp *StructF,
	a1 StructA1, b1 StructB1, c1 StructC1, d1 StructD1, e1 StructE1, f1 StructF1,
	a2 StructA2, b2 StructB2, c2 StructC2, d2 StructD2, e2 StructE2, f2 StructF1,
) {
	a.Equal(a)
	b.Equal(&b)
	c.Equal(c)
	d.Equal(&d)
	e.Equal(e)
	f.Equal(&f)

	ap.Equal(*ap)
	bp.Equal(bp)
	cp.Equal(*cp)
	dp.Equal(dp)
	ep.Equal(*ep)
	fp.Equal(fp)

	a1.Equal(a1.StructA)
	b1.Equal(&b1.StructB)
	c1.Equal(c1)
	d1.Equal(&d1)
	e1.Equal(e1)
	f1.Equal(&f1)

	a2.Equal(*a2.StructA)
	b2.Equal(b2.StructB)
	c2.Equal(c2)
	d2.Equal(&d2)
	e2.Equal(e2)
	f2.Equal(&f2)
}

type (
	privateStruct struct{ Public, private int }
	PublicStruct  struct{ Public, private int }
	ParentStructA struct{ privateStruct }
	ParentStructB struct{ PublicStruct }
	ParentStructC struct {
		privateStruct
		Public, private int
	}
	ParentStructD struct {
		PublicStruct
		Public, private int
	}
	ParentStructE struct {
		privateStruct
		PublicStruct
	}
	ParentStructF struct {
		privateStruct
		PublicStruct
		Public, private int
	}
	ParentStructG struct {
		*privateStruct
	}
	ParentStructH struct {
		*PublicStruct
	}
	ParentStructI struct {
		*privateStruct
		*PublicStruct
	}
	ParentStructJ struct {
		*privateStruct
		*PublicStruct
		Public  PublicStruct
		private privateStruct
	}
)

func NewParentStructG() *ParentStructG {
	return &ParentStructG{new(privateStruct)}
}
func NewParentStructH() *ParentStructH {
	return &ParentStructH{new(PublicStruct)}
}
func NewParentStructI() *ParentStructI {
	return &ParentStructI{new(privateStruct), new(PublicStruct)}
}
func NewParentStructJ() *ParentStructJ {
	return &ParentStructJ{
		privateStruct: new(privateStruct), PublicStruct: new(PublicStruct),
	}
}
func (s *privateStruct) SetPrivate(i int)              { s.private = i }
func (s *PublicStruct) SetPrivate(i int)               { s.private = i }
func (s *ParentStructC) SetPrivate(i int)              { s.private = i }
func (s *ParentStructD) SetPrivate(i int)              { s.private = i }
func (s *ParentStructF) SetPrivate(i int)              { s.private = i }
func (s *ParentStructA) PrivateStruct() *privateStruct { return &s.privateStruct }
func (s *ParentStructC) PrivateStruct() *privateStruct { return &s.privateStruct }
func (s *ParentStructE) PrivateStruct() *privateStruct { return &s.privateStruct }
func (s *ParentStructF) PrivateStruct() *privateStruct { return &s.privateStruct }
func (s *ParentStructG) PrivateStruct() *privateStruct { return s.privateStruct }
func (s *ParentStructI) PrivateStruct() *privateStruct { return s.privateStruct }
func (s *ParentStructJ) PrivateStruct() *privateStruct { return s.privateStruct }
func (s *ParentStructJ) Private() *privateStruct       { return &s.private }