// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package native_cgo

//#include "mojo/public/c/system/buffer.h"
//#include "mojo/public/c/system/data_pipe.h"
//#include "mojo/public/c/system/handle.h"
//#include "mojo/public/c/system/message_pipe.h"
//#include "mojo/public/c/system/result.h"
//#include "mojo/public/c/system/time.h"
//#include "mojo/public/c/system/wait.h"
//
// // These functions are used to 8-byte align C structs.
// MojoResult CreateSharedBuffer(struct MojoCreateSharedBufferOptions* options,
//     uint64_t num_bytes, MojoHandle* handle) {
//   struct MojoCreateSharedBufferOptions aligned_options;
//   if (options != NULL) {
//     aligned_options = *options;
//     return MojoCreateSharedBuffer(&aligned_options, num_bytes, handle);
//   } else {
//     return MojoCreateSharedBuffer(NULL, num_bytes, handle);
//   }
// }
//
// MojoResult DuplicateBufferHandle(MojoHandle handle,
//     struct MojoDuplicateBufferHandleOptions* options, MojoHandle* duplicate) {
//   struct MojoDuplicateBufferHandleOptions aligned_options;
//   if (options != NULL) {
//     aligned_options = *options;
//     return MojoDuplicateBufferHandle(handle, &aligned_options, duplicate);
//   } else {
//     return MojoDuplicateBufferHandle(handle, NULL, duplicate);
//   }
// }
//
// MojoResult CreateDataPipe(struct MojoCreateDataPipeOptions* options,
//     MojoHandle* producer, MojoHandle* consumer) {
//   struct MojoCreateDataPipeOptions aligned_options;
//   if (options != NULL) {
//     aligned_options = *options;
//     return MojoCreateDataPipe(&aligned_options, producer, consumer);
//   } else {
//     return MojoCreateDataPipe(NULL, producer, consumer);
//   }
// }
//
// MojoResult CreateMessagePipe(struct MojoCreateMessagePipeOptions* options,
//     MojoHandle* handle0, MojoHandle* handle1) {
//   struct MojoCreateMessagePipeOptions aligned_options = *options;
//   if (options != NULL) {
//     aligned_options = *options;
//     return MojoCreateMessagePipe(&aligned_options, handle0, handle1);
//   } else {
//     return MojoCreateMessagePipe(NULL, handle0, handle1);
//   }
// }
//
import "C"
import (
	"unsafe"
)

// CGoSystem provides an implementation of the system.MojoSystem interface based on CGO
type CGoSystem struct{}

func (c *CGoSystem) CreateSharedBuffer(flags uint32, numBytes uint64) (uint32, uint32) {
	var opts *C.struct_MojoCreateSharedBufferOptions
	opts = &C.struct_MojoCreateSharedBufferOptions{
		C.uint32_t(unsafe.Sizeof(*opts)),
		C.MojoCreateSharedBufferOptionsFlags(flags),
	}
	var cHandle C.MojoHandle
	r := C.CreateSharedBuffer(opts, C.uint64_t(numBytes), &cHandle)
	return uint32(r), uint32(cHandle)
}

func (c *CGoSystem) DuplicateBufferHandle(handle uint32, flags uint32) (uint32, uint32) {
	var opts *C.struct_MojoDuplicateBufferHandleOptions
	opts = &C.struct_MojoDuplicateBufferHandleOptions{
		C.uint32_t(unsafe.Sizeof(*opts)),
		C.MojoDuplicateBufferHandleOptionsFlags(flags),
	}
	var cDuplicateHandle C.MojoHandle
	r := C.DuplicateBufferHandle(C.MojoHandle(handle), opts, &cDuplicateHandle)
	return uint32(r), uint32(cDuplicateHandle)
}

func (c *CGoSystem) MapBuffer(handle uint32, offset, numBytes uint64, flags uint32) (result uint32, buf []byte) {
	var bufPtr unsafe.Pointer
	r := C.MojoMapBuffer(C.MojoHandle(handle), C.uint64_t(offset), C.uint64_t(numBytes), &bufPtr, C.MojoMapBufferFlags(flags))
	if r != C.MOJO_RESULT_OK {
		return uint32(r), nil
	}
	return uint32(r), unsafeByteSlice(bufPtr, int(numBytes))
}

func (c *CGoSystem) GetBufferInformation(handle uint32) (result uint32, flags uint32, numBytes uint64) {
	var info *C.struct_MojoBufferInformation
	info = &C.struct_MojoBufferInformation{}
	r := C.MojoGetBufferInformation(C.MojoHandle(handle), info, C.uint32_t(unsafe.Sizeof(*info)))

	return uint32(r), uint32(info.flags), uint64(info.num_bytes)
}

func (c *CGoSystem) UnmapBuffer(buf []byte) (result uint32) {
	return uint32(C.MojoUnmapBuffer(unsafe.Pointer(&buf[0])))
}

func createDataPipeWithCOptions(opts *C.struct_MojoCreateDataPipeOptions) (result uint32, producerHandle, consumerHandle uint32) {
	var cProducerHandle, cConsumerHandle C.MojoHandle
	r := C.CreateDataPipe(opts, &cProducerHandle, &cConsumerHandle)
	return uint32(r), uint32(cProducerHandle), uint32(cConsumerHandle)
}

func (c *CGoSystem) CreateDataPipe(flags, elementNumBytes, capacityNumBytes uint32) (result uint32, producerHandle, consumerHandle uint32) {
	var opts *C.struct_MojoCreateDataPipeOptions
	opts = &C.struct_MojoCreateDataPipeOptions{
		C.uint32_t(unsafe.Sizeof(*opts)),
		C.MojoCreateDataPipeOptionsFlags(flags),
		C.uint32_t(elementNumBytes),
		C.uint32_t(capacityNumBytes),
	}
	return createDataPipeWithCOptions(opts)
}

func (c *CGoSystem) CreateDataPipeWithDefaultOptions() (result uint32, producerHandle, consumerHandle uint32) {
	// A nil options pointer in the C interface means use the default values.
	return createDataPipeWithCOptions(nil)
}

func (c *CGoSystem) WriteData(producerHandle uint32, buf []byte, flags uint32) (result uint32, bytesWritten uint32) {
	numBytes := C.uint32_t(len(buf))
	r := C.MojoWriteData(C.MojoHandle(producerHandle), unsafe.Pointer(&buf[0]), &numBytes, C.MojoWriteDataFlags(flags))
	return uint32(r), uint32(numBytes)
}

func (c *CGoSystem) BeginWriteData(producerHandle uint32, flags uint32) (result uint32, buf []byte) {
	var buffer unsafe.Pointer
	var bufferNumBytes C.uint32_t
	r := C.MojoBeginWriteData(C.MojoHandle(producerHandle), &buffer, &bufferNumBytes, C.MojoWriteDataFlags(flags))
	if r != C.MOJO_RESULT_OK {
		return uint32(r), nil
	}
	return uint32(r), unsafeByteSlice(buffer, int(bufferNumBytes))
}

func (c *CGoSystem) EndWriteData(producerHandle uint32, numBytesWritten uint32) (result uint32) {
	return uint32(C.MojoEndWriteData(C.MojoHandle(producerHandle), C.uint32_t(numBytesWritten)))
}

func (c *CGoSystem) ReadData(consumerHandle uint32, flags uint32) (result uint32, buf []byte) {
	var numBytes C.uint32_t
	if r := C.MojoReadData(C.MojoHandle(consumerHandle), nil, &numBytes, C.MOJO_READ_DATA_FLAG_QUERY); r != C.MOJO_RESULT_OK {
		return uint32(r), nil
	}
	if numBytes == 0 {
		return uint32(C.MOJO_RESULT_OK), nil
	}
	buf = make([]byte, int(numBytes))
	r := C.MojoReadData(C.MojoHandle(consumerHandle), unsafe.Pointer(&buf[0]), &numBytes, C.MojoReadDataFlags(flags))
	buf = buf[0:int(numBytes)]
	return uint32(r), buf
}

func (c *CGoSystem) BeginReadData(consumerHandle uint32, flags uint32) (result uint32, buf []byte) {
	var buffer unsafe.Pointer
	var bufferNumBytes C.uint32_t
	r := C.MojoBeginReadData(C.MojoHandle(consumerHandle), &buffer, &bufferNumBytes, C.MojoReadDataFlags(flags))
	if r != C.MOJO_RESULT_OK {
		return uint32(r), nil
	}
	return uint32(r), unsafeByteSlice(buffer, int(bufferNumBytes))
}

func (c *CGoSystem) EndReadData(consumerHandle uint32, numBytesRead uint32) (result uint32) {
	return uint32(C.MojoEndReadData(C.MojoHandle(consumerHandle), C.uint32_t(numBytesRead)))
}

func (c *CGoSystem) GetTimeTicksNow() (timestamp uint64) {
	return uint64(C.MojoGetTimeTicksNow())
}

func (c *CGoSystem) Close(handle uint32) (result uint32) {
	return uint32(C.MojoClose(C.MojoHandle(handle)))
}

func (c *CGoSystem) Wait(handle uint32, signals uint32, deadline uint64) (result uint32, satisfiedSignals, satisfiableSignals uint32) {
	var cState C.struct_MojoHandleSignalsState
	r := C.MojoWait(C.MojoHandle(handle), C.MojoHandleSignals(signals), C.MojoDeadline(deadline), &cState)
	return uint32(r), uint32(cState.satisfied_signals), uint32(cState.satisfiable_signals)
}

func (c *CGoSystem) WaitMany(handles []uint32, signals []uint32, deadline uint64) (uint32, int, []uint32, []uint32) {
	if len(handles) == 0 {
		r := C.MojoWaitMany(nil, nil, 0, C.MojoDeadline(deadline), nil, nil)
		return uint32(r), -1, nil, nil
	}
	if len(handles) != len(signals) {
		panic("number of handles and signals must match")
	}
	index := ^C.uint32_t(0) // -1
	cHandles := (*C.MojoHandle)(unsafe.Pointer(&handles[0]))
	cSignals := (*C.MojoHandleSignals)(unsafe.Pointer(&signals[0]))
	cStates := make([]C.struct_MojoHandleSignalsState, len(handles))
	r := C.MojoWaitMany(cHandles, cSignals, C.uint32_t(len(handles)), C.MojoDeadline(deadline), &index, &cStates[0])
	var satisfied, satisfiable []uint32
	if r != C.MOJO_RESULT_INVALID_ARGUMENT && r != C.MOJO_RESULT_RESOURCE_EXHAUSTED {
		satisfied = make([]uint32, len(handles))
		satisfiable = make([]uint32, len(handles))
		for i := 0; i < len(handles); i++ {
			satisfied[i] = uint32(cStates[i].satisfied_signals)
			satisfiable[i] = uint32(cStates[i].satisfiable_signals)
		}
	}
	return uint32(r), int(int32(index)), satisfied, satisfiable
}

func (c *CGoSystem) CreateMessagePipe(flags uint32) (uint32, uint32, uint32) {
	var handle0, handle1 C.MojoHandle
	var opts *C.struct_MojoCreateMessagePipeOptions
	opts = &C.struct_MojoCreateMessagePipeOptions{
		C.uint32_t(unsafe.Sizeof(*opts)),
		C.MojoCreateMessagePipeOptionsFlags(flags),
	}
	r := C.CreateMessagePipe(opts, &handle0, &handle1)
	return uint32(r), uint32(handle0), uint32(handle1)
}

func (c *CGoSystem) WriteMessage(handle uint32, bytes []byte, handles []uint32, flags uint32) (result uint32) {
	var bytesPtr unsafe.Pointer
	if len(bytes) != 0 {
		bytesPtr = unsafe.Pointer(&bytes[0])
	}
	var handlesPtr *C.MojoHandle
	if len(handles) != 0 {
		handlesPtr = (*C.MojoHandle)(unsafe.Pointer(&handles[0]))
	}
	return uint32(C.MojoWriteMessage(C.MojoHandle(handle), bytesPtr, C.uint32_t(len(bytes)), handlesPtr, C.uint32_t(len(handles)), C.MojoWriteMessageFlags(flags)))
}

func (c *CGoSystem) ReadMessage(handle uint32, flags uint32) (result uint32, buf []byte, handles []uint32) {
	var numBytes, numHandles C.uint32_t
	cHandle := C.MojoHandle(handle)
	cFlags := C.MojoReadMessageFlags(flags)
	if r := C.MojoReadMessage(cHandle, nil, &numBytes, nil, &numHandles, cFlags); r != C.MOJO_RESULT_RESOURCE_EXHAUSTED {
		return uint32(r), nil, nil
	}
	var bufPtr unsafe.Pointer
	if numBytes != 0 {
		buf = make([]byte, int(numBytes))
		bufPtr = unsafe.Pointer(&buf[0])
	}
	var handlesPtr *C.MojoHandle
	if numHandles != 0 {
		handles = make([]uint32, int(numHandles))
		handlesPtr = (*C.MojoHandle)(unsafe.Pointer(&handles[0]))
	}
	r := C.MojoReadMessage(cHandle, bufPtr, &numBytes, handlesPtr, &numHandles, cFlags)
	return uint32(r), buf, handles
}

func unsafeByteSlice(ptr unsafe.Pointer, length int) []byte {
	return (*[^uint32(0) / 8]byte)(ptr)[:length:length]
}