package git

/*
#include <git2.h>
#include <git2/errors.h>

int _go_git_push_status_foreach(git_push *push, void *data);
int _go_git_push_set_callbacks(git_push *push, void *packbuilder_progress_data, void *transfer_progress_data);

*/
import "C"
import (
	"runtime"
	"unsafe"
)

type Push struct {
	ptr *C.git_push

	packbuilderProgress *PackbuilderProgressCallback
	transferProgress    *PushTransferProgressCallback
}

func newPushFromC(cpush *C.git_push) *Push {
	p := &Push{ptr: cpush}
	runtime.SetFinalizer(p, (*Push).Free)
	return p
}

func (p *Push) Free() {
	runtime.SetFinalizer(p, nil)
	C.git_push_free(p.ptr)
}

func (remote *Remote) NewPush() (*Push, error) {

	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	var cpush *C.git_push
	ret := C.git_push_new(&cpush, remote.ptr)
	if ret < 0 {
		return nil, MakeGitError(ret)
	}
	return newPushFromC(cpush), nil
}

func (p *Push) Finish() error {

	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	ret := C.git_push_finish(p.ptr)
	if ret < 0 {
		return MakeGitError(ret)
	}
	return nil
}

func (p *Push) UnpackOk() bool {

	ret := C.git_push_unpack_ok(p.ptr)
	if ret == 0 {
		return false
	}
	return true

}

func (p *Push) UpdateTips(sig *Signature, msg string) error {

	var csig *C.git_signature = nil
	if sig != nil {
		csig = sig.toC()
		defer C.free(unsafe.Pointer(csig))
	}

	var cmsg *C.char
	if msg == "" {
		cmsg = nil
	} else {
		cmsg = C.CString(msg)
		defer C.free(unsafe.Pointer(cmsg))
	}

	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	ret := C.git_push_update_tips(p.ptr, csig, cmsg)
	if ret < 0 {
		return MakeGitError(ret)
	}
	return nil
}

func (p *Push) AddRefspec(refspec string) error {

	crefspec := C.CString(refspec)
	defer C.free(unsafe.Pointer(crefspec))

	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	ret := C.git_push_add_refspec(p.ptr, crefspec)
	if ret < 0 {
		return MakeGitError(ret)
	}
	return nil
}

type PushOptions struct {
	Version       uint
	PbParallelism uint
}

func (p *Push) SetOptions(opts PushOptions) error {
	copts := C.git_push_options{version: C.uint(opts.Version), pb_parallelism: C.uint(opts.PbParallelism)}

	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	ret := C.git_push_set_options(p.ptr, &copts)
	if ret < 0 {
		return MakeGitError(ret)
	}
	return nil
}

type StatusForeachFunc func(ref string, msg string) int

//export statusForeach
func statusForeach(_ref *C.char, _msg *C.char, _data unsafe.Pointer) C.int {
	ref := C.GoString(_ref)
	msg := C.GoString(_msg)

	cb := (*StatusForeachFunc)(_data)

	return C.int((*cb)(ref, msg))
}

func (p *Push) StatusForeach(callback StatusForeachFunc) error {

	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	ret := C._go_git_push_status_foreach(p.ptr, unsafe.Pointer(&callback))
	if ret < 0 {
		return MakeGitError(ret)
	}
	return nil

}

type PushCallbacks struct {
	PackbuilderProgress *PackbuilderProgressCallback
	TransferProgress    *PushTransferProgressCallback
}

type PackbuilderProgressCallback func(stage int, current uint, total uint) int
type PushTransferProgressCallback func(current uint, total uint, bytes uint) int

//export packbuilderProgress
func packbuilderProgress(stage C.int, current C.uint, total C.uint, data unsafe.Pointer) C.int {
	return C.int((*(*PackbuilderProgressCallback)(data))(int(stage), uint(current), uint(total)))
}

//export pushTransferProgress
func pushTransferProgress(current C.uint, total C.uint, bytes C.size_t, data unsafe.Pointer) C.int {
	return C.int((*(*PushTransferProgressCallback)(data))(uint(current), uint(total), uint(bytes)))
}

func (p *Push) SetCallbacks(callbacks PushCallbacks) {

	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	// save callbacks so they don't get GC'd
	p.packbuilderProgress = callbacks.PackbuilderProgress
	p.transferProgress = callbacks.TransferProgress

	C._go_git_push_set_callbacks(p.ptr, unsafe.Pointer(p.packbuilderProgress), unsafe.Pointer(p.transferProgress))
}