#include <string.h>

#include "trcRecorder.h"
#include "r_sci_rx_if.h"
#include "r_sci_rx_pinset.h"

#if (TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_STREAMING)
#if (TRC_USE_TRACEALYZER_RECORDER == 1)

static uint8_t string[1024];
static uint8_t sci_buffer[1024];
static uint32_t sci_current_received_size = 0;
static volatile uint32_t wait_sending = 0;

extern sci_hdl_t sci_handle_tracealyzer;

void sci_callback_tracealyzer(void *arg);

traceResult xTraceStreamPortInitialize(TraceStreamPortBuffer_t* pxBuffer)
{
	TRC_ASSERT_EQUAL_SIZE(TraceStreamPortBuffer_t, TraceStreamPortUSBBuffers_t);

	if (pxBuffer == 0)
	{
		return TRC_FAIL;
	}

	return xTraceInternalEventBufferInitialize(pxBuffer->buffer, sizeof(pxBuffer->buffer));
}

traceResult prvTraceUARTTransmit(void* pvData, uint32_t uiSize, int32_t* piBytesSent)
{
	int32_t error_code = -1;

	while(1)
	{
		if(wait_sending)
		{
			xTraceKernelPortDelay(1);
		}
		else
		{
			break;
		}
	}

	if(uiSize < sizeof(string))
	{
		memcpy(string, pvData, uiSize);
		if(SCI_SUCCESS == R_SCI_Send(sci_handle_tracealyzer, string, uiSize))
		{
			wait_sending = 1;
			*piBytesSent = uiSize;
			error_code = 0;
		}
	}
	return error_code;
}

traceResult prvTraceUARTReceive(void* data, uint32_t uiSize, int32_t* piBytesReceived)
{
	if(sci_current_received_size == uiSize)
	{
		memcpy(data, sci_buffer, sci_current_received_size);
		*piBytesReceived = sci_current_received_size;
		sci_current_received_size = 0;
	}
	return 0;
}

void sci_callback_tracealyzer(void *arg)
{
	sci_cb_args_t   *p_args;
	p_args = (sci_cb_args_t *)arg;

	if (SCI_EVT_RX_CHAR == p_args->event)
	{
		R_SCI_Receive(p_args->hdl, &sci_buffer[sci_current_received_size], 1);
		if(sci_current_received_size == (sizeof(sci_buffer) - 1)) /* -1 means string terminator after "\n" */
		{
			sci_current_received_size = 0;
		}
		else
		{
			sci_current_received_size++;
		}
	}
	else if(SCI_EVT_TEI == p_args->event)
	{
		wait_sending = 0;
	}
}

#ifndef TRC_STREAM_PORT_CONFIG_H
#define TRC_STREAM_PORT_CONFIG_H

#ifdef __cplusplus
extern "C" {
#endif

/*******************************************************************************
* Configuration Macro: TRC_CFG_STREAM_PORT_INTERNAL_BUFFER_SIZE
*
* Specifies the size of the internal buffer.
******************************************************************************/
#define TRC_CFG_STREAM_PORT_INTERNAL_BUFFER_SIZE 1024

#ifdef __cplusplus
}
#endif

#endif /* TRC_STREAM_PORT_CONFIG_H */

#ifndef TRC_STREAM_PORT_H
#define TRC_STREAM_PORT_H

#include <trcTypes.h>
#include <trcStreamPortConfig.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef struct TraceStreamPortBuffer
{
	uint8_t buffer[(TRC_CFG_STREAM_PORT_INTERNAL_BUFFER_SIZE) + sizeof(TraceUnsignedBaseType_t)];
} TraceStreamPortBuffer_t;

traceResult prvTraceUARTReceive(void* data, uint32_t uiSize, int32_t* piBytesReceived);

traceResult prvTraceUARTTransmit(void* pvData, uint32_t uiSize, int32_t* piBytesSent);

/**
 * @internal Stream port initialize callback.
 *
 * This function is called by the recorder as part of its initialization phase.
 *
 * @param[in] pxBuffer Buffer
 *
 * @retval TRC_FAIL Initialization failed
 * @retval TRC_SUCCESS Success
 */
traceResult xTraceStreamPortInitialize(TraceStreamPortBuffer_t* pxBuffer);

/**
 * @brief Allocates data from the stream port.
 *
 * @param[in] uiSize Allocation size
 * @param[out] ppvData Allocation data pointer
 *
 * @retval TRC_FAIL Allocate failed
 * @retval TRC_SUCCESS Success
 */
#define xTraceStreamPortAllocate(uiSize, ppvData) ((void)uiSize, xTraceStaticBufferGet(ppvData))

/**
 * @brief Commits data to the stream port, depending on the implementation/configuration of the
 * stream port this data might be directly written to the stream port interface, buffered, or
 * something else.
 *
 * @param[in] pvData Data to commit
 * @param[in] uiSize Data to commit size
 * @param[out] piBytesCommitted Bytes committed
 *
 * @retval TRC_FAIL Commit failed
 * @retval TRC_SUCCESS Success
 */
#define xTraceStreamPortCommit xTraceInternalEventBufferPush

/**
 * @brief Writes data through the stream port interface.
 *
 * @param[in] pvData Data to write
 * @param[in] uiSize Data to write size
 * @param[out] piBytesWritten Bytes written
 *
 * @retval TRC_FAIL Write failed
 * @retval TRC_SUCCESS Success
 */
#define xTraceStreamPortWriteData prvTraceUARTTransmit

/**
 * @brief Reads data through the stream port interface.
 *
 * @param[in] pvData Destination data buffer
 * @param[in] uiSize Destination data buffer size
 * @param[out] piBytesRead Bytes read
 *
 * @retval TRC_FAIL Read failed
 * @retval TRC_SUCCESS Success
 */
#define xTraceStreamPortReadData prvTraceUARTReceive

#define xTraceStreamPortOnEnable(uiStartOption) ((void)(uiStartOption), TRC_SUCCESS)

#define xTraceStreamPortOnDisable() (TRC_SUCCESS)

#define xTraceStreamPortOnTraceBegin() (TRC_SUCCESS)

#define xTraceStreamPortOnTraceEnd() (TRC_SUCCESS)

#ifdef __cplusplus
}
#endif

#endif /* TRC_STREAM_PORT_H */

    /* As this port allows interrupt nesting... */
        static int32_t set_interrupt_mask_from_isr( void );
        static int32_t set_interrupt_mask_from_isr( void )
        {
        	int32_t tmp = __get_ipl();
        	__set_ipl( ( long ) configMAX_SYSCALL_INTERRUPT_PRIORITY );
        	return tmp;
        }
        #define portSET_INTERRUPT_MASK_FROM_ISR()                              set_interrupt_mask_from_isr()
        #define portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus )    set_ipl( ( long ) uxSavedInterruptStatus )

#include "r_sci_rx_if.h"
#include "r_sci_rx_pinset.h"

static sci_cfg_t my_sci_config;
sci_hdl_t sci_handle_tracealyzer;

extern void sci_callback_tracealyzer(void *arg);

void Processing_Before_Start_Kernel(void)
{
    BaseType_t ret;

    /* Create all other application tasks here */
    /* Set up the configuration data structure for asynchronous (UART) operation. */
    my_sci_config.async.baud_rate    = 921600;
    my_sci_config.async.clk_src      = SCI_CLK_INT;
    my_sci_config.async.data_size    = SCI_DATA_8BIT;
    my_sci_config.async.parity_en    = SCI_PARITY_OFF;
    my_sci_config.async.parity_type  = SCI_EVEN_PARITY;
    my_sci_config.async.stop_bits    = SCI_STOPBITS_1;
    my_sci_config.async.int_priority = 15; /* disable 0 - low 1 - 15 high */

    R_SCI_Open(SCI_CH7, SCI_MODE_ASYNC, &my_sci_config, sci_callback_tracealyzer, &sci_handle_tracealyzer);
    R_SCI_PinSet_SCI7();

    xTraceInitialize();

void main_task(void *pvParameters)
{
	xTraceEnable(TRC_START);
	/* Create all other application tasks here */
	while(1)
	{
		vTaskDelay(10);
	}
	vTaskDelete(NULL);
}