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

#include <trcRecorder.h>

#if ( TRC_USE_TRACEALYZER_RECORDER == 1 )

    #if ( TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_STREAMING )

        #define VALIDATE_ENTRY_HANDLE( xEntryHandle )    ( ( ( ( TraceUnsignedBaseType_t ) ( xEntryHandle ) >= ( TraceUnsignedBaseType_t ) pxEntryTable ) && ( ( TraceUnsignedBaseType_t ) ( xEntryHandle ) < ( ( TraceUnsignedBaseType_t ) pxEntryTable + sizeof( TraceEntryTable_t ) ) ) ) )

        #define GIVE_ENTRY_INDEX( xIndex )               xIndexTable.axFreeIndexes[ xIndexTable.uiFreeIndexCount ] = ( xIndex ); xIndexTable.uiFreeIndexCount++

        #define GET_FREE_INDEX_COUNT()                   xIndexTable.uiFreeIndexCount

        #define CALCULATE_ENTRY_INDEX( xEntryHandle )    ( TraceEntryIndex_t ) ( ( ( TraceUnsignedBaseType_t ) ( ( TraceUnsignedBaseType_t ) ( xEntryHandle ) - ( TraceUnsignedBaseType_t ) pxEntryTable ) / sizeof( TraceEntry_t ) ) )

        #if ( TRC_ENTRY_TABLE_SLOTS > 256 )
            typedef uint16_t   TraceEntryIndex_t;
        #else
            typedef uint8_t    TraceEntryIndex_t;
        #endif /* (TRC_CFG_ENTRY_TABLE_SLOTS > 256) */

        typedef struct EntryIndexTable
        {
            TraceEntryIndex_t axFreeIndexes[ TRC_ENTRY_TABLE_SLOTS ];
            uint32_t uiFreeIndexCount;
        } TraceEntryIndexTable_t;

        typedef struct TraceEntryTable
        {
            uint32_t uiSlots;
            uint32_t uiEntrySymbolLength;
            uint32_t uiEntryStateCount;
            TraceEntry_t axEntries[ TRC_ENTRY_TABLE_SLOTS ];
        } TraceEntryTable_t;

/* Private function definitions */
        traceResult prvEntryIndexInitialize( TraceEntryIndexTable_t * pxIndexTable );
        traceResult prvEntryIndexTake( TraceEntryIndex_t * pxIndex );

/* Variables */
        static TraceEntryTable_t * pxEntryTable;
        static TraceEntryIndexTable_t xIndexTable;

        traceResult xTraceEntryTableInitialize( TraceEntryTableBuffer_t * pxBuffer )
        {
            uint32_t i, j;

            TRC_ASSERT_EQUAL_SIZE( TraceEntryTableBuffer_t, TraceEntryTable_t );

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

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

            pxEntryTable = ( TraceEntryTable_t * ) pxBuffer;

            pxEntryTable->uiSlots = TRC_ENTRY_TABLE_SLOTS;
            pxEntryTable->uiEntrySymbolLength = TRC_ENTRY_TABLE_SLOT_SYMBOL_SIZE;
            pxEntryTable->uiEntryStateCount = TRC_ENTRY_TABLE_STATE_COUNT;

            for( i = 0; i < TRC_ENTRY_TABLE_SLOTS; i++ )
            {
                pxEntryTable->axEntries[ i ].pvAddress = 0;

                for( j = 0; j < TRC_ENTRY_TABLE_STATE_COUNT; j++ )
                {
                    pxEntryTable->axEntries[ i ].xStates[ j ] = 0;
                }

                pxEntryTable->axEntries[ i ].szSymbol[ 0 ] = 0;
            }

            prvEntryIndexInitialize( &xIndexTable );

            xTraceSetComponentInitialized( TRC_RECORDER_COMPONENT_ENTRY );

            return TRC_SUCCESS;
        }

        traceResult xTraceEntryCreate( TraceEntryHandle_t * pxEntryHandle )
        {
            uint32_t i;
            TraceEntryIndex_t xIndex;
            TraceEntry_t * pxEntry;

            TRACE_ALLOC_CRITICAL_SECTION();

            /* We always check this */
            if( !xTraceIsComponentInitialized( TRC_RECORDER_COMPONENT_ENTRY ) )
            {
                return TRC_FAIL;
            }

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

            TRACE_ENTER_CRITICAL_SECTION();

            if( prvEntryIndexTake( &xIndex ) != TRC_SUCCESS )
            {
                xTraceDiagnosticsIncrease( TRC_DIAGNOSTICS_ENTRY_SLOTS_NO_ROOM );

                TRACE_EXIT_CRITICAL_SECTION();

                return TRC_FAIL;
            }

            pxEntry = &pxEntryTable->axEntries[ xIndex ];

            pxEntry->pvAddress = ( void * ) pxEntry; /* We set a temporary address */

            for( i = 0; i < TRC_ENTRY_TABLE_STATE_COUNT; i++ )
            {
                pxEntry->xStates[ i ] = 0;
            }

            pxEntry->uiOptions = 0;
            pxEntry->szSymbol[ 0 ] = 0;

            *pxEntryHandle = ( TraceEntryHandle_t ) pxEntry;

            TRACE_EXIT_CRITICAL_SECTION();

            return TRC_SUCCESS;
        }

        traceResult xTraceEntryDelete( TraceEntryHandle_t xEntryHandle )
        {
            TraceEntryIndex_t xIndex;

            TRACE_ALLOC_CRITICAL_SECTION();

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

            /* This should never fail */
            TRC_ASSERT( VALIDATE_ENTRY_HANDLE( xEntryHandle ) );

            /* Calculate the index based on the entry address */
            /* Does not need to be locked. */
            /* This should never fail */
            xIndex = CALCULATE_ENTRY_INDEX( xEntryHandle );

            TRC_ASSERT( xIndex < TRC_ENTRY_TABLE_SLOTS );

            TRACE_ENTER_CRITICAL_SECTION();

            if( ( ( TraceEntry_t * ) xEntryHandle )->pvAddress == 0 )
            {
                /* Someone else has deleted this already? */
                TRACE_EXIT_CRITICAL_SECTION();

                return TRC_FAIL;
            }

            /* A valid address, so we assume it is OK. */
            /* For good measure, we clear the address field */
            ( ( TraceEntry_t * ) xEntryHandle )->pvAddress = 0;

            /* Give back the index */
            GIVE_ENTRY_INDEX( xIndex );

            TRACE_EXIT_CRITICAL_SECTION();

            return TRC_SUCCESS;
        }

        traceResult xTraceEntryFind( void * pvAddress,
                                     TraceEntryHandle_t * pxEntryHandle )
        {
            uint32_t i;
            TraceEntry_t * pxEntry;

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

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

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

            for( i = 0; i < TRC_ENTRY_TABLE_SLOTS; i++ )
            {
                pxEntry = ( TraceEntry_t * ) ( ( ( uint32_t ) pxEntryTable->axEntries ) + ( i * sizeof( TraceEntry_t ) ) );

                if( pxEntry->pvAddress == pvAddress )
                {
                    *pxEntryHandle = ( TraceEntryHandle_t ) pxEntry;

                    return TRC_SUCCESS;
                }
            }

            return TRC_FAIL;
        }

        traceResult xTraceEntrySetSymbol( TraceEntryHandle_t xEntryHandle,
                                          const char * szSymbol )
        {
            uint32_t i;

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

            if( szSymbol == 0 )
            {
                szSymbol = "";
            }

            /* Does not need to be locked. */
            /* This should never fail */
            TRC_ASSERT( VALIDATE_ENTRY_HANDLE( xEntryHandle ) );

            for( i = 0; i < ( TRC_ENTRY_TABLE_SYMBOL_LENGTH ); i++ )
            {
                ( ( TraceEntry_t * ) xEntryHandle )->szSymbol[ i ] = szSymbol[ i ]; /* We do this first to ensure we also get the 0 termination, if there is one */

                if( szSymbol[ i ] == 0 )
                {
                    break;
                }
            }

            /* Check the length of "name", if longer than TRC_ENTRY_TABLE_SYMBOL_LENGTH */
            while( ( szSymbol[ i ] != 0 ) && i < 128 )
            {
                i++;
            }

            /* Remember the longest symbol name */
            xTraceDiagnosticsSetIfHigher( TRC_DIAGNOSTICS_ENTRY_SYMBOL_LONGEST_LENGTH, i );

            return TRC_SUCCESS;
        }

        traceResult xTraceEntryGetCount( uint32_t * puiCount )
        {
            /* This should never fail */
            TRC_ASSERT( xTraceIsComponentInitialized( TRC_RECORDER_COMPONENT_ENTRY ) );

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

            *puiCount = TRC_ENTRY_TABLE_SLOTS - GET_FREE_INDEX_COUNT();

            return TRC_SUCCESS;
        }

        traceResult xTraceEntryGetAtIndex( uint32_t index,
                                           TraceEntryHandle_t * pxEntryHandle )
        {
            /* This should never fail */
            TRC_ASSERT( xTraceIsComponentInitialized( TRC_RECORDER_COMPONENT_ENTRY ) );

            /* This should never fail */
            TRC_ASSERT( index < TRC_ENTRY_TABLE_SLOTS );

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

            *pxEntryHandle = ( TraceEntryHandle_t ) ( ( uint32_t ) ( pxEntryTable->axEntries ) + ( index * sizeof( TraceEntry_t ) ) );

            return TRC_SUCCESS;
        }

        #if ( ( TRC_CFG_USE_TRACE_ASSERT ) == 1 )

            traceResult xTraceEntryCreateWithAddress( void * pvAddress,
                                                      TraceEntryHandle_t * pxEntryHandle )
            {
                /* This should never fail */
                TRC_ASSERT( pvAddress != 0 );

                return TRC_ENTRY_CREATE_WITH_ADDRESS( pvAddress, pxEntryHandle );
            }

            traceResult xTraceEntrySetState( TraceEntryHandle_t xEntryHandle,
                                             uint32_t uiStateIndex,
                                             TraceUnsignedBaseType_t uxState )
            {
                /* This should never fail */
                TRC_ASSERT( xTraceIsComponentInitialized( TRC_RECORDER_COMPONENT_ENTRY ) );

                /* This should never fail */
                TRC_ASSERT( uiStateIndex < ( TRC_ENTRY_TABLE_STATE_COUNT ) );

                /* This should never fail */
                TRC_ASSERT( VALIDATE_ENTRY_HANDLE( xEntryHandle ) );

                return TRC_ENTRY_SET_STATE( xEntryHandle, uiStateIndex, uxState );
            }

            traceResult xTraceEntrySetOptions( TraceEntryHandle_t xEntryHandle,
                                               uint32_t uiMask )
            {
                /* This should never fail */
                TRC_ASSERT( xTraceIsComponentInitialized( TRC_RECORDER_COMPONENT_ENTRY ) );

                /* Does not need to be locked. */
                /* This should never fail */
                TRC_ASSERT( VALIDATE_ENTRY_HANDLE( xEntryHandle ) );

                return TRC_ENTRY_SET_OPTIONS( xEntryHandle, uiMask );
            }

            traceResult xTraceEntryClearOptions( TraceEntryHandle_t xEntryHandle,
                                                 uint32_t uiMask )
            {
                /* This should never fail */
                TRC_ASSERT( xTraceIsComponentInitialized( TRC_RECORDER_COMPONENT_ENTRY ) );

                /* Does not need to be locked. */
                /* This should never fail */
                TRC_ASSERT( VALIDATE_ENTRY_HANDLE( xEntryHandle ) );

                return TRC_ENTRY_CLEAR_OPTIONS( xEntryHandle, uiMask );
            }

            traceResult xTraceEntryGetAddress( TraceEntryHandle_t xEntryHandle,
                                               void ** ppvAddress )
            {
                /* This should never fail */
                TRC_ASSERT( xTraceIsComponentInitialized( TRC_RECORDER_COMPONENT_ENTRY ) );

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

                /* Does not need to be locked. */
                /* This should never fail */
                TRC_ASSERT( VALIDATE_ENTRY_HANDLE( xEntryHandle ) );

                return TRC_ENTRY_GET_ADDRESS( xEntryHandle, ppvAddress );
            }

            traceResult xTraceEntryGetSymbol( TraceEntryHandle_t xEntryHandle,
                                              const char ** pszSymbol )
            {
                /* This should never fail */
                TRC_ASSERT( xTraceIsComponentInitialized( TRC_RECORDER_COMPONENT_ENTRY ) );

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

                /* Does not need to be locked. */
                /* This should never fail */
                TRC_ASSERT( VALIDATE_ENTRY_HANDLE( xEntryHandle ) );

                return TRC_ENTRY_GET_SYMBOL( xEntryHandle, pszSymbol );
            }

            traceResult xTraceEntryGetState( TraceEntryHandle_t xEntryHandle,
                                             uint32_t uiStateIndex,
                                             TraceUnsignedBaseType_t * puxState )
            {
                /* This should never fail */
                TRC_ASSERT( xTraceIsComponentInitialized( TRC_RECORDER_COMPONENT_ENTRY ) );

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

                /* This should never fail */
                TRC_ASSERT( uiStateIndex < TRC_ENTRY_TABLE_STATE_COUNT );

                /* Does not need to be locked. */
                /* This should never fail */
                TRC_ASSERT( VALIDATE_ENTRY_HANDLE( xEntryHandle ) );

                return TRC_ENTRY_GET_STATE( xEntryHandle, uiStateIndex, puxState );
            }

            traceResult xTraceEntryGetOptions( TraceEntryHandle_t xEntryHandle,
                                               uint32_t * puiOptions )
            {
                /* This should never fail */
                TRC_ASSERT( xTraceIsComponentInitialized( TRC_RECORDER_COMPONENT_ENTRY ) );

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

                /* Does not need to be locked. */
                /* This should never fail */
                TRC_ASSERT( VALIDATE_ENTRY_HANDLE( xEntryHandle ) );

                return TRC_ENTRY_GET_OPTIONS( xEntryHandle, puiOptions );
            }

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

/* PRIVATE FUNCTIONS */

        traceResult prvEntryIndexInitialize( TraceEntryIndexTable_t * pxIndexTable )
        {
            uint32_t i;

            for( i = 0; i < TRC_ENTRY_TABLE_SLOTS; i++ )
            {
                pxIndexTable->axFreeIndexes[ i ] = ( TraceEntryIndex_t ) i;
            }

            xIndexTable.uiFreeIndexCount = TRC_ENTRY_TABLE_SLOTS;

            return TRC_SUCCESS;
        }

        traceResult prvEntryIndexTake( TraceEntryIndex_t * pxIndex )
        {
            /* Critical Section must be active! */
            TraceEntryIndex_t xIndex;

            if( xIndexTable.uiFreeIndexCount == 0 )
            {
                return TRC_FAIL;
            }

            /* Always take the first item */
            xIndex = xIndexTable.axFreeIndexes[ 0 ];
            xIndexTable.uiFreeIndexCount--;

            /* Move the last item to the first slot, to avoid holes */
            xIndexTable.axFreeIndexes[ 0 ] = xIndexTable.axFreeIndexes[ xIndexTable.uiFreeIndexCount ];

            #if ( TRC_ENTRY_TABLE_SLOTS > 256 )
                xIndexTable.axFreeIndexes[ xIndexTable.uiFreeIndexCount ] = UINT16_MAX;
            #else
                xIndexTable.axFreeIndexes[ xIndexTable.uiFreeIndexCount ] = UINT8_MAX;
            #endif

            *pxIndex = xIndex;
            return TRC_SUCCESS;
        }

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

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