package telldus

/*
#cgo CFLAGS: -I/usr/local/include
#cgo LDFLAGS: -L/usr/local/lib -ltelldus-core
#include <telldus-core.h>
#include <stdlib.h>

// Extern declarations for exported Go callback functions
extern void goDeviceEvent(int deviceId, int method, char *data, int callbackId, void *context);
extern void goDeviceChangeEvent(int deviceId, int changeEvent, int changeType, int callbackId, void *context);
extern void goRawDeviceEvent(char *data, int controllerId, int callbackId, void *context);
extern void goSensorEvent(char *protocol, char *model, int id, int dataType, char *value, int timestamp, int callbackId, void *context);
extern void goControllerEvent(int controllerId, int changeEvent, int changeType, char *newValue, int callbackId, void *context);
*/
import "C"
import "unsafe"

// Callback function types
type DeviceEventFunc func(deviceId, method int, data string, callbackId int)
type DeviceChangeEventFunc func(deviceId, changeEvent, changeType, callbackId int)
type RawDeviceEventFunc func(data string, controllerId, callbackId int)
type SensorEventFunc func(protocol, model string, id, dataType int, value string, timestamp, callbackId int)
type ControllerEventFunc func(controllerId, changeEvent, changeType int, newValue string, callbackId int)

// Global callback variables
var deviceEventCallback DeviceEventFunc
var deviceChangeEventCallback DeviceChangeEventFunc
var rawDeviceEventCallback RawDeviceEventFunc
var sensorEventCallback SensorEventFunc
var controllerEventCallback ControllerEventFunc

//export goDeviceEvent
func goDeviceEvent(deviceId C.int, method C.int, data *C.char, callbackId C.int, context unsafe.Pointer) {
	if deviceEventCallback != nil {
		deviceEventCallback(int(deviceId), int(method), C.GoString(data), int(callbackId))
	}
}

//export goDeviceChangeEvent
func goDeviceChangeEvent(deviceId C.int, changeEvent C.int, changeType C.int, callbackId C.int, context unsafe.Pointer) {
	if deviceChangeEventCallback != nil {
		deviceChangeEventCallback(int(deviceId), int(changeEvent), int(changeType), int(callbackId))
	}
}

//export goRawDeviceEvent
func goRawDeviceEvent(data *C.char, controllerId C.int, callbackId C.int, context unsafe.Pointer) {
	if rawDeviceEventCallback != nil {
		rawDeviceEventCallback(C.GoString(data), int(controllerId), int(callbackId))
	}
}

//export goSensorEvent
func goSensorEvent(protocol *C.char, model *C.char, id C.int, dataType C.int, value *C.char, timestamp C.int, callbackId C.int, context unsafe.Pointer) {
	if sensorEventCallback != nil {
		sensorEventCallback(C.GoString(protocol), C.GoString(model), int(id), int(dataType), C.GoString(value), int(timestamp), int(callbackId))
	}
}

//export goControllerEvent
func goControllerEvent(controllerId C.int, changeEvent C.int, changeType C.int, newValue *C.char, callbackId C.int, context unsafe.Pointer) {
	if controllerEventCallback != nil {
		controllerEventCallback(int(controllerId), int(changeEvent), int(changeType), C.GoString(newValue), int(callbackId))
	}
}

// Init initializes the Telldus library
func Init() {
	C.tdInit()
}

// Close closes the Telldus library
func Close() {
	C.tdClose()
}

// TurnOn turns on a device
func TurnOn(deviceId int) int {
	return int(C.tdTurnOn(C.int(deviceId)))
}

// TurnOff turns off a device
func TurnOff(deviceId int) int {
	return int(C.tdTurnOff(C.int(deviceId)))
}

// Learns a device
func Learn(deviceId int) int {
	return int(C.tdLearn(C.int(deviceId)))
}

// Dim dims a device to a level (0-255)
func Dim(deviceId int, level int) int {
	return int(C.tdDim(C.int(deviceId), C.uchar(level)))
}

// Bell rings the bell on a device
func Bell(deviceId int) int {
	return int(C.tdBell(C.int(deviceId)))
}

// GetNumberOfDevices returns the number of devices
func GetNumberOfDevices() int {
	return int(C.tdGetNumberOfDevices())
}

// GetDeviceId returns the device ID at the given index
func GetDeviceId(index int) int {
	return int(C.tdGetDeviceId(C.int(index)))
}

// GetName returns the name of a device
func GetName(deviceId int) string {
	cstr := C.tdGetName(C.int(deviceId))
	defer C.tdReleaseString(cstr)
	return C.GoString(cstr)
}

// GetProtocol returns the protocol of a device
func GetProtocol(deviceId int) string {
	cstr := C.tdGetProtocol(C.int(deviceId))
	defer C.tdReleaseString(cstr)
	return C.GoString(cstr)
}

// GetModel returns the model of a device
func GetModel(deviceId int) string {
	cstr := C.tdGetModel(C.int(deviceId))
	defer C.tdReleaseString(cstr)
	return C.GoString(cstr)
}

// Methods returns the supported methods for a device
func Methods(deviceId int, methodsSupported int) int {
	return int(C.tdMethods(C.int(deviceId), C.int(methodsSupported)))
}

// Sensor retrieves sensor data
func Sensor(protocol *string, model *string, id *int, dataTypes *int) int {
	var cProtocol [20]C.char
	var cModel [20]C.char
	var cId C.int
	var cDataTypes C.int
	ret := int(C.tdSensor(&cProtocol[0], 20, &cModel[0], 20, &cId, &cDataTypes))
	if ret == 0 {
		*protocol = C.GoString(&cProtocol[0])
		*model = C.GoString(&cModel[0])
		*id = int(cId)
		*dataTypes = int(cDataTypes)
	}
	return ret
}

// SensorValue retrieves a specific sensor value
func SensorValue(protocol, model string, id, dataType int) (string, int, int) {
	var value [20]C.char
	var timestamp C.int
	ret := int(C.tdSensorValue(C.CString(protocol), C.CString(model), C.int(id), C.int(dataType), &value[0], 20, &timestamp))
	if ret == 0 {
		return C.GoString(&value[0]), int(timestamp), ret
	}
	return "", 0, ret
}

// GetErrorString returns the error string for an error code
func GetErrorString(errorNo int) string {
	cstr := C.tdGetErrorString(C.int(errorNo))
	defer C.tdReleaseString(cstr)
	return C.GoString(cstr)
}

// RegisterDeviceEvent registers a callback for device events
func RegisterDeviceEvent(cb DeviceEventFunc) int {
	deviceEventCallback = cb
	return int(C.tdRegisterDeviceEvent(C.TDDeviceEvent(C.goDeviceEvent), nil))
}

// RegisterDeviceChangeEvent registers a callback for device change events
func RegisterDeviceChangeEvent(cb DeviceChangeEventFunc) int {
	deviceChangeEventCallback = cb
	return int(C.tdRegisterDeviceChangeEvent(C.TDDeviceChangeEvent(C.goDeviceChangeEvent), nil))
}

// RegisterRawDeviceEvent registers a callback for raw device events
func RegisterRawDeviceEvent(cb RawDeviceEventFunc) int {
	rawDeviceEventCallback = cb
	return int(C.tdRegisterRawDeviceEvent(C.TDRawDeviceEvent(C.goRawDeviceEvent), nil))
}

// RegisterSensorEvent registers a callback for sensor events
func RegisterSensorEvent(cb SensorEventFunc) int {
	sensorEventCallback = cb
	return int(C.tdRegisterSensorEvent(C.TDSensorEvent(C.goSensorEvent), nil))
}

// RegisterControllerEvent registers a callback for controller events
func RegisterControllerEvent(cb ControllerEventFunc) int {
	controllerEventCallback = cb
	return int(C.tdRegisterControllerEvent(C.TDControllerEvent(C.goControllerEvent), nil))
}

// UnregisterCallback unregisters a callback
func UnregisterCallback(callbackId int) int {
	return int(C.tdUnregisterCallback(C.int(callbackId)))
}

// Constants for methods
const (
	MethodTurnOn  = 1
	MethodTurnOff = 2
	MethodBell    = 4
	MethodDim     = 16
	MethodLearn   = 32
)

// Constants for sensor data types
const (
	DataTypeTemperature   = 1
	DataTypeHumidity      = 2
	DataTypeRainRate      = 4
	DataTypeRainTotal     = 8
	DataTypeWindDirection = 16
	DataTypeWindAverage   = 32
	DataTypeWindGust      = 64
)