func updateControllerDetailsFromLogin(
	store jujuclient.ControllerStore,
	controllerName string, controllerDetails *jujuclient.ControllerDetails,
	params UpdateControllerParams,
) error {
	// Get the new endpoint addresses.
	addrs, unresolvedAddrs, addrsChanged := PrepareEndpointsForCaching(*controllerDetails, params.CurrentHostPorts, params.AddrConnectedTo...)
	agentChanged := params.AgentVersion != controllerDetails.AgentVersion
	if !addrsChanged && !agentChanged && params.ModelCount == nil && params.MachineCount == nil && params.ControllerMachineCount == nil {
		return nil
	}

	// Write the new controller data.
	if addrsChanged {
		controllerDetails.APIEndpoints = addrs
		controllerDetails.UnresolvedAPIEndpoints = unresolvedAddrs
	}
	if agentChanged {
		controllerDetails.AgentVersion = params.AgentVersion
	}
	if params.ModelCount != nil {
		controllerDetails.ModelCount = params.ModelCount
	}
	if params.MachineCount != nil {
		controllerDetails.MachineCount = params.MachineCount
	}
	if params.ControllerMachineCount != nil {
		controllerDetails.ControllerMachineCount = *params.ControllerMachineCount
	}
	err := store.UpdateController(controllerName, *controllerDetails)
	return errors.Trace(err)
}

func setEndpointAddressAndHostname(c *gc.C, store jujuclient.ControllerStore, addr, host string) {
	// Populate the controller details with known address and hostname.
	details, err := store.ControllerByName("local.my-controller")
	c.Assert(err, jc.ErrorIsNil)
	details.APIEndpoints = []string{addr}
	details.UnresolvedAPIEndpoints = []string{host}
	err = store.UpdateController("local.my-controller", *details)
	c.Assert(err, jc.ErrorIsNil)
}

// UpdateControllerDetailsFromLogin writes any new api addresses and other relevant details
// to the client controller file.
// Controller may be specified by a UUID or name, and must already exist.
func UpdateControllerDetailsFromLogin(
	store jujuclient.ControllerStore, controllerName string,
	params UpdateControllerParams,
) error {
	controllerDetails, err := store.ControllerByName(controllerName)
	if err != nil {
		return errors.Trace(err)
	}
	return updateControllerDetailsFromLogin(store, controllerName, controllerDetails, params)
}

// UpdateControllerAddresses writes any new api addresses to the client controller file.
// Controller may be specified by a UUID or name, and must already exist.
func UpdateControllerAddresses(
	store jujuclient.ControllerStore, controllerName string,
	currentHostPorts [][]network.HostPort, addrConnectedTo ...network.HostPort,
) error {
	controllerDetails, err := store.ControllerByName(controllerName)
	if err != nil {
		return errors.Trace(err)
	}
	return updateControllerAddresses(
		store, controllerName, controllerDetails,
		currentHostPorts, addrConnectedTo...,
	)
}

func updateControllerAddresses(
	store jujuclient.ControllerStore,
	controllerName string, controllerDetails *jujuclient.ControllerDetails,
	currentHostPorts [][]network.HostPort, addrConnectedTo ...network.HostPort,
) error {
	// Get the new endpoint addresses.
	addrs, hosts, addrsChanged := PrepareEndpointsForCaching(*controllerDetails, currentHostPorts, addrConnectedTo...)
	if !addrsChanged {
		return nil
	}

	// Write the new controller data.
	controllerDetails.UnresolvedAPIEndpoints = hosts
	controllerDetails.APIEndpoints = addrs
	err := store.UpdateController(controllerName, *controllerDetails)
	return errors.Trace(err)
}

// ResolveControllerName returns the canonical name of a controller given
// an unambiguous identifier for that controller.
// Locally created controllers (i.e. those whose names begin with "local.")
// may be identified with or without the "local." prefix if there exists no
// other controller in the store with the same unprefixed name.
func ResolveControllerName(store jujuclient.ControllerStore, controllerName string) (string, error) {
	_, err := store.ControllerByName(controllerName)
	if err == nil {
		return controllerName, nil
	}
	if !errors.IsNotFound(err) {
		return "", err
	}
	var secondErr error
	localName := "local." + controllerName
	_, secondErr = store.ControllerByName(localName)
	// If fallback name not found, return the original error.
	if errors.IsNotFound(secondErr) {
		return "", err
	}
	return localName, secondErr
}

// Destroy destroys the controller and, if successful,
// its associated configuration data from the given store.
func Destroy(
	controllerName string,
	env Environ,
	store jujuclient.ControllerStore,
) error {
	details, err := store.ControllerByName(controllerName)
	if err != nil && !errors.IsNotFound(err) {
		return errors.Trace(err)
	}
	if err := env.DestroyController(details.ControllerUUID); err != nil {
		return errors.Trace(err)
	}
	err = store.RemoveController(controllerName)
	if err != nil && !errors.IsNotFound(err) {
		return errors.Trace(err)
	}
	return nil
}