package server


/*
#include <stdlib.h>

struct OpenReply {
	char* message;
	char* context;
};

struct DoResponse {
	char* reqName;
	char* RespResult;
	char* retContext;
};

int open_device(int devIdx, char* devUri, char* devGroup, void** reply);
int close_device(int devIdx, char* devUri, char* devGroup, void** reply);

int device_get(int devIdx, char* devUri, char* devProperty, void** reply);
int device_set(int devIdx, char* devUri, char* devProperty, char* devValueSet, void** reply);
int device_update(int devIdx, char* devUri, char* devProperty, char* devValueUpdate, void** reply);

int device_add(int devIdx, char* devUri, char* devProperty, char* devValueAdd, void** reply);
int device_del(int devIdx, char* devUri, char* devProperty, char* devValueDel, void** reply);

int device_action(int devIdx, char* devUri, char* devFunction, char* devReqParams, void** reply);
int device_message(int devIdx, char* devUri, char* devTopic, char* devMessageValue, void** reply);

int free_struct(void* pPoirnt, int nItemCount);
*/
import "C"


import (
	"context"
	"fmt"
	"sync"
	"unsafe"

	gen "github.com/osguydch/ccosproc/proto/device/v3"
)
// DeviceServerImpl will implement the service defined in protocol buffer definitions
type DeviceServerImpl struct {
	gen.UnimplementedDeviceServer
	mu   *sync.RWMutex
	devs map[string]int
}

// New initializes a new Backend struct.
func New(dev []string) *DeviceServerImpl {
	devs := make(map[string]int)
	for i, v := range dev {
		devs[v] = i
	}
	return &DeviceServerImpl{
		mu:   &sync.RWMutex{},
		devs: devs,
	}
}

// Open is the implementation of RPC call defined in protocol definitions.
// This will take OpenRequest message and return OpenReply
func (g *DeviceServerImpl) Open(ctx context.Context, request *gen.OpenRequest) (*gen.OpenReply, error) {
	g.mu.Lock()
	defer g.mu.Unlock()

	idx := g.devs[request.DeviceUri]

	cUri := C.CString(request.DeviceUri)
	cGroup := C.CString(request.DeviceGroup)
	defer C.free(unsafe.Pointer(cUri))
	defer C.free(unsafe.Pointer(cGroup))

	var openReply unsafe.Pointer
	ret := C.open_device(C.int(idx), cUri, cGroup, &openReply)

	if ret != 2 {
		return &gen.OpenReply{
			Message:    fmt.Sprintf("grpc error for open %s", request.DeviceUri),
			RetContext: "Open Call Error",
		}, nil
	}
	defer C.free_struct(openReply, C.int(3))

	reply := (*C.struct_OpenReply)(openReply)
	return &gen.OpenReply{
		Message:    C.GoString(reply.message),
		RetCode:    fmt.Sprintf("%d", ret),
		RetContext: C.GoString(reply.context),
	}, nil
}

func (g *DeviceServerImpl) Close(ctx context.Context, request *gen.OpenRequest) (*gen.OpenReply, error) {
	g.mu.Lock()
	defer g.mu.Unlock()

	idx := g.devs[request.DeviceUri]

	cUri := C.CString(request.DeviceUri)
	cGroup := C.CString(request.DeviceGroup)
	defer C.free(unsafe.Pointer(cUri))
	defer C.free(unsafe.Pointer(cGroup))

	var openReply unsafe.Pointer
	ret := C.close_device(C.int(idx), cUri, cGroup, &openReply)

	if ret != 2 {
		return &gen.OpenReply{
			Message:    fmt.Sprintf("grpc error for close %s", request.DeviceUri),
			RetContext: "Close Call Error",
		}, nil
	}
	defer C.free_struct(openReply, C.int(3))

	reply := (*C.struct_OpenReply)(openReply)
	return &gen.OpenReply{
		Message:    C.GoString(reply.message),
		RetCode:    fmt.Sprintf("%d", ret),
		RetContext: C.GoString(reply.context),
	}, nil
}

func (g *DeviceServerImpl) Get(ctx context.Context, request *gen.DoRequest) (*gen.DoResponse, error) {
	g.mu.Lock()
	defer g.mu.Unlock()

	idx := g.devs[request.DeviceUri]

	cUri := C.CString(request.DeviceUri)
	cName := C.CString(request.ReqName)
	defer C.free(unsafe.Pointer(cUri))
	defer C.free(unsafe.Pointer(cName))

	var openReply unsafe.Pointer
	ret := C.device_get(C.int(idx), cUri, cName, &openReply)

	reply := (*C.struct_DoResponse)(openReply)

	if ret != 2 {
		return &gen.DoResponse{
			DeviceUri:  request.DeviceUri,
			RetCode:    fmt.Sprintf("%d", ret),
			ReqName:    request.ReqName,
			RespResult: C.GoString(reply.RespResult),
			RetContext: "Get Call Error",
		}, nil
	}
	defer C.free_struct(openReply, C.int(3))

	return &gen.DoResponse{
		DeviceUri:      request.DeviceUri,
		RetCode:        fmt.Sprintf("%d", ret),
		ReqName:        request.ReqName,
		RespResult:     C.GoString(reply.RespResult),
		ReqTransaction: request.ReqTransaction,
		RetContext:     C.GoString(reply.retContext),
	}, nil
}

func (g *DeviceServerImpl) Set(ctx context.Context, request *gen.DoRequest) (*gen.DoResponse, error) {
	g.mu.Lock()
	defer g.mu.Unlock()

	idx := g.devs[request.DeviceUri]

	cUri := C.CString(request.DeviceUri)
	cName := C.CString(request.ReqName)
	cParam := C.CString(request.ReqParam)
	defer C.free(unsafe.Pointer(cUri))
	defer C.free(unsafe.Pointer(cName))
	defer C.free(unsafe.Pointer(cParam))

	var openReply unsafe.Pointer
	ret := C.device_set(C.int(idx), cUri, cName, cParam, &openReply)

	reply := (*C.struct_DoResponse)(openReply)

	if ret != 2 {
		return &gen.DoResponse{
			DeviceUri:  request.DeviceUri,
			RetCode:    fmt.Sprintf("%d", ret),
			ReqName:    request.ReqName,
			RespResult: C.GoString(reply.RespResult),
			RetContext: "Set Call Error",
		}, nil
	}
	defer C.free_struct(openReply, C.int(3))

	return &gen.DoResponse{
		DeviceUri:      request.DeviceUri,
		RetCode:        fmt.Sprintf("%d", ret),
		ReqName:        request.ReqName,
		RespResult:     C.GoString(reply.RespResult),
		ReqTransaction: request.ReqTransaction,
		RetContext:     C.GoString(reply.retContext),
	}, nil
}

func (g *DeviceServerImpl) Update(ctx context.Context, request *gen.DoRequest) (*gen.DoResponse, error) {
	g.mu.Lock()
	defer g.mu.Unlock()

	idx := g.devs[request.DeviceUri]

	cUri := C.CString(request.DeviceUri)
	cName := C.CString(request.ReqName)
	cParam := C.CString(request.ReqParam)
	defer C.free(unsafe.Pointer(cUri))
	defer C.free(unsafe.Pointer(cName))
	defer C.free(unsafe.Pointer(cParam))

	var openReply unsafe.Pointer
	ret := C.device_update(C.int(idx), cUri, cName, cParam, &openReply)

	reply := (*C.struct_DoResponse)(openReply)

	if ret != 2 {
		return &gen.DoResponse{
			DeviceUri:  request.DeviceUri,
			RetCode:    fmt.Sprintf("%d", ret),
			ReqName:    request.ReqName,
			RespResult: C.GoString(reply.RespResult),
			RetContext: "Update Call Error",
		}, nil
	}
	defer C.free_struct(openReply, C.int(3))

	return &gen.DoResponse{
		DeviceUri:      request.DeviceUri,
		RetCode:        fmt.Sprintf("%d", ret),
		ReqName:        request.ReqName,
		RespResult:     C.GoString(reply.RespResult),
		ReqTransaction: request.ReqTransaction,
		RetContext:     C.GoString(reply.retContext),
	}, nil
}

func (g *DeviceServerImpl) Add(ctx context.Context, request *gen.DoRequest) (*gen.DoResponse, error) {
	g.mu.Lock()
	defer g.mu.Unlock()

	idx := g.devs[request.DeviceUri]

	cUri := C.CString(request.DeviceUri)
	cName := C.CString(request.ReqName)
	cParam := C.CString(request.ReqParam)
	defer C.free(unsafe.Pointer(cUri))
	defer C.free(unsafe.Pointer(cName))
	defer C.free(unsafe.Pointer(cParam))

	var openReply unsafe.Pointer
	ret := C.device_add(C.int(idx), cUri, cName, cParam, &openReply)

	reply := (*C.struct_DoResponse)(openReply)

	if ret != 2 {
		return &gen.DoResponse{
			DeviceUri:  request.DeviceUri,
			RetCode:    fmt.Sprintf("%d", ret),
			ReqName:    request.ReqName,
			RespResult: C.GoString(reply.RespResult),
			RetContext: "Add Call Error",
		}, nil
	}
	defer C.free_struct(openReply, C.int(3))

	return &gen.DoResponse{
		DeviceUri:      request.DeviceUri,
		RetCode:        fmt.Sprintf("%d", ret),
		ReqName:        request.ReqName,
		RespResult:     C.GoString(reply.RespResult),
		ReqTransaction: request.ReqTransaction,
		RetContext:     C.GoString(reply.retContext),
	}, nil
}

func (g *DeviceServerImpl) Del(ctx context.Context, request *gen.DoRequest) (*gen.DoResponse, error) {
	g.mu.Lock()
	defer g.mu.Unlock()

	idx := g.devs[request.DeviceUri]

	cUri := C.CString(request.DeviceUri)
	cName := C.CString(request.ReqName)
	cParam := C.CString(request.ReqParam)
	defer C.free(unsafe.Pointer(cUri))
	defer C.free(unsafe.Pointer(cName))
	defer C.free(unsafe.Pointer(cParam))

	var openReply unsafe.Pointer
	ret := C.device_del(C.int(idx), cUri, cName, cParam, &openReply)

	reply := (*C.struct_DoResponse)(openReply)

	if ret != 2 {
		return &gen.DoResponse{
			DeviceUri:  request.DeviceUri,
			RetCode:    fmt.Sprintf("%d", ret),
			ReqName:    request.ReqName,
			RespResult: C.GoString(reply.RespResult),
			RetContext: "Del Call Error",
		}, nil
	}
	defer C.free_struct(openReply, C.int(3))

	return &gen.DoResponse{
		DeviceUri:      request.DeviceUri,
		RetCode:        fmt.Sprintf("%d", ret),
		ReqName:        request.ReqName,
		RespResult:     C.GoString(reply.RespResult),
		ReqTransaction: request.ReqTransaction,
		RetContext:     C.GoString(reply.retContext),
	}, nil
}

func (g *DeviceServerImpl) Action(ctx context.Context, request *gen.DoRequest) (*gen.DoResponse, error) {
	g.mu.Lock()
	defer g.mu.Unlock()

	idx := g.devs[request.DeviceUri]

	cUri := C.CString(request.DeviceUri)
	cName := C.CString(request.ReqName)
	cParam := C.CString(request.ReqParam)
	defer C.free(unsafe.Pointer(cUri))
	defer C.free(unsafe.Pointer(cName))
	defer C.free(unsafe.Pointer(cParam))

	var openReply unsafe.Pointer
	ret := C.device_action(C.int(idx), cUri, cName, cParam, &openReply)

	reply := (*C.struct_DoResponse)(openReply)

	if ret != 2 {
		return &gen.DoResponse{
			DeviceUri:  request.DeviceUri,
			RetCode:    fmt.Sprintf("%d", ret),
			ReqName:    request.ReqName,
			RespResult: C.GoString(reply.RespResult),
			RetContext: "Action Call Error",
		}, nil
	}
	defer C.free_struct(openReply, C.int(3))

	return &gen.DoResponse{
		DeviceUri:      request.DeviceUri,
		RetCode:        fmt.Sprintf("%d", ret),
		ReqName:        request.ReqName,
		RespResult:     C.GoString(reply.RespResult),
		ReqTransaction: request.ReqTransaction,
		RetContext:     C.GoString(reply.retContext),
	}, nil
}

func (g *DeviceServerImpl) Message(ctx context.Context, request *gen.DoRequest) (*gen.DoResponse, error) {
	g.mu.Lock()
	defer g.mu.Unlock()

	idx := g.devs[request.DeviceUri]

	cUri := C.CString(request.DeviceUri)
	cName := C.CString(request.ReqName)
	cParam := C.CString(request.ReqParam)
	defer C.free(unsafe.Pointer(cUri))
	defer C.free(unsafe.Pointer(cName))
	defer C.free(unsafe.Pointer(cParam))

	var openReply unsafe.Pointer
	ret := C.device_message(C.int(idx), cUri, cName, cParam, &openReply)

	reply := (*C.struct_DoResponse)(openReply)

	if ret != 2 {
		return &gen.DoResponse{
			DeviceUri:  request.DeviceUri,
			RetCode:    fmt.Sprintf("%d", ret),
			ReqName:    request.ReqName,
			RespResult: C.GoString(reply.RespResult),
			RetContext: "Message Call Error",
		}, nil
	}
	defer C.free_struct(openReply, C.int(3))

	return &gen.DoResponse{
		DeviceUri:      request.DeviceUri,
		RetCode:        fmt.Sprintf("%d", ret),
		ReqName:        request.ReqName,
		RespResult:     C.GoString(reply.RespResult),
		ReqTransaction: request.ReqTransaction,
		RetContext:     C.GoString(reply.retContext),
	}, nil
}