//*****************************************************************************
// (C) Automotive Lighting Reutlingen GmbH
//     Tuebinger Strasse 123, 72762 Reutlingen, Germany
//
// Automotive Lighting Reutlingen GmbH owns all the rights to this work.
// This work shall not be copied, reproduced, used, modified, transferred
// or its information shall not be disclosed without the prior written
// authorization of Automotive Lighting Reutlingen GmbH.
//*****************************************************************************

// ----------------------------------------------------------------------------
///  \file    CodM.c
///
///  \author  Sally Shen ALSH/EES (sally.shen@marelli.com)
///
///  \date    02.16.2023
///
///  \brief  Coding Manager module for Human Horizons VC1 ELM
///
///  \descr  Source: CodingTool_LDC_HHVC1_RX_XXXX.XXXX.XX.xlsm
///          For details see coding parameter
///
// ----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
//  Standard / system header file includes
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
//  Project-specific header file includes
//-----------------------------------------------------------------------------
#include <Swc/CodM/Api/CodM.h>
#include <Swc/CodM/Api/CodM_Rte.h>
#include <Crc.h>
//#include <Rte_Main.h>
#include "Rte_ctaaCodM.h"

//#define CodM_Debug
#ifdef CodM_Debug
  //#define CodM_Debug_PrintfInitTime
  //#define CodM_Debug_PrintfCrcCheckTime
  //#define CodM_Debug_CheckCodingData
#endif

#ifdef CodM_Debug
  #include "stdio.h"
  #include "Util/Time/Util_Time.h"
#endif

#ifdef CodM_Debug_PrintfInitTime
  TIMER tickStart1 = 0;
  TIMER deltaTicks1 = 0;
#endif

#ifdef CodM_Debug_PrintfCrcCheckTime
  TIMER tickStart2 = 0;
  TIMER deltaTicks2 = 0;
  boolean boDebugTimerCount2 = FALSE;
#endif

#ifdef UNIT_TEST
  STATIC_AL boolean flag_MT_CodMCycle = FALSE;
  STATIC_AL boolean flag_MT_CodMDeInit = FALSE;
#endif
//-----------------------------------------------------------------------------
//  "define" and "typedef" statements at the module level
//-----------------------------------------------------------------------------
/** Swap the byte ordering of a 32-bit value */
#define CY_SWAP_ENDIAN32(x)     ((uint32)((((x) >> 24u) & 0x000000FFu) | (((x) & 0x00FF0000u) >> 8u) | \
  (((x)& 0x0000FF00u) << 8u) | ((x) << 24u)))

#define VALIDATION_CYCLE_COUNTER_MAX 10u

//-----------------------------------------------------------------------------
//  Global variable declarations
//-----------------------------------------------------------------------------

//=============================================================================
// Start definitions of static or initialized variables of type of type structures, unions, or arrays
//=============================================================================
//tRomPara_CodingArea applicationCodingData __attribute__((section(".APPL_CODING_DATA"))) = ROMPARA_SYSTEMBLOCK_INIT;
//#define APP_CODDATA __attribute__((used, protect, section(".rodata.CodingConfigData")))
//const tRomPara_CodingArea applicationCodingData APP_CODDATA;

const tRomPara_CodingArea* applicationCodingDataptr = (tRomPara_CodingArea*)CODING_START_ADDRESS;
//=============================================================================
// End definitions of static or initialized variables of type of type structures, unions, or arrays
//=============================================================================

//=============================================================================
// Start definitions of static or initialized variables of type of type structures, unions, or arrays
//=============================================================================
STATIC_AL const uint8 CodM_pucCodingLabelsHeader[] = "Z03_HH002_CODD";
STATIC_AL const uint8 CodM_pucCodingLabels[] = "Z03_HH002_CODD_0005.0000";
//=============================================================================
// End definitions of static or initialized variables of type of type structures, unions, or arrays
//=============================================================================

//=============================================================================
// Start definitions of static or initialized 8 bit variables
//=============================================================================
// -------------- Start variable definitions.
STATIC_AL boolean CodM_boCodingDataIsValidated = FALSE;
STATIC_AL boolean CodM_boECUIsCoded = FALSE;
STATIC_AL boolean CodM_boCrcCodingTestResultIsOk = FALSE;
STATIC_AL boolean CodM_boCodingLabelsCompatible = FALSE;
STATIC_AL tisCodingStatus tCodingStatus = { CODING_STATUS_UNKNOWN };
//STATIC_AL uint8   CodM_CodingValidationCntr = 0u;
// -------------- Stop variable definitions.
//=============================================================================
// End definitions of static or initialized 8 bit variables
//=============================================================================

//=============================================================================
// Start declaration or definitions of functions
//=============================================================================
STATIC_AL void CodM_ValidateCodingData(void);
//-----------------------------------------------------------------------------
//  Static variable declarations
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
//  Function prototypes
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
//  Function definitions
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
/// \brief initialisation function for CodM
///
/// \descr CodM_Init() is initializing the RTE outputs, privat variables and
///        coding data.
///        Calling once at start up.
///
/// \param  void
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CodM_Init(void)
{
#ifdef CodM_Debug_PrintfInitTime
  tickStart1 = UTILTIME_TIMER_START(0);
#endif

  if (CodM_boCodingDataIsValidated == FALSE)
  {
    CodM_ValidateCodingData();
  }

#ifdef CodM_Debug_PrintfInitTime
  deltaTicks1 = UTILTIME_TIMER_GET_TIME_SINCE(tickStart1);
  printf("*********** CodM: implementation time of CodM_Init() is %ld us ***********\n", deltaTicks1);
#endif
}

//-----------------------------------------------------------------------------
/// \brief deinitialisation function for CodM
///
/// \descr CodM_DeInit() is doing nothing
///        Calling once before go to sleep.
///
/// \param  void
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CodM_DeInit(void)
{
  // do absolute nothing
#ifdef UNIT_TEST
  flag_MT_CodMDeInit = TRUE;
#endif
} // PRQA S 5334 1 // program architecture and code readability

//-----------------------------------------------------------------------------
/// \brief  cyclic function for CodM
///
/// \descr  validate coding data status every 200ms (VALIDATION_CYCLE_COUNTER_MAX * cycle20ms)
///
/// \param  void
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CodM_Cycle20ms(void)
{
  //if (CodM_CodingValidationCntr == 0u)
  //{
  //  CodM_ValidateCodingData();
  //  CodM_CodingValidationCntr = VALIDATION_CYCLE_COUNTER_MAX;
  //}
  //else
  //{
  //  CodM_CodingValidationCntr = CodM_CodingValidationCntr - 1u;
  //}
#ifdef UNIT_TEST
  flag_MT_CodMCycle = TRUE;
#endif
}

//-----------------------------------------------------------------------------
//  Runnable Definitions
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
/// \brief initialization runnable
///
/// \descr initialization runnable for CodM
///        Calling once at start up.
///
/// \param  void
///
/// \return void
//-----------------------------------------------------------------------------
FUNC(void, ctaaCodM_CODE) Rte_riCodMInit(void)
{
  CodM_Init();
}

//-----------------------------------------------------------------------------
/// \brief deinitialization runnable
///
/// \descr deinitialization runnable for CodM
///        Calling once before go to sleep.
///
/// \param  void
///
/// \return void
//-----------------------------------------------------------------------------
FUNC(void, ctaaCodM_CODE) Rte_rdCodMDeInit(void)
{
  CodM_DeInit();
}

//-----------------------------------------------------------------------------
/// \brief  cyclic runnable
///
/// \descr  cyclic runnable for CodM
///         Calling cyclically every 20 ms.
///
/// \param  void
///
/// \return void
//-----------------------------------------------------------------------------
FUNC(void, ctaaCodM_CODE) Rte_rpCodM20ms(void)
{
#ifdef CodM_Debug
  CodM_ValidateCodingData();
#else
  if (CodM_boCodingDataIsValidated == FALSE)
  {
    CodM_Cycle20ms();
  }
#endif
}

//-----------------------------------------------------------------------------
/// \brief  Init Runnables
///
/// \descr  CodM_IsCodingLabelsCompatible
///         Calling at init.
///
/// \param  void
///
/// \return boolean
//-----------------------------------------------------------------------------
//boolean CodM_IsCodingLabelsCompatible(unsigned char* szSrc, const unsigned char* szDest)
//{
//  while (((unsigned char)'\0' != *szSrc) && ((unsigned char)'\0' != *szDest) && (*szSrc == *szDest)) { // PRQA S 1881// program architecture and readability
//    szSrc++;
//    szDest++;
//  }
//  return ((*szSrc - *szDest) == 0u ? TRUE : FALSE);  // PRQA S 1863// program architecture and readability
//}

//-----------------------------------------------------------------------------
/// \brief  Init Runnables
///
/// \descr  Rte_roCodMStartCodingDataVerification
///
///
/// \param  void
///
/// \return boolean
//-----------------------------------------------------------------------------
FUNC(Std_ReturnType, ctaaCodM_CODE) Rte_roCodMStartCodingDataVerification(void)
{
  //if (CodM_boCodingDataIsValidated == FALSE)
  //{
  //  CodM_ValidateCodingData();
  //}
  return RTE_E_OK;
}

//-----------------------------------------------------------------------------
/// \brief  CodM_ValidateCodingData
///
/// \descr  validate coding data with CRC check and label check, implementation time is about 5972us
///         
///
/// \param  void
///
/// \return void
//-----------------------------------------------------------------------------
# if defined (BRS_COMP_TASKING)
#pragma warning 549        /* 549: condition is always true */
# endif

STATIC_AL void CodM_ValidateCodingData(void)
{
  /* Deviation fromMISRA-C:2012 rule 11.4, 11.6.
  Justification: This cast is needed for handling integral values as addresses
  for device access. */
  /* PRQA S 306 2 */

  uint32 ulCrcCodingData;

  //unsigned char ucCodingLabels[25] = { (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0',
  //  (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0',
  //  (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0',
  //  (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0',
  //  (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0' };// PRQA S 4414// program architecture and readability
  uint32* pulCrcCodingExpected = (uint32*)CODING_CRC_ADDRESS; // PRQA S 306// program architecture and readability
  uint8*  pucCrcCodingData = (uint8*)CODING_START_ADDRESS; // PRQA S 306// program architecture and readability
  uint32 ulExpectedCRC;

#ifdef CodM_Debug_CheckCodingData
  unsigned char ucDebugCodingLabels[32];
  unsigned char ucDebugCodingDate[3];
  tRomPara_CodingArea            tDebugCodingData;
  tRomPara_SystemBlock           tDebugSystem;
  tRomPara_AFSConfigBlock        tDebugAFSConfig;
  tRomPara_PXA1DConfigBlock      tDebugPXAConfig;
  tRomPara_UnitsMappingBlock     tDebugUnitsMapping;
  tRomPara_ISDConfigBlock        tDebugISDConfig;
  tRomPara_LampFuncConfigBlock   tDebugLampFuncConfig;
  tRomPara_ISDDataThemeBlock     tDebugISDDataTheme;
  tRomPara_ISDDataRegsBlock      tDebugISDDataRegs;
  (void)memcpy(&tDebugCodingData, &applicationCodingData, sizeof(tRomPara_CodingArea));
  (void)memcpy(&ucDebugCodingLabels, applicationCodingData.CodingLabels, sizeof(ucDebugCodingLabels));
  (void)memcpy(&ucDebugCodingDate, applicationCodingData.CodingDate, sizeof(ucDebugCodingDate));
  (void)memcpy(&tDebugSystem, &applicationCodingData.System, sizeof(tRomPara_SystemBlock));
  (void)memcpy(&tDebugAFSConfig, &applicationCodingData.AFSConfig, sizeof(tRomPara_AFSConfigBlock));
  (void)memcpy(&tDebugPXAConfig, &applicationCodingData.PXA1DConfig, sizeof(tRomPara_PXA1DConfigBlock));
  (void)memcpy(&tDebugUnitsMapping, &applicationCodingData.UnitsMapping, sizeof(tRomPara_UnitsMappingBlock));
  (void)memcpy(&tDebugISDConfig, &applicationCodingData.ISDConfig, sizeof(tRomPara_ISDConfigBlock));
  (void)memcpy(&tDebugLampFuncConfig, &applicationCodingData.LampFuncConfig, sizeof(tRomPara_LampFuncConfigBlock));
  (void)memcpy(&tDebugISDDataTheme, &applicationCodingData.ISDDataTheme, sizeof(tRomPara_ISDDataThemeBlock));
  (void)memcpy(&tDebugISDDataRegs, &applicationCodingData.ISDDataRegs, sizeof(tRomPara_ISDDataRegsBlock));
#endif

  if ((pulCrcCodingExpected != NULL) && (pucCrcCodingData != NULL))
  {
#ifdef CodM_Debug_PrintfCrcCheckTime
    //if (FALSE == boDebugTimerCount2)
    //{
      tickStart2 = UTILTIME_TIMER_START(0);
    //}
#endif

#ifndef UNIT_TEST
    //Calculate CRC with coding data, implementation time is about 5977us
    ulCrcCodingData = Crc_CalculateCRC32P4(pucCrcCodingData,
      (uint32)(CODING_END_ADDRESS - CODING_START_ADDRESS + 1u),
      (uint32)0xFFFFFFFFUL,
      (boolean)TRUE);

#ifdef CodM_Debug_PrintfCrcCheckTime
    //if (FALSE == boDebugTimerCount2)
    //{
      deltaTicks2 = UTILTIME_TIMER_GET_TIME_SINCE(tickStart2);
      printf("*********** CodM: implementation time of coding data CRC check in CodM_ValidateCodingData() is %ld us ***********\n", deltaTicks2);
    //  boDebugTimerCount2 = TRUE;
    //}
#endif

    //Read CRC data and Swap Byte order
    ulExpectedCRC = *pulCrcCodingExpected;
    ulExpectedCRC = CY_SWAP_ENDIAN32(ulExpectedCRC);

    //Compare CRC data
    CodM_boCrcCodingTestResultIsOk = (ulCrcCodingData == ulExpectedCRC) ? TRUE : FALSE;
#else
    extern uint8 setCRCTestValue;
    CodM_boCrcCodingTestResultIsOk = Crc_CalculateCRCTest(setCRCTestValue);
#endif

    //Check Coding Label Header
    //(void)memcpy(&ucCodingLabels, applicationCodingDataptr->CodingLabels, sizeof(CodM_pucCodingLabelsHeader)-1u); // PRQA S 1840// program architecture and readability 
    //(void)memcpy(&ucCodingLabels, applicationCodingData.CodingLabels, sizeof(CodM_pucCodingLabelsHeader)-1u); // PRQA S 1840// program architecture and readability 
    //CodM_boECUIsCoded = CodM_IsCodingLabelsCompatible(ucCodingLabels, CodM_pucCodingLabelsHeader);
    if (0 == memcmp(applicationCodingData.CodingLabels, CodM_pucCodingLabelsHeader, sizeof(CodM_pucCodingLabelsHeader)-1u))
    {
      CodM_boECUIsCoded = TRUE;
    }
    else
    {
      CodM_boECUIsCoded = FALSE;
    }

    if (TRUE == CodM_boECUIsCoded)
    {
      //Check Coding Labels
      //(void)memcpy(&ucCodingLabels, applicationCodingDataptr->CodingLabels, sizeof(ucCodingLabels)-1u); // PRQA S 1840// program architecture and readability 
      //(void)memcpy(&ucCodingLabels, applicationCodingData.CodingLabels, sizeof(ucCodingLabels)-1u); // PRQA S 1840// program architecture and readability 
      //CodM_boCodingLabelsCompatible = CodM_IsCodingLabelsCompatible(ucCodingLabels, (unsigned char*)CodM_pucCodingLabels);
      if (0 == memcmp(applicationCodingData.CodingLabels, CodM_pucCodingLabels, sizeof(CodM_pucCodingLabels)-1u))
      {
        CodM_boCodingLabelsCompatible = TRUE;
      }
      else
      {
        CodM_boCodingLabelsCompatible = FALSE;
      }

    }
    else
    {
      CodM_boCodingLabelsCompatible = FALSE;
    }

  }
  else
  {
    CodM_boECUIsCoded = FALSE;
  }

  //Check Combined coding validity
  CodM_boCodingDataIsValidated = CodM_boCrcCodingTestResultIsOk & CodM_boCodingLabelsCompatible & CodM_boECUIsCoded;

  // Write Coding Status to RTE
  if (TRUE == CodM_boCodingDataIsValidated)
  {
    tCodingStatus.eCodingStatus = CODING_STATUS_VALID;
  }
  else
  {
    if (FALSE == CodM_boECUIsCoded)
    {
      tCodingStatus.eCodingStatus = CODING_STATUS_ECUNOTCODED;
    }
    else if (FALSE == CodM_boCodingLabelsCompatible)
    {
      tCodingStatus.eCodingStatus = CODING_STATUS_LABELNOTCOMPATIBLE;
    }
    else if (FALSE == CodM_boCrcCodingTestResultIsOk)
    {
      tCodingStatus.eCodingStatus = CODING_STATUS_CRCCHECKERR;
    }
    else
    {
      //
    }
  }

  Rte_Write_ctaaCodM_PpaseCodMCodingStatus_sCodingStatus(&tCodingStatus);

}

# if defined (BRS_COMP_TASKING)
#pragma warning restore        /*restore: 549: condition is always true */
# endif
//=============================================================================
// End declaration or definitions of functions
//=============================================================================