//-----------------------------------------------------------------------------
/// \file   CddSwi_Adapter.c
///
/// \brief  Default adapter
///
/// \author MES-LYG
//-----------------------------------------------------------------------------
#include <Std_Types.h>
#include <AL_Helper/AL_Helper.h>

#include <Rte_ctadCddSwi.h>
#if E2E_VALID
  #include <E2EWrapper_ctadCddSwi.h>
  #include <E2E_PH_Types.h>
#endif

#include <CddSwi/Api/CddSwi.h>
#include <CddSwi/Cfg/CddSwi_Cfg.h>

#if E2E_VALID
  #define FAULT_THRESH 19u
#endif

#ifndef UNIT_TEST
#else
#include "Mt_CddSwi/Test.h"
#endif

//-----------------------------------------------------------------------------
// Start definitions of initialized 8 bit variables
//-----------------------------------------------------------------------------
#define ctadCddSwi_START_SEC_VAR_INIT_UNSPECIFIED
#include <CddSwi/Cfg/CddSwi_MemMap.h>

#if E2E_VALID
  STATIC_AL uint8 CddSwi_E2E_Read_DebounceCounter  = 0u;
  STATIC_AL uint8 CddSwi_E2E_Write_DebounceCounter = 0u;
#endif

#define ctadCddSwi_STOP_SEC_VAR_INIT_UNSPECIFIED
#include <CddSwi/Cfg/CddSwi_MemMap.h>

#define ctadCddSwi_START_SEC_VAR_NOINIT_UNSPECIFIED
#include <CddSwi/Cfg/CddSwi_MemMap.h>

STATIC_AL uint16 usPreTgtVal[8];

#define ctadCddSwi_STOP_SEC_VAR_NOINIT_UNSPECIFIED
#include <CddSwi/Cfg/CddSwi_MemMap.h>

//-----------------------------------------------------------------------------
// End definitions of initialized 8 bit variables
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Start definitions of initialized boolean variables
//-----------------------------------------------------------------------------
#define ctadCddSwi_START_SEC_VAR_INIT_UNSPECIFIED
#include <CddSwi/Cfg/CddSwi_MemMap.h>

#if E2E_VALID
  STATIC_AL boolean CddSwi_E2E_Read_FaultActive  = FALSE;
  STATIC_AL boolean CddSwi_E2E_Write_FaultActive = FALSE;
#endif

#define ctadCddSwi_STOP_SEC_VAR_INIT_UNSPECIFIED
#include <CddSwi/Cfg/CddSwi_MemMap.h>
//-----------------------------------------------------------------------------
// End definitions of initialized boolean variables
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
// Start declaration or definitions of functions
//-----------------------------------------------------------------------------
#define ctadCddSwi_START_SEC_CODE
#include <CddSwi/Cfg/CddSwi_MemMap.h>


//-----------------------------------------------------------------------------
// Local function prototypes
//-----------------------------------------------------------------------------
#if E2E_VALID
  STATIC_AL boolean CddSwi_ReadE2E_ErrorCheck(uint32 E2E_ReadReturnVal);
  STATIC_AL boolean CddSwi_WriteE2E_ErrorCheck(uint32 E2E_WriteReturnVal);
#endif

//-----------------------------------------------------------------------------
/// \brief  Init runnable
///
/// \descr  Init runnable to be called at MCU startup
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
void Rte_riCddSwiInit(void)
{
  tisAllSwitchStatus aStatus;

  CddSwi_Init();
  CddSwi_SetSleep_Wakeup(CDDSWI_WAKEUP_MODE);

  for (uint8 i = 0; i < CFG_SWI_OUTPUTS_CNT; i++)
  {
    aStatus.asSwitchStatus[i] = CddSwi_GetState(i);
    usPreTgtVal[i] = 0u;
  }
#if E2E_VALID
  (void)E2EPW_Write_ppaseCddSwiStatus_sAllSwitchStatus(&aStatus);
#endif

  (void)Rte_Write_PpaseCddSwiSwiStatus_sAllSwitchStatus(&aStatus);
}

boolean CddSwi_GetCodMDataStatus(void)
{
  tisCodingStatus      tCodingDataStatus;
  boolean              IsCodingValid = FALSE;
  // read Coding Data Status
#if CODINGDATA_VALID
  (void)Rte_Read_PpareCodMCodingStatus_sCodingStatus(&tCodingDataStatus);
#endif
  if (tCodingDataStatus.eCodingStatus == 0U)
  {
    IsCodingValid = TRUE;
  }
  else
  {
    IsCodingValid = FALSE;
  }
  return IsCodingValid;

}

//-----------------------------------------------------------------------------
/// \brief  rpCddSwiCycle10ms
///
/// \descr  Cyclic runnable adapter for CddSwi_Cycle10ms.
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
void Rte_rpCddSwi10ms(void)
{
  tisAllSwitchStatus tStatus;
  tisAllSwitchTarget tTgtVal;
  boolean boWriteError;
  boolean boSleepStat;
#if E2E_VALID
  boolean boReadError;
  uint32 E2E_ReadReturnVal, E2E_WriteReturnVal;
  E2E_ReadReturnVal = E2EPW_Read_ppareSysMonSwiTarget_sAllSwitchTarget(&tTgtVal);
  boReadError = CddSwi_ReadE2E_ErrorCheck(E2E_ReadReturnVal);
#endif

  (void)Rte_Read_PpareCtrlSwiSwiTarget_sAllSwitchTarget(&tTgtVal);

#if E2E_VALID
  if (boReadError == FALSE)
#endif
  {
    //This function is get the Hss to Sleep or wakeup stat.
    boSleepStat = CddSwi_GetSleepStat();

    if (boSleepStat != TRUE) //not Dormancy only,Hss is output
    {
      for (uint8 i = 0; i < CFG_SWI_OUTPUTS_CNT; i++)
      {
        //This function is called for HSS output setting when request is changed from ctrlswi.
        CddSwi_New_request(i,tTgtVal.ucNew_request[i]);

        if (tTgtVal.aunTgtVal[i] != usPreTgtVal[i])
        {
          CddSwi_SetTgt(i, tTgtVal.aunTgtVal[i]);
        }
        usPreTgtVal[i] = tTgtVal.aunTgtVal[i];
      }
      CddSwi_SetSpiOut();
    }
    else
    {
      for (uint8 i = 0; i < CFG_SWI_OUTPUTS_CNT; i++)
      {
        usPreTgtVal[i] = 0u;
      }
    }
  }

#if E2E_VALID
  tStatus.bfSysMonTargetQty = (CddSwi_E2E_Read_FaultActive == TRUE) ? INVALID_VALUE_ERROR : 0x00;
#endif

  if (boSleepStat != TRUE) //not Dormancy only,Hss diagnostic implementation.
  {
    CddSwi_Cycle10ms();
  }

#if E2E_VALID
  if (boReadError == FALSE)
#endif
  {
    for (uint8 i = 0; i < CFG_SWI_OUTPUTS_CNT; i++)
    {
      tStatus.asSwitchStatus[i] = CddSwi_GetState(i);
    }
  }

#if E2E_VALID
  E2E_WriteReturnVal = E2EPW_Write_ppaseCddSwiStatus_sAllSwitchStatus(&tStatus);
  boWriteError = CddSwi_WriteE2E_ErrorCheck(E2E_WriteReturnVal);
#endif

  (void)Rte_Write_PpaseCddSwiSwiStatus_sAllSwitchStatus(&tStatus);

  (void)boWriteError;
  //if boWriteError == FALSE, write successful
  // else boWriteError = TRUE, no action necessary for now.
}

#if E2E_VALID
//--------------------------------------------------------------------------------------------------
/// \brief  CddSwi_ReadE2E_ErrorCheck
///
/// \descr
///
/// \param  E2E_ReadReturnVal
///
/// \return boolean TRUE: CRC_ERR, FALSE: CRC_NO_ERR
//--------------------------------------------------------------------------------------------------
STATIC_AL boolean CddSwi_ReadE2E_ErrorCheck(uint32 E2E_ReadReturnVal)
{
  boolean boRetVal = FALSE;
  uint32 StatusByte0_2, StatusByte3;

  StatusByte0_2 = (uint32)(((uint32)(E2E_ReadReturnVal)) & ((uint32)0x00FFFFFFU));
  StatusByte3 = (uint32)((((uint32)(E2E_ReadReturnVal)) >> 24U) & ((uint32)0x000000FFU));

  if (  ( (E2E_ReadReturnVal == E2E_E_OK)  ||  (StatusByte3 == E2E_P04STATUS_REPEATED) || (StatusByte3 == E2E_P04STATUS_OKSOMELOST) )
   &&   (StatusByte0_2 == 0x00)
   &&   (CddSwi_E2E_Read_FaultActive == FALSE)
   &&   (CddSwi_E2E_Read_DebounceCounter < FAULT_THRESH) )
  {
    if ((StatusByte3 == E2E_P04STATUS_REPEATED))
    {
      CddSwi_E2E_Read_DebounceCounter++;
    }
    else
    {
      if (CddSwi_E2E_Read_DebounceCounter > 0)
      {
        CddSwi_E2E_Read_DebounceCounter--;
      }
      else
      {
        CddSwi_E2E_Read_FaultActive = FALSE;
      }
    }
    boRetVal = FALSE;
  }
  else
  {
    if ( ( (E2E_ReadReturnVal == E2E_E_OK) ||
           ( (StatusByte3 == E2E_P04STATUS_OKSOMELOST) &&
             (StatusByte0_2 == 0x00)
           )
         ) == FALSE )
    {
      if (CddSwi_E2E_Read_DebounceCounter < FAULT_THRESH)
      {
        CddSwi_E2E_Read_DebounceCounter++;
      }
      else
      {
        CddSwi_E2E_Read_DebounceCounter = FAULT_THRESH;
        CddSwi_E2E_Read_FaultActive = TRUE;
      }
      boRetVal = TRUE;
    }
    else
    {
      if (CddSwi_E2E_Read_DebounceCounter > 0)
      {
        CddSwi_E2E_Read_DebounceCounter--;
        boRetVal = TRUE;
      }
      else
      {
        CddSwi_E2E_Read_FaultActive = FALSE;
        boRetVal = FALSE;
      }
    }
  }
  return boRetVal;
}

//--------------------------------------------------------------------------------------------------
/// \brief  CddSwi_WriteE2E_ErrorCheck
///
/// \descr
///
/// \param  E2E_WriteReturnVal
///
/// \return boolean TRUE: CRC_ERR, FALSE: CRC_NO_ERR
//--------------------------------------------------------------------------------------------------
STATIC_AL boolean CddSwi_WriteE2E_ErrorCheck(uint32 E2E_WriteReturnVal)
{
  boolean boRetVal = FALSE;

  if ((E2E_WriteReturnVal == E2E_E_OK) && (CddSwi_E2E_Write_FaultActive == FALSE))
  {
    //?CddSwi_CRC_Write_DebounceCounter--;
    //CddSwi_E2E_Write_FaultActive = FALSE;
    boRetVal = FALSE;
  }
  else
  {
    if (E2E_WriteReturnVal != E2E_E_OK)
    {
      if (CddSwi_E2E_Write_DebounceCounter < FAULT_THRESH)
      {
        CddSwi_E2E_Write_DebounceCounter++;
      }
      else
      {
        CddSwi_E2E_Write_FaultActive = TRUE;
      }
    }
    else
    {
      if (CddSwi_E2E_Write_DebounceCounter > 0)
      {
        CddSwi_E2E_Write_DebounceCounter--;
      }
      else
      {
        CddSwi_E2E_Write_FaultActive = FALSE;
      }
    }
    boRetVal = CddSwi_E2E_Write_FaultActive;
  }
  return boRetVal;
}
#endif

void RterdCddSwiDeInit(void)
{
  CddSwi_DeInit();
  for (uint8 i = 0; i < CFG_SWI_OUTPUTS_CNT; i++)
  {
    usPreTgtVal[i] = 0u;
  }
}

//--------------------------------------------------------------------------------------------------
/// \brief  CddSwi_SetSleep_mode
///
/// \descr
///
/// \param
///
/// \return void
//--------------------------------------------------------------------------------------------------
void CddSwi_SetSleep_mode(void)
{
  CddSwi_SetSleep_Wakeup(CDDSWI_SLEEP_MODE);
}

#define ctadCddSwi_STOP_SEC_CODE
#include <CddSwi/Cfg/CddSwi_MemMap.h>
//-----------------------------------------------------------------------------
// End declaration or definitions of functions
//-----------------------------------------------------------------------------