package bootstrap

import (
	"isle/garage"
)

// GarageClientParams contains all the data needed to instantiate garage
// clients.
type GarageClientParams struct {
	Peer                         garage.RemotePeer
	GlobalBucketS3APICredentials garage.S3APICredentials
	RPCSecret                    string
}

// GlobalBucketS3APIClient returns an S3 client pre-configured with access to
// the global bucket.
func (p GarageClientParams) GlobalBucketS3APIClient() garage.S3APIClient {
	var (
		addr  = p.Peer.S3APIAddr()
		creds = p.GlobalBucketS3APICredentials
	)
	return garage.NewS3APIClient(addr, creds)
}

// GaragePeers returns a Peer for each known garage instance in the network.
func (b Bootstrap) GaragePeers() []garage.RemotePeer {

	var peers []garage.RemotePeer

	for _, host := range b.Hosts {

		for _, instance := range host.Garage.Instances {

			peer := garage.RemotePeer{
				ID:        instance.ID,
				IP:        host.IP().String(),
				RPCPort:   instance.RPCPort,
				S3APIPort: instance.S3APIPort,
			}

			peers = append(peers, peer)
		}
	}

	return peers
}

// ChooseGaragePeer returns a Peer for a garage instance from the network. It
// will prefer a garage instance on this particular host, if there is one, but
// will otherwise return a random endpoint.
func (b Bootstrap) ChooseGaragePeer() garage.RemotePeer {

	thisHost := b.ThisHost()

	if len(thisHost.Garage.Instances) > 0 {

		inst := thisHost.Garage.Instances[0]
		return garage.RemotePeer{
			ID:        inst.ID,
			IP:        thisHost.IP().String(),
			RPCPort:   inst.RPCPort,
			S3APIPort: inst.S3APIPort,
		}
	}

	for _, peer := range b.GaragePeers() {
		return peer
	}

	panic("no garage instances configured")
}

// GarageClientParams returns a GarageClientParams.
func (b Bootstrap) GarageClientParams() GarageClientParams {
	return GarageClientParams{
		Peer:                         b.ChooseGaragePeer(),
		GlobalBucketS3APICredentials: b.Garage.GlobalBucketS3APICredentials,
		RPCSecret:                    b.Garage.RPCSecret,
	}
}