/*
* Percepio Trace Recorder for Tracealyzer v4.6.0
* Copyright 2021 Percepio AB
* www.percepio.com
*
* SPDX-License-Identifier: Apache-2.0
*
* The implementation for events.
*/

#include <trcRecorder.h>

#if (TRC_USE_TRACEALYZER_RECORDER == 1)

#if (TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_STREAMING)

#define VERIFY_EVENT_SIZE(i) \
	if ((i) > (TRC_MAX_BLOB_SIZE)) \
	{ \
		xTraceDiagnosticsSetIfHigher(TRC_DIAGNOSTICS_BLOB_MAX_BYTES_TRUNCATED, (TraceUnsignedBaseType_t)((i) - (TRC_MAX_BLOB_SIZE))); \
		(i) = TRC_MAX_BLOB_SIZE; \
	}

TraceEventDataTable_t *pxTraceEventDataTable;

int32_t DUMMY_iTraceBytesCommitted;

TRACE_ALLOC_CRITICAL_SECTION();

traceResult xTraceEventInitialize(TraceEventDataBuffer_t* pxBuffer)
{
	TraceCoreEventData_t* pxCoreEventData;
	uint32_t i, j;

	TRC_ASSERT_EQUAL_SIZE(TraceEventDataBuffer_t, TraceEventDataTable_t);

	/* This should never fail */
	TRC_ASSERT(pxBuffer != 0);

	pxTraceEventDataTable = (TraceEventDataTable_t*)pxBuffer;

	for (i = 0; i < TRC_CFG_CORE_COUNT; i++)
	{
		pxCoreEventData = &pxTraceEventDataTable->coreEventData[i];

		pxCoreEventData->eventCounter = 0;

		for (j = 0; j < (TRC_CFG_MAX_ISR_NESTING) + 1; j++)
		{
			RESET_EVENT_DATA(&pxCoreEventData->eventData[j]);
		}
	}

	xTraceSetComponentInitialized(TRC_RECORDER_COMPONENT_EVENT);

	return TRC_SUCCESS;
}

traceResult xTraceEventBeginRawOffline(uint32_t uiSize, TraceEventHandle_t* pxEventHandle)
{
	TraceEventData_t* pxEventData;
	int32_t ISR_nesting;

	/* We need to check this */
	if (!xTraceIsComponentInitialized(TRC_RECORDER_COMPONENT_EVENT))
	{
		return TRC_FAIL;
	}

	/* This should never fail */
	TRC_ASSERT(pxEventHandle != 0);

	TRACE_ENTER_CRITICAL_SECTION();

	xTraceISRGetCurrentNesting(&ISR_nesting);

	/* We add 1 since xTraceISRGetCurrentNesting(...) returns -1 if no ISR is active */
	pxEventData = &pxTraceEventDataTable->coreEventData[TRC_CFG_GET_CURRENT_CORE()].eventData[ISR_nesting + 1];

	/* This should never fail */
	TRC_ASSERT_CUSTOM_ON_FAIL(pxEventData->pvBlob == 0, TRACE_EXIT_CRITICAL_SECTION(); return TRC_FAIL; );

	VERIFY_EVENT_SIZE(uiSize);

	pxEventData->size = ((uiSize + (sizeof(uint32_t) - 1)) / sizeof(uint32_t)) * sizeof(uint32_t);	/* 4-byte align */

	pxEventData->offset = 0;

	/* This can fail and we should handle it */
	if (xTraceStreamPortAllocate(pxEventData->size, &pxEventData->pvBlob) == TRC_FAIL)
	{
		TRACE_EXIT_CRITICAL_SECTION();
		return TRC_FAIL;
	}

	*pxEventHandle = (TraceEventHandle_t)pxEventData;

	return TRC_SUCCESS;
}

traceResult xTraceEventBeginRawOfflineBlocking(uint32_t uiSize, TraceEventHandle_t* pxEventHandle)
{
	TraceEventData_t* pxEventData;
	int32_t ISR_nesting;
	uint32_t uiAttempts = 0;

	/* We need to check this */
	if (!xTraceIsComponentInitialized(TRC_RECORDER_COMPONENT_EVENT))
	{
		return TRC_FAIL;
	}

	/* This should never fail */
	TRC_ASSERT(pxEventHandle != 0);

	TRACE_ENTER_CRITICAL_SECTION();

	xTraceGetCurrentISRNesting(&ISR_nesting);

	/* We add 1 since xTraceISRGetCurrentNesting(...) returns -1 if no ISR is active */
	pxEventData = &pxTraceEventDataTable->coreEventData[TRC_CFG_GET_CURRENT_CORE()].eventData[ISR_nesting + 1];

	/* This should never fail */
	TRC_ASSERT_CUSTOM_ON_FAIL(pxEventData->pvBlob == 0, TRACE_EXIT_CRITICAL_SECTION(); return TRC_FAIL; );

	VERIFY_EVENT_SIZE(uiSize);

	pxEventData->size = ((uiSize + (sizeof(uint32_t) - 1)) / sizeof(uint32_t)) * sizeof(uint32_t);	/* 4-byte align */

	pxEventData->offset = 0;

	/* This can fail and we should handle it */
	while (xTraceStreamPortAllocate(pxEventData->size, &pxEventData->pvBlob) != TRC_SUCCESS)
	{
		uiAttempts++;
	}

	*pxEventHandle = (TraceEventHandle_t)pxEventData;

	return TRC_SUCCESS;
}

traceResult xTraceEventEndOffline(TraceEventHandle_t xEventHandle)
{
	int32_t iBytesCommitted;

	/* This should never fail */
	TRC_ASSERT(xTraceIsComponentInitialized(TRC_RECORDER_COMPONENT_EVENT));

	/* This should never fail */
	TRC_ASSERT(xEventHandle != 0);

	/* This should never fail */
	TRC_ASSERT(((TraceEventData_t*)xEventHandle)->pvBlob != 0);

	xTraceStreamPortCommit(((TraceEventData_t*)xEventHandle)->pvBlob, ((TraceEventData_t*)xEventHandle)->size, &iBytesCommitted);

	RESET_EVENT_DATA((TraceEventData_t*)xEventHandle);

	TRACE_EXIT_CRITICAL_SECTION();

	return TRC_SUCCESS;
}

traceResult xTraceEventEndOfflineBlocking(TraceEventHandle_t xEventHandle)
{
	TraceEventData_t* pxEventData = (TraceEventData_t*)xEventHandle;
	int32_t iBytesCommitted;

	/* This should never fail */
	TRC_ASSERT(xTraceIsComponentInitialized(TRC_RECORDER_COMPONENT_EVENT));

	/* This should never fail */
	TRC_ASSERT(pxEventData != 0);

	while (pxEventData->size > 0)
	{
		iBytesCommitted = 0;
		xTraceStreamPortCommit(pxEventData->pvBlob, pxEventData->size, &iBytesCommitted);

		pxEventData->size -= iBytesCommitted;
		pxEventData->pvBlob = ((uint8_t*)pxEventData->pvBlob) + iBytesCommitted;
	}

	RESET_EVENT_DATA(pxEventData);

	TRACE_EXIT_CRITICAL_SECTION();

	return TRC_SUCCESS;
}

traceResult xTraceEventAddData(TraceEventHandle_t xEventHandle, void* pvData, uint32_t uiSize)
{
	uint32_t i;

	/* This should never fail */
	TRC_ASSERT(xTraceIsComponentInitialized(TRC_RECORDER_COMPONENT_EVENT));

	/* This should never fail */
	TRC_ASSERT(xEventHandle != 0);

	/* This should never fail */
	TRC_ASSERT(pvData != 0);

	/* This should never fail */
	TRC_ASSERT(((TraceEventData_t*)xEventHandle)->offset + uiSize <= ((TraceEventData_t*)xEventHandle)->size);

	for (i = 0; i < uiSize; i++)
	{
		TRC_EVENT_ADD_8(xEventHandle, ((uint8_t*)pvData)[i]);
	}

	return TRC_SUCCESS;
}

#if ((TRC_CFG_USE_TRACE_ASSERT) == 1)

traceResult xTraceEventGetSize(void *pvAddress, uint32_t* puiSize)
{
	/* This should never fail */
	TRC_ASSERT(pvAddress != 0);
	
	/* This should never fail */
	TRC_ASSERT(puiSize != 0);

	/* This should never fail */
	TRC_ASSERT((sizeof(TraceBaseEvent_t) + (TRC_EVENT_GET_PARAM_COUNT(((TraceBaseEvent_t*)pvAddress)->EventID)) * sizeof(uint32_t)) <= TRC_MAX_BLOB_SIZE);
	
	return TRC_EVENT_GET_SIZE(pvAddress, puiSize);
}

traceResult xTraceEventGetRawData(TraceEventHandle_t xEventHandle, uint32_t uiOffset, uint32_t uiSize, void** ppvData)
{
	/* This should never fail */
	TRC_ASSERT(xTraceIsComponentInitialized(TRC_RECORDER_COMPONENT_EVENT));

	/* This should never fail */
	TRC_ASSERT(xEventHandle != 0);

	/* This should never fail */
	TRC_ASSERT(ppvData != 0);

	/* This should never fail */
	TRC_ASSERT(uiOffset + uiSize <= ((TraceEventData_t*)xEventHandle)->size);

	return TRC_EVENT_GET_RAW_DATA(xEventHandle, uiOffset, uiSize, ppvData);
}

traceResult xTraceEventGetPayload(TraceEventHandle_t xEventHandle, uint32_t uiOffset, uint32_t uiSize, void** ppvData)
{
	/* This should never fail */
	TRC_ASSERT(xTraceIsComponentInitialized(TRC_RECORDER_COMPONENT_EVENT));

	/* This should never fail */
	TRC_ASSERT(xEventHandle != 0);

	/* This should never fail */
	TRC_ASSERT(ppvData != 0);

	/* This should never fail */
	TRC_ASSERT(uiOffset + uiSize <= ((TraceEventData_t*)xEventHandle)->size);

	return TRC_EVENT_GET_PAYLOAD(xEventHandle, uiOffset, uiSize, ppvData);
}

traceResult xTraceEventPayloadRemaining(TraceEventHandle_t xEventHandle, uint32_t* puiValue)
{
	/* This should never fail */
	TRC_ASSERT(xTraceIsComponentInitialized(TRC_RECORDER_COMPONENT_EVENT));

	/* This should never fail */
	TRC_ASSERT(xEventHandle != 0);

	/* This should never fail */
	TRC_ASSERT(puiValue != 0);

	/* This should never fail */
	TRC_ASSERT(((TraceEventData_t*)xEventHandle)->pvBlob != 0);

	return TRC_EVENT_PAYLOAD_REMAINING(xEventHandle, puiValue);
}

traceResult xTraceEventPayloadUsed(TraceEventHandle_t xEventHandle, uint32_t* puiValue)
{
	/* This should never fail */
	TRC_ASSERT(xTraceIsComponentInitialized(TRC_RECORDER_COMPONENT_EVENT));

	/* This should never fail */
	TRC_ASSERT(xEventHandle != 0);

	/* This should never fail */
	TRC_ASSERT(puiValue != 0);

	/* This should never fail */
	TRC_ASSERT(((TraceEventData_t*)xEventHandle)->pvBlob != 0);

	return TRC_EVENT_PAYLOAD_USED(xEventHandle, puiValue);
}

traceResult xTraceEventPayloadSize(TraceEventHandle_t xEventHandle, uint32_t* puiValue)
{
	/* This should never fail */
	TRC_ASSERT(xTraceIsComponentInitialized(TRC_RECORDER_COMPONENT_EVENT));

	/* This should never fail */
	TRC_ASSERT(xEventHandle != 0);

	/* This should never fail */
	TRC_ASSERT(puiValue != 0);

	/* This should never fail */
	TRC_ASSERT(((TraceEventData_t*)xEventHandle)->pvBlob != 0);

	return TRC_EVENT_PAYLOAD_SIZE(xEventHandle, puiValue);
}

traceResult xTraceEventAddPointer(TraceEventHandle_t xEventHandle, void* pvAddress)
{
	/* This should never fail */
	TRC_ASSERT(xTraceIsComponentInitialized(TRC_RECORDER_COMPONENT_EVENT));

	/* This should never fail */
	TRC_ASSERT(xEventHandle != 0);

	/* This should never fail */
	TRC_ASSERT(((TraceEventData_t*)xEventHandle)->offset + sizeof(void*) <= ((TraceEventData_t*)xEventHandle)->size);

	/* Make sure we are writing at void* aligned offset */
	/* This should never fail */
	TRC_ASSERT((((TraceEventData_t*)xEventHandle)->offset & (sizeof(void*) - 1)) == 0);

	return TRC_EVENT_ADD_POINTER(xEventHandle, pvAddress);
}

traceResult xTraceEventAddUnsignedBaseType(TraceEventHandle_t xEventHandle, TraceUnsignedBaseType_t uxValue)
{
	/* This should never fail */
	TRC_ASSERT(xTraceIsComponentInitialized(TRC_RECORDER_COMPONENT_EVENT));

	/* This should never fail */
	TRC_ASSERT(xEventHandle != 0);

	/* This should never fail */
	TRC_ASSERT(((TraceEventData_t*)xEventHandle)->offset + sizeof(TraceUnsignedBaseType_t) <= ((TraceEventData_t*)xEventHandle)->size);

	/* Make sure we are writing at TraceUnsignedBaseType_t aligned offset */
	/* This should never fail */
	TRC_ASSERT((((TraceEventData_t*)xEventHandle)->offset & (sizeof(TraceUnsignedBaseType_t) - 1)) == 0);

	return TRC_EVENT_ADD_UNSIGNED_BASE_TYPE(xEventHandle, uxValue);
}

traceResult xTraceEventAdd32(TraceEventHandle_t xEventHandle, uint32_t value)
{
	/* This should never fail */
	TRC_ASSERT(xTraceIsComponentInitialized(TRC_RECORDER_COMPONENT_EVENT));

	/* This should never fail */
	TRC_ASSERT(xEventHandle != 0);

	/* This should never fail */
	TRC_ASSERT(((TraceEventData_t*)xEventHandle)->offset + sizeof(uint32_t) <= ((TraceEventData_t*)xEventHandle)->size);

	/* Make sure we are writing at 32-bit aligned offset */
	/* This should never fail */
	TRC_ASSERT((((TraceEventData_t*)xEventHandle)->offset & 3) == 0);

	return TRC_EVENT_ADD_32(xEventHandle, value);
}

traceResult xTraceEventAdd16(TraceEventHandle_t xEventHandle, uint16_t value)
{
	/* This should never fail */
	TRC_ASSERT(xTraceIsComponentInitialized(TRC_RECORDER_COMPONENT_EVENT));

	/* This should never fail */
	TRC_ASSERT(xEventHandle != 0);

	/* This should never fail */
	TRC_ASSERT(((TraceEventData_t*)xEventHandle)->offset + sizeof(uint16_t) <= ((TraceEventData_t*)xEventHandle)->size);

	/* Make sure we are writing at 16-bit aligned offset */
	/* This should never fail */
	TRC_ASSERT((((TraceEventData_t*)xEventHandle)->offset & 1) == 0);

	return TRC_EVENT_ADD_16(xEventHandle, value);
}

traceResult xTraceEventAdd8(TraceEventHandle_t xEventHandle, uint8_t value)
{
	/* This should never fail */
	TRC_ASSERT(xTraceIsComponentInitialized(TRC_RECORDER_COMPONENT_EVENT));

	/* This should never fail */
	TRC_ASSERT(xEventHandle != 0);

	/* This should never fail */
	TRC_ASSERT(((TraceEventData_t*)xEventHandle)->offset + sizeof(uint8_t) <= ((TraceEventData_t*)xEventHandle)->size);

	return TRC_EVENT_ADD_8(xEventHandle, value);
}

#endif /* ((TRC_CFG_USE_TRACE_ASSERT) == 1) */

#endif /* (TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_STREAMING) */

#endif /* (TRC_USE_TRACEALYZER_RECORDER == 1) */