"k8s.io/apiserver/pkg/storage/names"
	"k8s.io/client-go/discovery"
	fakediscovery "k8s.io/client-go/discovery/fake"
	"k8s.io/client-go/dynamic"
	dynamicfake "k8s.io/client-go/dynamic/fake"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/kubernetes/fake"
	kubescheme "k8s.io/client-go/kubernetes/scheme"
	"k8s.io/client-go/metadata"
	metadatafake "k8s.io/client-go/metadata/fake"
	"k8s.io/client-go/rest"
	clienttesting "k8s.io/client-go/testing"

	"sync"
	"sync/atomic"
	"time"
)

// A Client is an HTTP client. Its zero value ([DefaultClient]) is a
// usable client that uses [DefaultTransport].
//
// The [Client.Transport] typically has internal state (cached TCP
// connections), so Clients should be reused instead of created as
// needed. Clients are safe for concurrent use by multiple goroutines.
//
// A Client is higher-level than a [RoundTripper] (such as [Transport])

var ErrSecurity = errors.New("security error: misbehaving server")

// A Client is a client connection to a checksum database.
// All the methods are safe for simultaneous use by multiple goroutines.
type Client struct {
	ops ClientOps // access to operations in the external world

	didLookup uint32

	// one-time initialized data
	initOnce   sync.Once

}

var _ model.ConfigStoreController = &Client{}

func New(client kube.Client, opts Option) *Client {
	schemas := collections.Pilot
	if features.EnableGatewayAPI {
		schemas = collections.PilotGatewayAPI()
	}
	return NewForSchemas(client, opts, schemas)
}

func NewForSchemas(client kube.Client, opts Option, schemas collection.Schemas) *Client {
	schemasByCRDName := map[string]resource.Schema{}

func (n *NetworkError) Unwrap() error {
	return n.Err
}

// Client - http based RPC client.
type Client struct {
	connected int32 // ref: https://golang.org/pkg/sync/atomic/#pkg-note-BUG
	_         int32 // For 64 bits alignment
	lastConn  int64

	// HealthCheckFn is the function set to test for health.
	// If not set the client will not keep track of health.
	// Calling this returns true or false if the target

type Filter = kubetypes.Filter

// New returns a Client for the given type.
// Internally, this uses a shared informer, so calling this multiple times will share the same internals.
func New[T controllers.ComparableObject](c kube.Client) Client[T] {
	return NewFiltered[T](c, Filter{})
}

// NewFiltered returns a Client with some filter applied.

00000050  7d 5c 1c 42 c7                                    |}\.B.|
>>> Flow 4 (server to client)
00000000  14 03 03 00 01 01 16 03  03 00 20 e7 86 48 6c 00  |.......... ..Hl.|
00000010  0a 1e f5 5f b8 ff ad 1c  9d 74 24 c5 6e d4 c6 6e  |..._.....t$.n..n|
00000020  25 27 7d 6e 18 44 96 29  eb db b0                 |%'}n.D.)...|
>>> Flow 5 (client to server)
00000000  17 03 03 00 16 64 9d 31  09 a1 ce 5a 6d ec 6f c4  |.....d.1...Zm.o.|

00000050  c5 af fd e5 59                                    |....Y|
>>> Flow 4 (server to client)
00000000  14 03 03 00 01 01 16 03  03 00 20 94 da e2 2e f3  |.......... .....|
00000010  65 59 31 4f 58 42 57 b5  1f e6 c1 5a c6 07 97 12  |eY1OXBW....Z....|
00000020  f6 6c 20 cc 91 50 76 42  70 dd 2c                 |.l ..PvBp.,|
>>> Flow 5 (client to server)
00000000  17 03 03 00 16 fe 0d 78  61 f9 fe 65 3c 42 c0 98  |.......xa..e<B..|

00000050  8b 4e 95 85 fc                                    |.N...|
>>> Flow 4 (server to client)
00000000  14 03 03 00 01 01 16 03  03 00 20 03 84 99 6b f7  |.......... ...k.|
00000010  3e 44 b1 96 6a 09 75 bf  26 4b 67 30 c4 e9 86 74  |>D..j.u.&Kg0...t|
00000020  4d e1 e3 9b fa 15 8e 1e  72 f9 5a                 |M.......r.Z|
>>> Flow 5 (client to server)
00000000  17 03 03 00 16 68 29 2f  1b 1c 9d 28 6e b6 e5 09  |.....h)/...(n...|

	return toStorageErr(err)
}

func (client remotePeerS3Client) GetHost() string {
	return client.node.Host
}

func (client remotePeerS3Client) GetPools() []int {
	return client.pools
}

func (client *remotePeerS3Client) SetPools(p []int) {
	client.pools = make([]int, len(p))
	copy(client.pools, p)
}

// newPeerS3Clients creates new peer clients.