package rbd

/*
#cgo LDFLAGS: -lrbd
#include <stdlib.h>
#include <rbd/librbd.h>
*/
import "C"

import (
	"unsafe"

	"github.com/ceph/go-ceph/internal/cutil"
	"github.com/ceph/go-ceph/internal/retry"
	"github.com/ceph/go-ceph/rados"
)

// GroupCreate is used to create an image group.
//
// Implements:
//  int rbd_group_create(rados_ioctx_t p, const char *name);
func GroupCreate(ioctx *rados.IOContext, name string) error {
	cName := C.CString(name)
	defer C.free(unsafe.Pointer(cName))

	ret := C.rbd_group_create(cephIoctx(ioctx), cName)
	return getError(ret)
}

// GroupRemove is used to remove an image group.
//
// Implements:
//  int rbd_group_remove(rados_ioctx_t p, const char *name);
func GroupRemove(ioctx *rados.IOContext, name string) error {
	cName := C.CString(name)
	defer C.free(unsafe.Pointer(cName))

	ret := C.rbd_group_remove(cephIoctx(ioctx), cName)
	return getError(ret)
}

// GroupRename will rename an existing image group.
//
// Implements:
//  int rbd_group_rename(rados_ioctx_t p, const char *src_name,
//                       const char *dest_name);
func GroupRename(ioctx *rados.IOContext, src, dest string) error {
	cSrc := C.CString(src)
	defer C.free(unsafe.Pointer(cSrc))
	cDest := C.CString(dest)
	defer C.free(unsafe.Pointer(cDest))

	ret := C.rbd_group_rename(cephIoctx(ioctx), cSrc, cDest)
	return getError(ret)
}

// GroupList returns a slice of image group names.
//
// Implements:
//  int rbd_group_list(rados_ioctx_t p, char *names, size_t *size);
func GroupList(ioctx *rados.IOContext) ([]string, error) {
	var (
		buf []byte
		err error
		ret C.int
	)
	retry.WithSizes(1024, 262144, func(size int) retry.Hint {
		cSize := C.size_t(size)
		buf = make([]byte, cSize)
		ret = C.rbd_group_list(
			cephIoctx(ioctx),
			(*C.char)(unsafe.Pointer(&buf[0])),
			&cSize)
		err = getErrorIfNegative(ret)
		return retry.Size(int(cSize)).If(err == errRange)
	})

	if err != nil {
		return nil, err
	}

	// cSize is not set to the expected size when it is sufficiently large
	// but ret will be set to the size in a non-error condition.
	groups := cutil.SplitBuffer(buf[:ret])
	return groups, nil
}

// GroupImageAdd will add the specified image to the named group.
// An io context must be supplied for both the group and image.
//
// Implements:
//  int rbd_group_image_add(rados_ioctx_t group_p,
//                          const char *group_name,
//                          rados_ioctx_t image_p,
//                          const char *image_name);
func GroupImageAdd(groupIoctx *rados.IOContext, groupName string,
	imageIoctx *rados.IOContext, imageName string) error {

	cGroupName := C.CString(groupName)
	defer C.free(unsafe.Pointer(cGroupName))
	cImageName := C.CString(imageName)
	defer C.free(unsafe.Pointer(cImageName))

	ret := C.rbd_group_image_add(
		cephIoctx(groupIoctx),
		cGroupName,
		cephIoctx(imageIoctx),
		cImageName)
	return getError(ret)
}

// GroupImageRemove will remove the specified image from the named group.
// An io context must be supplied for both the group and image.
//
// Implements:
//  int rbd_group_image_remove(rados_ioctx_t group_p,
//                             const char *group_name,
//                             rados_ioctx_t image_p,
//                             const char *image_name);
func GroupImageRemove(groupIoctx *rados.IOContext, groupName string,
	imageIoctx *rados.IOContext, imageName string) error {

	cGroupName := C.CString(groupName)
	defer C.free(unsafe.Pointer(cGroupName))
	cImageName := C.CString(imageName)
	defer C.free(unsafe.Pointer(cImageName))

	ret := C.rbd_group_image_remove(
		cephIoctx(groupIoctx),
		cGroupName,
		cephIoctx(imageIoctx),
		cImageName)
	return getError(ret)
}

// GroupImageRemoveByID will remove the specified image from the named group.
// An io context must be supplied for both the group and image.
//
// Implements:
//  CEPH_RBD_API int rbd_group_image_remove_by_id(rados_ioctx_t group_p,
//                                               const char *group_name,
//                                               rados_ioctx_t image_p,
//                                               const char *image_id);
func GroupImageRemoveByID(groupIoctx *rados.IOContext, groupName string,
	imageIoctx *rados.IOContext, imageID string) error {

	cGroupName := C.CString(groupName)
	defer C.free(unsafe.Pointer(cGroupName))
	cid := C.CString(imageID)
	defer C.free(unsafe.Pointer(cid))

	ret := C.rbd_group_image_remove_by_id(
		cephIoctx(groupIoctx),
		cGroupName,
		cephIoctx(imageIoctx),
		cid)
	return getError(ret)
}

// GroupImageState indicates an image's state in a group.
type GroupImageState int

const (
	// GroupImageStateAttached is equivalent to RBD_GROUP_IMAGE_STATE_ATTACHED
	GroupImageStateAttached = GroupImageState(C.RBD_GROUP_IMAGE_STATE_ATTACHED)
	// GroupImageStateIncomplete is equivalent to RBD_GROUP_IMAGE_STATE_INCOMPLETE
	GroupImageStateIncomplete = GroupImageState(C.RBD_GROUP_IMAGE_STATE_INCOMPLETE)
)

// GroupImageInfo reports on images within a group.
type GroupImageInfo struct {
	Name   string
	PoolID int64
	State  GroupImageState
}

// GroupImageList returns a slice of GroupImageInfo types based on the
// images that are part of the named group.
//
// Implements:
//  int rbd_group_image_list(rados_ioctx_t group_p,
//                           const char *group_name,
//                           rbd_group_image_info_t *images,
//                           size_t group_image_info_size,
//                           size_t *num_entries);
func GroupImageList(ioctx *rados.IOContext, name string) ([]GroupImageInfo, error) {
	cName := C.CString(name)
	defer C.free(unsafe.Pointer(cName))

	var (
		cImages []C.rbd_group_image_info_t
		cSize   C.size_t
		err     error
	)
	retry.WithSizes(1024, 262144, func(size int) retry.Hint {
		cSize = C.size_t(size)
		cImages = make([]C.rbd_group_image_info_t, cSize)
		ret := C.rbd_group_image_list(
			cephIoctx(ioctx),
			cName,
			(*C.rbd_group_image_info_t)(unsafe.Pointer(&cImages[0])),
			C.sizeof_rbd_group_image_info_t,
			&cSize)
		err = getErrorIfNegative(ret)
		return retry.Size(int(cSize)).If(err == errRange)
	})

	if err != nil {
		return nil, err
	}

	images := make([]GroupImageInfo, cSize)
	for i := range images {
		images[i].Name = C.GoString(cImages[i].name)
		images[i].PoolID = int64(cImages[i].pool)
		images[i].State = GroupImageState(cImages[i].state)
	}

	// free C memory allocated by C.rbd_group_image_list call
	ret := C.rbd_group_image_list_cleanup(
		(*C.rbd_group_image_info_t)(unsafe.Pointer(&cImages[0])),
		C.sizeof_rbd_group_image_info_t,
		cSize)
	return images, getError(ret)
}

// GroupInfo contains the name and pool id of a RBD group.
type GroupInfo struct {
	Name   string
	PoolID int64
}

// GetGroup returns group info for the group this image is part of.
//
// Implements:
//  int rbd_get_group(rbd_image_t image, rbd_group_info_t *group_info,
//                    size_t group_info_size);
func (image *Image) GetGroup() (GroupInfo, error) {
	if err := image.validate(imageIsOpen); err != nil {
		return GroupInfo{}, err
	}

	var cgi C.rbd_group_info_t
	ret := C.rbd_get_group(
		image.image,
		&cgi,
		C.sizeof_rbd_group_info_t)
	if err := getErrorIfNegative(ret); err != nil {
		return GroupInfo{}, err
	}

	gi := GroupInfo{
		Name:   C.GoString(cgi.name),
		PoolID: int64(cgi.pool),
	}
	ret = C.rbd_group_info_cleanup(&cgi, C.sizeof_rbd_group_info_t)
	return gi, getError(ret)
}