package goffmpeg

/*
#cgo LDFLAGS: -ldl
#include <stdlib.h>
#include "libcffmpeg.h"
*/
import "C"
import (
	"errors"
	"fmt"
	"unsafe"
)

const (
	// ScaleFastBilinear SWS_FAST_BILINEAR
	ScaleFastBilinear = 1
	// ScaleBilinear SWS_BILINEAR
	ScaleBilinear = 2
	// ScaleBicubic SWS_BICUBIC
	ScaleBicubic = 4
	// ScaleX SWS_X
	ScaleX = 8
	// ScalePoint SWS_POINT
	ScalePoint = 0x10
	// ScaleArea SWS_AREA
	ScaleArea = 0x20
	// ScaleBicublin SWS_BICUBLIN
	ScaleBicublin = 0x40
	// ScaleGauss SWS_GAUSS
	ScaleGauss = 0x80
	// ScaleSinc SWS_SINC
	ScaleSinc = 0x100
	// ScaleLancZos SWS_LANCZOS
	ScaleLancZos = 0x200
	// ScaleSpline SWS_SPLINE
	ScaleSpline = 0x400
)

var libcffmpeg C.libcffmpeg

// InitFFmpeg init ffmepg
func InitFFmpeg(soFileGo string) error {
	soFile := C.CString(soFileGo)
	defer C.free(unsafe.Pointer(soFile))
	lib := C.init_libcffmpeg(soFile)
	if lib == nil {
		fmt.Println("open error: ", soFileGo)
		return errors.New("init ffmpeg error")
	}
	libcffmpeg = lib
	return nil
}

// FreeFFmpeg free ffmpeg
func FreeFFmpeg() {
	if libcffmpeg != nil {
		C.release_libcffmpeg(libcffmpeg)
	}
}

// GoFFMPEG handle for c
type GoFFMPEG struct {
	ffmpeg C.cffmpeg
}

// New create handle
func New() *GoFFMPEG {
	return &GoFFMPEG{
		ffmpeg: C.wrap_fn_create(),
	}
}

// NewWithScale scale out pic
func NewWithScale(w, h int, flag int) *GoFFMPEG {
	f := C.wrap_fn_create()
	if f != nil {
		C.wrap_fn_scale(f, C.int(w), C.int(h), C.int(flag))
	}
	return &GoFFMPEG{
		ffmpeg: f,
	}
}

// Free free handle
func (h *GoFFMPEG) Free() {
	C.wrap_fn_destroy(h.ffmpeg)
}

// Run ffmpeg
func (h *GoFFMPEG) Run(input string) {
	in := C.CString(input)
	defer C.free(unsafe.Pointer(in))

	C.wrap_fn_run(h.ffmpeg, in)
}

// DecodeJPEG decode jpeg file
func (h *GoFFMPEG) DecodeJPEG(input string) ([]byte, int, int) {
	in := C.CString(input)
	defer C.free(unsafe.Pointer(in))

	var width C.int
	var height C.int
	p := C.wrap_fn_decode_jpeg(h.ffmpeg, in, &width, &height)
	defer C.free(p)

	if width > 0 && height > 0 {
		data := C.GoBytes(p, width*height*3)
		wid := int(width)
		hei := int(height)
		return data, wid, hei
	}
	return nil, 0, 0
}

///////////////for encoder

// GoEncoder encoder
type GoEncoder struct {
	enc C.cencoder
}

// NewEncoder encoder
func NewEncoder(w, h, fps, br, sFlag, gi int) *GoEncoder {
	if w <= 0 || h <= 0 {
		return nil
	}

	return &GoEncoder{
		enc: C.wrap_fn_create_encoder(C.int(w), C.int(h), C.int(fps), C.int(br), C.int(sFlag), C.int(gi)),
	}
}

// Free free
func (e *GoEncoder) Free() {
	C.wrap_fn_destroy_encoder(e.enc)
}

// Encode pic
func (e *GoEncoder) Encode(in []byte, w, h int) ([]byte, int, bool) {

	var size C.int
	var key C.int
	cin := C.CBytes(in)
	defer C.free(cin)

	p := C.wrap_fn_encode(e.enc, cin, C.int(w), C.int(h), &size, &key)
	defer C.free(p)
	if p != nil && size > 0 {
		b := C.GoBytes(p, size)

		isKey := false
		if key > 0 {
			isKey = true
		}
		return b, int(size), isKey
	}
	return nil, 0, false
}