/*
 * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

///////////////////////////////////////////////////////////////////////////////
/// \ingroup  tag_SS_LoggerService
/// \brief    Provide support for SS Logger module utility functions.
///
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// INCLUDES
///////////////////////////////////////////////////////////////////////////////
#include "ss_logger_util.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <dirent.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <stub/Clock_API.h>
#include <iomanip>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>
#include "ss_logger_common.h"

#include <system_service/ss_logger_store_logs.h>

#define SS_STORE_FILENAME_SYSILG_TERM "_SYS_ILG_RESET.tar.gz"
#define SS_STORE_FILENAME__CWORD52__TERM "__CWORD52_.log"


char CLoggerUtil::m_usbpath[USB_PATH_SIZE];

///////////////////////////////////////////////////////////////////////////////
// CLASS METHODS
///////////////////////////////////////////////////////////////////////////////
CLoggerUtil::CLoggerUtil(void)
    : m_pCfg(NULL),
      m_Milage(0),
      m_bootCount(0) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  m_usbpath[0] = '\0';
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}

CLoggerUtil::~CLoggerUtil(void) {  // LCOV_EXCL_START 14:globle instance
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}
// LCOV_EXCL_STOP

EFrameworkunifiedStatus CLoggerUtil::Initialize(CLoggerCfg *f_pLoggerCfg) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus;

  m_pCfg = f_pLoggerCfg;
  l_eStatus = (NULL != f_pLoggerCfg) ? eFrameworkunifiedStatusOK : eFrameworkunifiedStatusInvldParam;

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}

std::string CLoggerUtil::getDestination(TLoggerErrorEvent &f_eventNtfData) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+: %d ", f_eventNtfData.EventType);
  std::string l_path = "";
  EFrameworkunifiedStatus l_eStatus;

  switch (f_eventNtfData.EventType) {
    case eErrorEventTypeProcessCrash:
    case eErrorEventTypeHeartBeatFailure:
    case eErrorEventTypeSystemLowMemory:
    case eErrorEventTypeBootMicroReset:
    case eErrorEventTypeProcessExit:
    case eErrorEventTypeUserInvokedUserForceReset:
    case eErrorEventTypeModConnFailed:
    case eErrorEventTypeStartRespFailed:
    case eErrorEventTypeUserInvokedCollectDevLogs:
    case eErrorEventTypeModuleInvokedResetRequest:
    case eErrorEventTypeModuleInvokedCollectDebugLogs:
    case eErrorEventTypeDtcEvent:
    case eErrorEventTypeUserInvokedClearLogs:
    case eErrorEventTypeGroupRelaunch:
      l_eStatus = m_pCfg->GetEmmcDestination(l_path);
      break;

    case eErrorEventTypeUserInvokedCollectNaviLog:
      l_eStatus = m_pCfg->GetEmmcNaviLogDestination(l_path);
      break;

    case eErrorEventTypeEelExport:
      l_path = f_eventNtfData.ModuleName;
      l_eStatus = eFrameworkunifiedStatusOK;
      break;

    case eErrorEventTypeInterfaceunifiedEmmcLogs:
      l_path = f_eventNtfData.ModuleName;
      l_eStatus = eFrameworkunifiedStatusOK;
      break;

    case eErrorEventTypeUserInvokedCollectAllLogs:
    case eErrorEventTypeUserInvokedCollectScreenShot:
    case eErrorEventTypeUserInvokedCollectInterfaceunifiedLogs:
    case eErrorEventTypeCanEvent:
      l_eStatus = m_pCfg->GetUserInvokedDestination(l_path);
      break;

    case eErrorEventTypeDiagEvent:
      l_path = f_eventNtfData.ModuleName;
      l_eStatus = eFrameworkunifiedStatusOK;
      break;

    default:
      l_eStatus = eFrameworkunifiedStatusFail;
      break;
  }
  if (eFrameworkunifiedStatusOK != l_eStatus) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. Could not get filepath ");
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-: %s", l_path.c_str());
  return (l_path);
}
EFrameworkunifiedStatus CLoggerUtil::checkDestinationAvailable(
    TLoggerErrorEvent &f_eventNtfData) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
  std::string l_path = CLoggerUtil::getDestination(f_eventNtfData);
  std::string::size_type ret;

  if (l_path.length() > 0) {
    ret = l_path.find(DEBUG_USB_PATH);
    if (ret != std::string::npos && ret == 0) {
      if (0 == access(m_usbpath, W_OK)) {  // LCOV_EXCL_BR_LINE 5:C code
        // LCOV_EXCL_START 5:C code
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        std::string path = l_path.substr(sizeof(DEBUG_USB_PATH) - 1);
        f_eventNtfData.ModuleName = m_usbpath;
        f_eventNtfData.ModuleName.append(path);
        l_eStatus = eFrameworkunifiedStatusOK;
        // LCOV_EXCL_STOP
      }
    } else {
      if (0 == access(l_path.c_str(), W_OK)) {  // LCOV_EXCL_BR_LINE 5:C code
        l_eStatus = eFrameworkunifiedStatusOK;
      }
    }
  }

  if (eFrameworkunifiedStatusOK != l_eStatus) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           " Error. Failed the check path: l_eStatus(%d), l_path(%s)",
           l_eStatus, l_path.c_str());  // LCOV_EXCL_BR_LINE 11:except,C++ STL
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}

static void SetSuffixFromType(std::string &pathAndName, EErrorEventType type) {  // NOLINT (runtime/references)
  switch (type) {
    case eErrorEventTypeProcessCrash:
    case eErrorEventTypeHeartBeatFailure:
    case eErrorEventTypeSystemLowMemory:
    case eErrorEventTypeBootMicroReset:
    case eErrorEventTypeProcessExit:
    case eErrorEventTypeModConnFailed:
    case eErrorEventTypeStartRespFailed:
    case eErrorEventTypeModuleInvokedResetRequest:
      pathAndName.insert(pathAndName.find(".tar.gz"), "_ERR");
      break;
    case eErrorEventTypeUserInvokedUserForceReset:
    case eErrorEventTypeUserInvokedCollectAllLogs:
    case eErrorEventTypeUserInvokedCollectScreenShot:
    case eErrorEventTypeUserInvokedCollectInterfaceunifiedLogs:
    case eErrorEventTypeDiagEvent:
    case eErrorEventTypeCanEvent:
    case eErrorEventTypeDtcEvent:
    case eErrorEventTypeModuleInvokedCollectDebugLogs:
      pathAndName.insert(pathAndName.find(".tar.gz"), "_DIAG");
      break;
    case eErrorEventTypeUserInvokedCollectDevLogs:
      pathAndName.insert(pathAndName.find(".tar.gz"), "_DEBUG");
      break;
    case eErrorEventTypeGroupRelaunch:
      pathAndName.insert(pathAndName.find(".tar.gz"), "_GRP_RELAUNCH");
      break;
    default:
      break;
  }
}

EFrameworkunifiedStatus CLoggerUtil::getFilePathAndName(HANDLE f_hApp,
                                           TLoggerErrorEvent &f_eventNtfData,
                                           uint32_t f_time,
                                           std::string &f_pathAndName) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  f_pathAndName = "";

  switch (f_eventNtfData.EventType) {  // LCOV_EXCL_BR_LINE 200: eErrorEventTypeEelExport ex. can not be run
    case eErrorEventTypeProcessCrash:
    case eErrorEventTypeProcessExit:
    case eErrorEventTypeHeartBeatFailure:
    case eErrorEventTypeSystemLowMemory:
    case eErrorEventTypeBootMicroReset:
    case eErrorEventTypeModConnFailed:
    case eErrorEventTypeStartRespFailed:
    case eErrorEventTypeGroupRelaunch:
      l_eStatus = m_pCfg->GetEmmcDestination(f_pathAndName);
      if (eFrameworkunifiedStatusOK != l_eStatus) {  // LCOV_EXCL_BR_LINE 6:it will aways return ok
        // LCOV_EXCL_START 6:it will aways return ok
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
               " Error. GetEmmcDestination() returned %d.",
               l_eStatus);
        // LCOV_EXCL_STOP
      } else {
        f_pathAndName.append("/");
        f_pathAndName.append(GetEmmcFilename(f_time));
      }
      break;

    case eErrorEventTypeUserInvokedUserForceReset:
    case eErrorEventTypeUserInvokedCollectDevLogs:
      l_eStatus = m_pCfg->GetEmmcDestination(f_pathAndName);
      if (eFrameworkunifiedStatusOK != l_eStatus) {  // LCOV_EXCL_BR_LINE 6:it will aways return ok
        // LCOV_EXCL_START 6:it will aways return ok
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
               " Error. GetEmmcDestination() returned %d.",
               l_eStatus);
        // LCOV_EXCL_STOP
      } else {
        f_pathAndName.append("/");
        f_pathAndName.append(GetEmmcFilename(f_time));
      }
      break;
    case eErrorEventTypeModuleInvokedResetRequest:
    case eErrorEventTypeModuleInvokedCollectDebugLogs:
    case eErrorEventTypeDtcEvent:
      l_eStatus = m_pCfg->GetEmmcDestination(f_pathAndName);
      if (eFrameworkunifiedStatusOK != l_eStatus) {  // LCOV_EXCL_BR_LINE 6:it will aways return ok
        // LCOV_EXCL_START 6:it will aways return ok
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
               " Error. GetEmmcDestination() returned %d.",
               l_eStatus);
        // LCOV_EXCL_STOP
      } else {
        f_pathAndName.append("/");
        f_pathAndName.append(GetEmmcFilename(f_time));
        if (!f_eventNtfData.ModuleName.empty()) {  // LCOV_EXCL_BR_LINE 6: ModuleName can not be empty
          size_t l_pos = f_pathAndName.find(".tar.gz");
          if (l_pos != std::string::npos) {  // LCOV_EXCL_BR_LINE 6: ".tar.gz" is aways exist
            f_pathAndName.insert(l_pos, f_eventNtfData.ModuleName);
          }
        }
      }
      break;
    case eErrorEventTypeEelExport:  // LCOV_EXCL_START 6: impossible to confirm because it can not get in
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      f_pathAndName = f_eventNtfData.ModuleName;
      f_pathAndName.append("/");
      f_pathAndName.append("loggerservicelogs_export_");
      f_pathAndName.append(GetTimeString(f_time));
      f_pathAndName.append(".tar.gz");
      break;
      // LCOV_EXCL_STOP
    case eErrorEventTypeInterfaceunifiedEmmcLogs:  // LCOV_EXCL_START 6: impossible to confirm because it can not get in
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      // store the target location on event trigger
      f_pathAndName = f_eventNtfData.ModuleName;
      break;
      // LCOV_EXCL_STOP
    case eErrorEventTypeUserInvokedCollectAllLogs:
      l_eStatus = m_pCfg->GetUserInvokedDestination(f_pathAndName);
      if (eFrameworkunifiedStatusOK != l_eStatus) {  // LCOV_EXCL_BR_LINE 6: impossible to confirm because it can not be fail
        // LCOV_EXCL_START 6: impossible to confirm because it can not be fail
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
               " Error. GetUserInvokedDestination() returned %d.",
               l_eStatus);
        // LCOV_EXCL_STOP
      } else {
        std::string l_emmc_path = m_pCfg->getEmmcOutputPath();
        f_pathAndName.append(l_emmc_path);
        f_pathAndName.append("/");
        f_pathAndName.append(GetUserInvokedFilename(f_hApp, f_time));
        if (!f_eventNtfData.ModuleName.empty()) {  // LCOV_EXCL_BR_LINE 6: it can not be empty
          size_t l_pos = f_pathAndName.find(".tar.gz");
          if (l_pos != std::string::npos) {  // LCOV_EXCL_BR_LINE 6: ".tar.gz" is aways exist
            f_pathAndName.insert(l_pos, f_eventNtfData.ModuleName);
          }
        }
      }
      break;

    case eErrorEventTypeUserInvokedCollectScreenShot:
    case eErrorEventTypeUserInvokedCollectInterfaceunifiedLogs:
    case eErrorEventTypeCanEvent:
      l_eStatus = m_pCfg->GetUserInvokedDestination(f_pathAndName);
      if (eFrameworkunifiedStatusOK != l_eStatus) {  // LCOV_EXCL_BR_LINE 6: impossible to confirm because it can not be fail
        // LCOV_EXCL_START 6: impossible to confirm because it can not be fail
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
               " Error. GetUserInvokedDestination() returned %d.",
               l_eStatus);
        // LCOV_EXCL_STOP
      } else {
        f_pathAndName.append("/");
        f_pathAndName.append(GetUserInvokedFilename(f_hApp, f_time));
      }
      break;

    case eErrorEventTypeDiagEvent:  // LCOV_EXCL_START 6: impossible to confirm because it can not get in
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      f_pathAndName = f_eventNtfData.ModuleName;
      f_pathAndName.append("/");
      f_pathAndName.append(GetUserInvokedFilename(f_hApp, f_time));
      l_eStatus = eFrameworkunifiedStatusOK;
      break;
      // LCOV_EXCL_STOP
    case eErrorEventTypeUserInvokedClearLogs:
    case eErrorEventTypeUserInvokedCollectNaviLog:
      l_eStatus = eFrameworkunifiedStatusOK;
      break;

    default:
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. Unknown event type: %d.",
             f_eventNtfData.EventType);
      l_eStatus = eFrameworkunifiedStatusFail;
      break;
  }

  SetSuffixFromType(f_pathAndName, f_eventNtfData.EventType);

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}

// LCOV_EXCL_START 13:
EFrameworkunifiedStatus CLoggerUtil::getNaviLogFilePathAndName(std::string &f_prefix,
                                                  uint32_t f_time,
                                                  std::string &f_pathAndName) {  // LCOV_EXCL_BR_LINE 13:
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  l_eStatus = m_pCfg->GetEmmcNaviLogDestination(f_pathAndName);
  if (eFrameworkunifiedStatusOK != l_eStatus) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           " Error. GetEmmNaviLogDestination() returned %d.",
           l_eStatus);
  } else {
    f_pathAndName.append("/");
    f_pathAndName.append(f_prefix);
    f_pathAndName.append(GetEmmcNaviLogFilename(f_time));
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}
// LCOV_EXCL_STOP

// LCOV_EXCL_START 200:
EFrameworkunifiedStatus CLoggerUtil::getEmmcNaviLogParams(
    uint32_t f_time, EPWR_SHUTDOWN_TRIGGER_TYPE errorType,
    std::string &f_pathName, UI_32 &f_logMax) {
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  DIR *l_dirp = NULL;
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  std::string l_prefix = "";

  std::vector<std::string> l_vector;
  std::string l_path = m_pCfg->getEmmcOutputNaviLogPath();

  if ((errorType == epssdmsdtGENERIC_ERROR_RESET)
      || (errorType == epssdmsdtFATAL_ERROR_RESET)) {
    /*When reset occured !!*/
    f_logMax = m_pCfg->m_emmcOutputNaviLogErrMax;
    l_prefix = "ERR_";
  } else {
    /* ACC OFF occured*/
    f_logMax = m_pCfg->m_emmcOutputNaviLogNmlMax;
    l_prefix = "NML_";
  }

  if (f_logMax == 0) {
    l_eStatus = eFrameworkunifiedStatusOK;
    return l_eStatus;
  }

  l_dirp = opendir(l_path.c_str());
  if (l_dirp != NULL) {
    struct dirent l_dirent;
    struct dirent* next;

    while (0 == readdir_r(l_dirp, &l_dirent, &next) && next != NULL) {
      std::string l_findFileName = l_dirent.d_name;
      size_t l_find_pos_top = l_findFileName.find(l_prefix.c_str());
      size_t l_find_pos = l_findFileName.find(".log");
      if (std::string::npos != l_find_pos
          && std::string::npos != l_find_pos_top) {
        l_vector.push_back(l_findFileName);
      }
    }
    closedir(l_dirp);
  }
  std::sort(l_vector.begin(), l_vector.end());

  for (UI_32 i = static_cast<UI_32>(l_vector.size()); i != 0; i--) {
    std::string l_FilePath = l_path;
    std::string l_FileName = l_vector.at(i - 1);
    l_FilePath.append("/");
    l_FilePath.append(l_FileName.c_str());

    if (i < f_logMax) {
      size_t l_pos = l_FileName.find("_", l_prefix.size());
      if (std::string::npos != l_pos) {
        std::string l_renameFilePath = l_path;
        std::stringstream l_numStream;
        l_numStream << std::setw(5) << std::setfill('0') << std::right << std::dec << (i + 1);
        l_renameFilePath.append("/");
        l_renameFilePath.append(l_prefix);
        l_renameFilePath.append(l_numStream.str());
        l_renameFilePath.append(l_FileName, l_pos, (l_FileName.size() - l_pos));
        if (0 != rename(l_FilePath.c_str(), l_renameFilePath.c_str())) {
          FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. rename navilog file %s:%d.",
                 l_FilePath.c_str(), errno);
        }
      }
    } else {
      if (0 != unlink(l_FilePath.c_str())) {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. delete navilog file %s:%d.",
               l_FilePath.c_str(), errno);
      }
    }
  }
  // sync parent directory
  SyncDir(l_path);

  l_eStatus = getNaviLogFilePathAndName(l_prefix, f_time, f_pathName);
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}
// LCOV_EXCL_STOP

// LCOV_EXCL_START 200: can not be called
size_t CLoggerUtil::deleteRequestLogs(std::string f_emmcpath,
                                      ELOGGERSERVICELOGTYPE f_reqtype, size_t f_reqsize,
                                      ELOGGERSERVICELOGTYPE f_deltype) {
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  DIR* l_dirp = NULL;
  std::vector<std::string> vect;
  std::vector<std::string>::iterator it;
  UI_32 l_count = 0;
  size_t l_totalsize = 0;

  // create saved file list on eMMC
  l_dirp = opendir(f_emmcpath.c_str());
  if (l_dirp != NULL) {
    struct dirent l_dirent;
    struct dirent* next;
    while (0 == readdir_r(l_dirp, &l_dirent, &next) && next != NULL) {
      std::string l_filename = l_dirent.d_name;
      if (CLoggerUtil::QueryLoggerservicelogType(l_filename) == f_deltype) {
        vect.push_back(l_filename);
      }
    }
    closedir(l_dirp);
  } else {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " open failed eMMC path: %s",
           f_emmcpath.c_str());
    FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
    return 0;
  }

  // get num of delete logs
  std::sort(vect.begin(), vect.end());
  for (it = vect.begin(); it != vect.end(); it++) {
    l_count++;

    std::string l_filename = *it;
    struct stat st_buf;
    std::string l_tmpstr = f_emmcpath;
    l_tmpstr.append(l_filename.c_str());
    if (stat(l_tmpstr.c_str(), &st_buf) != -1) {
      l_totalsize += st_buf.st_size;
    }

    if (l_totalsize > f_reqsize) {
      break;
    }
  }

  // start delete logs
  if ((l_totalsize > f_reqsize) || (f_reqtype == eLoggerservicelogTypeAbnormal)
      || (f_reqtype == eLoggerservicelogTypeGrpRelaunch)) {
    for (it = vect.begin(); it != vect.end() && l_count > 0; it++) {
      l_count--;

      std::string l_filename = *it;
      std::string l_tmpstr = f_emmcpath;
      l_tmpstr.append(l_filename.c_str());
      if (unlink(l_tmpstr.c_str()) != 0) {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " unlink failed %s:%d.",
               l_tmpstr.c_str(), errno);
      }
      FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " del-file=%s total=%d", l_tmpstr.c_str(),
             l_totalsize);
    }
    SyncDir(f_emmcpath);
  } else {
    l_totalsize = 0;
    FRAMEWORKUNIFIEDLOG(
        ZONE_INFO,
        __FUNCTION__,
        " nothing to delete logs req-type=%d del-logtype=%d total=%d, log_count=%d",
        f_reqtype, f_deltype, l_totalsize, l_count);
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_totalsize;
}
// LCOV_EXCL_STOP

// LCOV_EXCL_START 200: can not be called
EFrameworkunifiedStatus CLoggerUtil::forceDeleteOldLog(std::string f_archive_destination,
                                          size_t f_req_size) {
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
  std::string l_emmc_path;
  size_t l_delsize = 0;
  ELOGGERSERVICELOGTYPE l_logtype = eLoggerservicelogTypeOther;

  size_t l_pos = f_archive_destination.find_last_of('/');
  if (std::string::npos != l_pos) {
    l_emmc_path = f_archive_destination.substr(0, l_pos);
    l_emmc_path.append("/");
    l_logtype = CLoggerUtil::QueryLoggerservicelogType(
        f_archive_destination.substr(l_pos + 1,
                                     f_archive_destination.size() - l_pos + 1));
  }

  if (l_logtype == eLoggerservicelogTypeOther) {
    // not found
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Invalid Parameter. dest=%s",
           f_archive_destination.c_str());
    FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
    return eFrameworkunifiedStatusFail;
  }

  // remove dirty-file if exist
  if (unlink(f_archive_destination.c_str()) != 0) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " unlink failed %s:%d.",
           f_archive_destination.c_str(), errno);
  }

  // delete normal log
  l_delsize = deleteRequestLogs(l_emmc_path, l_logtype, f_req_size,
                                eLoggerservicelogTypeNormal);
  if (l_delsize >= f_req_size) {
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
           " delete normal logs success: req-size=%d, del-size=%d", f_req_size,
           l_delsize);
    l_eStatus = eFrameworkunifiedStatusOK;
  } else if (l_logtype == eLoggerservicelogTypeAbnormal) {
  // delete abnormal log if request type is abnormal
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
           " continue delete abnormal logs: req-size=%d, del-size=%d",
           f_req_size, l_delsize);
    size_t l_tmpsize = f_req_size;
    l_tmpsize -= l_delsize;
    l_delsize = deleteRequestLogs(l_emmc_path, l_logtype, l_tmpsize,
                                  eLoggerservicelogTypeAbnormal);
    if (l_delsize >= l_tmpsize) {
      FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
             " delete abnormal logs success: req-size=%d, del-size=%d",
             f_req_size, l_delsize);
      l_eStatus = eFrameworkunifiedStatusOK;
    } else {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
             " abnormal log delete not complete. req-size=%d, del-size=%d",
             f_req_size, l_delsize);
    }
  } else if (l_logtype == eLoggerservicelogTypeGrpRelaunch) {
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
           " continue delete group relaunch logs: req-size=%d, del-size=%d",
           f_req_size, l_delsize);
    size_t l_tmpsize = f_req_size;
    l_tmpsize -= l_delsize;
    l_delsize = deleteRequestLogs(l_emmc_path, l_logtype, l_tmpsize,
                                  eLoggerservicelogTypeGrpRelaunch);
    if (l_delsize >= l_tmpsize) {
      FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
             " delete group relaunch logs success: req-size=%d, del-size=%d",
             f_req_size, l_delsize);
      l_eStatus = eFrameworkunifiedStatusOK;
    } else {
      FRAMEWORKUNIFIEDLOG(
          ZONE_ERR, __FUNCTION__,
          " group relaunch log delete not complete. req-size=%d, del-size=%d",
          f_req_size, l_delsize);
    }
  } else {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           " normal log del not complete. req-size=%d, del-size=%d", f_req_size,
           l_delsize);
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}
// LCOV_EXCL_STOP

EFrameworkunifiedStatus CLoggerUtil::deleteOldLog(std::string log_path,
                                     std::vector<std::string>& l_vector,
                                     std::string& f_archive_destination,
                                     UI_32 max_num) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  size_t l_pos = f_archive_destination.find_last_of('/');
  if (std::string::npos != l_pos) {  // LCOV_EXCL_BR_LINE 200: there is always '/' in f_destination
    std::sort(l_vector.begin(), l_vector.end());
    std::vector<std::string>::iterator itr = l_vector.begin();
    for (UI_32 i = static_cast<UI_32>(l_vector.size()); (max_num - 1) < i; i--, itr++) {
      if (itr == l_vector.end()) {  // LCOV_EXCL_BR_LINE 200: (max_num - 1) can not be -1.
        break;
      }
      std::string l_FilePath = log_path;
      std::string l_FileName = *itr;
      l_FilePath.append("/");
      l_FilePath.append(l_FileName.c_str());
      if (0 != unlink(l_FilePath.c_str())) {
        l_eStatus = eFrameworkunifiedStatusAccessError;
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. delete old log file %s:%d.",
               l_FilePath.c_str(), errno);
      }
    }
    SyncDir(log_path);
  } else {
    // LCOV_EXCL_START 200: there is always '/' in f_destination
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    l_eStatus = eFrameworkunifiedStatusFail;
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. delete target not found. %s",
           f_archive_destination.c_str());
    // LCOV_EXCL_STOP
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}

EFrameworkunifiedStatus CLoggerUtil::deleteOldEmmcLog(std::string& f_archive_destination,
                                         EErrorEventType type) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  DIR *l_dirp = NULL;
  std::vector<std::string> vect_abnrm; /* ILLEGAL RESET LOG INFO or ERROR EXIT LOG INFO */
  std::vector<std::string> vect_nrm; /* NORMAL LOG INFO */
  std::vector<std::string> vect_rlnc; /* RELAUNCH LOG INFO */
  std::string l_emmc_path = m_pCfg->getEmmcOutputPath();
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  UI_32 abnrm_count = 0;

  l_dirp = opendir(l_emmc_path.c_str());
  if (l_dirp != NULL) {  // LCOV_EXCL_BR_LINE 5: opendir's error case.
    struct dirent l_dirent;
    struct dirent* next;
    while (0 == readdir_r(l_dirp, &l_dirent, &next) && next != NULL) {
      std::string l_findFileName = l_dirent.d_name;

//      if ((std::string::npos != l_findFileName.find("_ILG_RESET.tar.gz"))
//          || (std::string::npos != l_findFileName.find("_ERR.tar.gz"))) {
//        vect_abnrm.push_back(l_findFileName);
      if ((l_findFileName == ".") || (l_findFileName == "..")) {
        continue;
      } else if (std::string::npos != l_findFileName.find(SS_STORE_FILENAME_SYSILG_TERM)) {
        vect_abnrm.push_back(l_findFileName);
      } else if(std::string::npos != l_findFileName.find(SS_STORE_FILENAME__CWORD52__TERM)) {  // LCOV_EXCL_BR_LINE 8: SS_STORE_FILENAME__CWORD52__TERM can not be set  // NOLINT[whitespace/line_length]
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        vect_abnrm.push_back(l_findFileName);  // LCOV_EXCL_LINE 8: SS_STORE_FILENAME_SYSILG_TERM can not be set  // NOLINT[whitespace/line_length]
      } else if((std::string::npos != l_findFileName.find("_ILG_RESET.tar.gz")) ||
                (std::string::npos != l_findFileName.find("_ERR.tar.gz"))) {
        vect_abnrm.push_back(l_findFileName);
        abnrm_count++;

      } else if (std::string::npos
          != l_findFileName.find("_GRP_RELAUNCH.tar.gz")) {
        vect_rlnc.push_back(l_findFileName);
      } else if (std::string::npos != l_findFileName.find(".tar.gz")) {
        vect_nrm.push_back(l_findFileName);
      }
    }
    closedir(l_dirp);
  }

  switch (type) {
    case eErrorEventTypeProcessCrash:
    case eErrorEventTypeProcessExit:
    case eErrorEventTypeHeartBeatFailure:
    case eErrorEventTypeSystemLowMemory:
    case eErrorEventTypeBootMicroReset:
    case eErrorEventTypeModConnFailed:
    case eErrorEventTypeStartRespFailed:
    case eErrorEventTypeModuleInvokedResetRequest:

//      if ((UI_32) m_pCfg->m_emmcOutputErrMax <= vect_abnrm.size()) {
//        l_eStatus = deleteOldLog(l_emmc_path, vect_abnrm, f_archive_destination,
//                                 (UI_32) m_pCfg->m_emmcOutputErrMax);
      if ((UI_32)m_pCfg->m_emmcOutputErrMax <= abnrm_count) {
        l_eStatus = SS_LoggerStoreLogs_deleteOldLogAbnrm(l_emmc_path, vect_abnrm, f_archive_destination,
                                                         (UI_32)m_pCfg->m_emmcOutputErrMax, abnrm_count);

      }
      break;
    case eErrorEventTypeGroupRelaunch:
      if ((UI_32) m_pCfg->m_emmcOutputGrpRelaunchMax <= vect_rlnc.size()) {
        l_eStatus = deleteOldLog(l_emmc_path, vect_rlnc, f_archive_destination,
                                 (UI_32) m_pCfg->m_emmcOutputGrpRelaunchMax);
      }
      break;
    default:
      if ((UI_32) m_pCfg->m_emmcOutputMax <= vect_nrm.size()) {
        l_eStatus = deleteOldLog(l_emmc_path, vect_nrm, f_archive_destination,
                                 (UI_32) m_pCfg->m_emmcOutputMax);
      }
      break;
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}

void CLoggerUtil::SetMilage(UI_32 f_Milage) {
  m_Milage = f_Milage;
}

std::string CLoggerUtil::GetUserInvokedFilename(HANDLE f_hApp, uint32_t f_time) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  std::string l_ret = "";
  std::stringstream l_nameStream;
  UI_32 l_seqNumber = 0;

  EFrameworkunifiedStatus l_eStatus = m_pCfg->GetIncrementAndPersistUserInvokedCounter(
      f_hApp, l_seqNumber);
  LOG_STATUS_IF_ERRORED(
      l_eStatus,
      "GetIncrementAndPersistUserInvokedCounter()");

  /* new counter value was not persisted if l_eStatus != eFrameworkunifiedStatusOK */

  l_nameStream << std::setw(5) << std::setfill('0') << std::right << std::dec << l_seqNumber << '_';
  l_nameStream << std::setw(8) << std::setfill('0') << std::right << std::dec << m_Milage << '_';
  l_nameStream << std::setw(5) << std::setfill('0') << std::right << std::dec << m_bootCount << '_';
  l_nameStream << std::setw(15) << GetTimeString(f_time) << ".tar.gz";

  l_ret = l_nameStream.str();

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_ret);
}

std::string CLoggerUtil::GetEmmcFilename(uint32_t f_time) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  std::string l_ret = "";
  std::stringstream l_nameStream;
  UI_32 l_counter = 0;

  m_pCfg->GetAndIncrementEmmcCounter(l_counter);
  l_nameStream << std::setw(5) << std::setfill('0') << std::right << std::dec << l_counter << '_';
  l_nameStream << std::setw(15) << this->GetTimeString(f_time) << ".tar.gz";

  l_ret = l_nameStream.str();

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_ret);
}

// LCOV_EXCL_START 8: dead code
std::string CLoggerUtil::GetEmmcErrorFilename(uint32_t f_time) {
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  std::string l_ret = "";
  std::stringstream l_nameStream;
  UI_32 l_counter = 0;

  m_pCfg->GetAndIncrementEmmcCounter(l_counter);
  l_nameStream << std::setw(5) << std::setfill('0') << std::right << std::dec << l_counter << '_';
  l_nameStream << std::setw(15) << this->GetTimeString(f_time) << "_ERR.tar.gz";

  l_ret = l_nameStream.str();

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_ret);
}
// LCOV_EXCL_STOP

// LCOV_EXCL_START 13:
std::string CLoggerUtil::GetEmmcNaviLogFilename(uint32_t f_time) {
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  std::string l_ret = "";
  std::stringstream l_nameStream;
  UI_32 l_counter = 1;

  l_nameStream << std::setw(5) << std::setfill('0') << std::right << std::dec << l_counter << '_';
  l_nameStream << std::setw(15) << this->GetTimeString(f_time) << ".log";

  l_ret = l_nameStream.str();

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_ret);
}
// LCOV_EXCL_STOP

std::string CLoggerUtil::GetTimeString(uint32_t f_time) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  std::string l_ret = "00000000_000000";
  struct tm local_time;
  Clock_getLocalTimeY2K38(&f_time, &local_time);
  char buffer[20];
  if (0
      != strftime(buffer, sizeof(buffer), "%Y%m%d_%H%M%S",  // LCOV_EXCL_BR_LINE 5: c code
                  &local_time)) {
    l_ret = buffer;
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_ret);
}

void CLoggerUtil::SetUsbMountPath(std::string usbpath) {
  strncpy(m_usbpath, usbpath.c_str(), USB_PATH_SIZE - 1);
  m_usbpath[USB_PATH_SIZE - 1] = '\0';
}
#ifdef RELEASE_BUILD
EFrameworkunifiedStatus CLoggerUtil::PathCheckAndCopyFile(std::string f_source,
    std::string f_destination) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
  std::string::size_type ret;

  ret = f_destination.find(m_usbpath);
  l_eStatus = CopyFile(f_source, f_destination);

  return l_eStatus;
}
#endif  // RELEASE_BUILD
/////////////////////////////////////////////////////////////////////////
///// Static Functions
/////////////////////////////////////////////////////////////////////////

EFrameworkunifiedStatus CLoggerUtil::CopyFile(std::string f_source,
                                 std::string f_destination) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  ssize_t l_nrd;
  ssize_t l_nwr;
  char l_buf[BUF_MAX_SIZE];

  int l_if = open(f_source.c_str(), O_RDONLY | O_CLOEXEC, 0);
  if (-1 == l_if) {  // LCOV_EXCL_BR_LINE 5: open's error case.
    // LCOV_EXCL_START 5: open's error case.
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "src open fail:%s,errno:%d,msg:%s",
           f_source.c_str(), errno, strerror(errno));
    l_eStatus = eFrameworkunifiedStatusFail;
    // LCOV_EXCL_STOP
  } else {
    bool isWebdav = false;
    std::string l_tmpDest;
    size_t l_pos = f_destination.find_last_of('/');

    l_tmpDest = f_destination;
    if (f_destination.find("/mnt/import") != std::string::npos) {  // LCOV_EXCL_BR_LINE 13:
      // if output to webdav's directory, don't create temporary file.
      // because of being unable to rename the file on it.
      isWebdav = true;
    }

    int l_of = open(l_tmpDest.c_str(), O_WRONLY | O_CREAT | O_CLOEXEC, 0640);
    if (-1 == l_of) {  // LCOV_EXCL_BR_LINE 5: open's error case.
      // LCOV_EXCL_START 5: open's error case.
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "dest open fail:%s,errno:%d,msg:%s",
             l_tmpDest.c_str(), errno, strerror(errno));
      l_eStatus = eFrameworkunifiedStatusFail;
      // LCOV_EXCL_STOP
    } else {
      do {
        l_nrd = read(l_if, l_buf, sizeof(l_buf));
        if (l_nrd == -1) {  // LCOV_EXCL_BR_LINE 5: read's error case.
          // LCOV_EXCL_START 5: read's error case.
          AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
          FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "read fail:%s,errno:%d,msg:%s",
                 f_source.c_str(), errno, strerror(errno));
          l_eStatus = eFrameworkunifiedStatusAccessError;
          break;
          // LCOV_EXCL_STOP
        }

        l_nwr = write(l_of, l_buf, l_nrd);
        if (l_nwr == -1) {  // LCOV_EXCL_BR_LINE 5: write's error case.
          // LCOV_EXCL_START 5: write's error case.
          AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
          if (ENOSPC == errno) {
            FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
                   "write fail(ENOSPC):%s,errno:%d,msg:%s", l_tmpDest.c_str(),
                   errno, strerror(errno));
            l_eStatus = eFrameworkunifiedStatusErrNoEAGAIN;
          } else {
            FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "write fail:%s,errno:%d,msg%s",
                   l_tmpDest.c_str(), errno, strerror(errno));
            l_eStatus = eFrameworkunifiedStatusAccessError;
          }
          break;
          // LCOV_EXCL_STOP
        }
      } while (l_nrd > 0);

      fsync(l_of);
      close(l_of);

      if (l_eStatus != eFrameworkunifiedStatusOK) {  // LCOV_EXCL_BR_LINE 6: can not be fail
        // LCOV_EXCL_START 6: can not be fail
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        close(l_if);
        return l_eStatus;
        // LCOV_EXCL_STOP
      }

      {
        struct stat istat_buf, ostat_buf;
        int ret;
        ret = fstat(l_if, &istat_buf);
        if (ret < 0) {  // LCOV_EXCL_BR_LINE 5: fstat's error case.
          // LCOV_EXCL_START 5: fstat's error case.
          AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
          FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. stat(%s). errno: %d, %s",
                 f_source.c_str(), errno, strerror(errno));
          // LCOV_EXCL_STOP
        } else {
          while (1) {
            ret = stat(l_tmpDest.c_str(), &ostat_buf);
            if (ret < 0) {  // LCOV_EXCL_BR_LINE 5: stat's error case.
              // LCOV_EXCL_START 5: stat's error case.
              AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
              FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. stat(%s). errno: %d, %s",
                     l_tmpDest.c_str(), errno, strerror(errno));
              break;
              // LCOV_EXCL_STOP
            }
            if (ostat_buf.st_size >= istat_buf.st_size) {  // LCOV_EXCL_BR_LINE 5: read and write can not fail, so the size is same  // NOLINT[whitespace/line_length]
              break;
            }
            usleep(10000);  // interval
          }
        }
      }
    }
    close(l_if);

    if (!isWebdav) {  // LCOV_EXCL_BR_LINE 6: isWebdav is aways false
      if (rename(l_tmpDest.c_str(), f_destination.c_str()) != 0) {  // LCOV_EXCL_BR_LINE 5: rename's error case.
        // LCOV_EXCL_START 5: rename's error case.
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "rename %s to %s fail,errno:%d,msg:%s",
               l_tmpDest.c_str(), f_destination.c_str(), errno, strerror(errno));
        // LCOV_EXCL_STOP
      }
    }

    if (std::string::npos != l_pos) {  // LCOV_EXCL_BR_LINE 200: there is always '/' in f_destination
      std::string l_destPath = f_destination.substr(0, l_pos);
      SyncDir(l_destPath);
    } else {
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "dest invalid:%s", f_destination.c_str());  // LCOV_EXCL_LINE 200: there is always '/' in f_destination  // NOLINT[whitespace/line_length]
    }
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}

// LCOV_EXCL_START 8: can not be called
EFrameworkunifiedStatus CLoggerUtil::CopyUntyped(std::string f_source,
                                    std::string f_destination) {
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  struct stat l_stat;
  int l_statRetVal;
  if (0 != access(f_source.c_str(), F_OK)) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           " Error. The specified file path and name does not exist: %s",
           f_source.c_str());
  } else if (0 != (l_statRetVal = lstat(f_source.c_str(), &l_stat))) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           " Error. stat() for file or directory returned error: %s -> %d",
           f_source.c_str(), l_statRetVal);
  } else if (0 != S_ISDIR(l_stat.st_mode)) {
    l_eStatus = CopyDirectory(f_source, f_destination);
  } else if (0 != S_ISLNK(l_stat.st_mode)) {
      // avoid duplicate copy for eErrorEventTypeInterfaceunifiedEmmcLogs: /nv/log/awlog -> /nv/BS/ss/logger_service/rwdata/log2/awlog
      if (f_source.find("/nv/BS/ss/logger_service/rwdata/awlog") == std::string::npos) {
        l_eStatus = CopyDirectory(f_source, f_destination);
      }
  } else if (0 != S_ISREG(l_stat.st_mode)) {
#ifdef RELEASE_BUILD
    l_eStatus = PathCheckAndCopyFile(f_source, f_destination);
#else
    l_eStatus = CopyFile(f_source, f_destination);
#endif  // RELEASE_BUILD
  } else {
    FRAMEWORKUNIFIEDLOG(
        ZONE_ERR,
        __FUNCTION__,
        " Error. specified file may be a symbolic link or other non 'regular' type. File: %s, mode: 0x%04X.",
        f_source.c_str(), l_stat.st_mode);
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}
// LCOV_EXCL_STOP

// LCOV_EXCL_START 8: can not be called
EFrameworkunifiedStatus CLoggerUtil::CopyDirectory(std::string f_source,
                                      std::string f_destination) {
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  DIR * l_pDir = opendir(f_source.c_str());

  if (l_pDir == NULL) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Could not open directory: %s",
           f_source.c_str());
  } else {
    if (mkdir(f_destination.c_str(), 0775) == -1) {
      if (errno == EEXIST) {
        FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "Directory: %s already exists.",
               f_destination.c_str());
      } else {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
               "Could not create directory: %s. Errno: %s",
               f_destination.c_str(), strerror(errno));
        l_eStatus = eFrameworkunifiedStatusFail;
      }
    } else {
      SyncDir(f_destination);
      size_t l_pos = f_destination.find_last_of('/');
      if (l_pos != std::string::npos) {
        std::string l_destPath = f_destination.substr(0, l_pos);
        SyncDir(l_destPath);
      }
    }

    struct dirent l_pDirent;
    struct dirent* next;
    while (0 == readdir_r(l_pDir, &l_pDirent, &next) && next != NULL) {
      if ((0 != strcmp(l_pDirent.d_name, ".")) && /* Ignore special  . directory.                     */
      (0 != strcmp(l_pDirent.d_name, "..")) && /* Ignore special .. directory.                     */
      (0 != strcmp(l_pDirent.d_name, "lost+found")) && /* Ignore lost+found.                     */
      ('.' != l_pDirent.d_name[0])) {  /* Ignore hidden files                              */
        std::string l_fileSource = f_source;
        std::string l_fileDestination = f_destination;
        l_fileSource.append("/");
        l_fileSource.append(l_pDirent.d_name);
        l_fileDestination.append("/");
        l_fileDestination.append(l_pDirent.d_name);
        l_eStatus = CopyUntyped(l_fileSource, l_fileDestination);
      }
    }

    closedir(l_pDir);
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}
// LCOV_EXCL_STOP

// LCOV_EXCL_START 8: can not be called
EFrameworkunifiedStatus CLoggerUtil::MoveFile(std::string f_source,
                                 std::string f_destination) {
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
#ifdef RELEASE_BUILD
  l_eStatus = CLoggerUtil::PathCheckAndCopyFile(f_source, f_destination);
  LOG_STATUS_IF_ERRORED(l_eStatus, "CLoggerUtil::PathCheckAndCopyFile()");
#else
  l_eStatus = CLoggerUtil::CopyFile(f_source, f_destination);
  LOG_STATUS_IF_ERRORED(l_eStatus, "CLoggerUtil::CopyFile()");
#endif  // RELEASE_BUILD
  if (eFrameworkunifiedStatusOK == l_eStatus) {
    l_eStatus = (0 == remove(f_source.c_str())) ? eFrameworkunifiedStatusOK : eFrameworkunifiedStatusFail;
    if (l_eStatus == eFrameworkunifiedStatusOK) {
      size_t l_pos = f_source.find_last_of('/');
      if (std::string::npos != l_pos) {
        std::string l_emmc_path = f_source.substr(0, l_pos);
        SyncDir(l_emmc_path);
      }
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}
// LCOV_EXCL_STOP

// LCOV_EXCL_START 8: can not be called
EFrameworkunifiedStatus CLoggerUtil::MoveUntyped(std::string f_source,
                                    std::string f_destination) {
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
  struct stat l_stat;
  int l_statRetVal;
  if (0 != access(f_source.c_str(), F_OK)) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           " Error. The specified file path and name does not exist: %s",
           f_source.c_str());
  } else if (0 != (l_statRetVal = stat(f_source.c_str(), &l_stat))) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           " Error. stat() for file or directory returned error: %s -> %d",
           f_source.c_str(), l_statRetVal);
  } else if (0 != S_ISDIR(l_stat.st_mode)) {
    l_eStatus = CLoggerUtil::MoveDirectory(f_source, f_destination);
    LOG_STATUS_IF_ERRORED(
        l_eStatus, "CLoggerUtil::MoveDirectory(f_source, f_destination);");
  } else if (0 != S_ISREG(l_stat.st_mode)) {
    l_eStatus = CLoggerUtil::MoveFile(f_source, f_destination);
    LOG_STATUS_IF_ERRORED(l_eStatus,
                          "CLoggerUtil::MoveFile(f_source, f_destination)");
  } else {
    FRAMEWORKUNIFIEDLOG(
        ZONE_ERR,
        __FUNCTION__,
        " Error. specified file may be a symbolic link or other non 'regular' type. File: %s, mode: 0x%04X.",
        f_source.c_str(), l_stat.st_mode);
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}
// LCOV_EXCL_STOP

// LCOV_EXCL_START 8: can not be called
EFrameworkunifiedStatus CLoggerUtil::MoveDirectory(std::string f_source,
                                      std::string f_destination) {
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  DIR * l_pDir = opendir(f_source.c_str());

  if (l_pDir == NULL) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Could not open directory: %s",
           f_source.c_str());
    l_eStatus = eFrameworkunifiedStatusFail;
  } else {
    errno = 0;
    if (mkdir(f_destination.c_str(), 0666) == -1) {
      if (errno == EEXIST) {
        FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "Directory: %s already exists.",
               f_destination.c_str());
      } else {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
               "Could not create directory: %s. Errno: %s",
               f_destination.c_str(), strerror(errno));
        l_eStatus = eFrameworkunifiedStatusFail;
      }
      errno = 0;
    } else {
      SyncDir(f_destination);
      size_t l_pos = f_destination.find_last_of('/');
      if (l_pos != std::string::npos) {
        std::string l_destPath = f_destination.substr(0, l_pos);
        SyncDir(l_destPath);
      }
    }

    if (eFrameworkunifiedStatusOK == l_eStatus) {  /* if directory already exists or has been newly created */
      struct dirent l_pDirent;
      struct dirent* next;

      while (0 == readdir_r(l_pDir, &l_pDirent, &next) && next != NULL) {
        if ((0 != strcmp(l_pDirent.d_name, ".")) && /* Ignore special  . directory.                     */
        (0 != strcmp(l_pDirent.d_name, "..")) && /* Ignore special .. directory.                     */
        (0 != strcmp(l_pDirent.d_name, "lost+found")) && /* Ignore lost+found.                     */
        ('.' != l_pDirent.d_name[0])) {  /* Ignore hidden files                              */
          std::string l_fileSource = f_source;
          std::string l_fileDestination = f_destination;
          l_fileSource.append("/");
          l_fileSource.append(l_pDirent.d_name);
          l_fileDestination.append("/");
          l_fileDestination.append(l_pDirent.d_name);
          l_eStatus = MoveUntyped(l_fileSource, l_fileDestination);
        }
      }
    } else {
    }
    closedir(l_pDir);
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}
// LCOV_EXCL_STOP

// LCOV_EXCL_START 200: can not be called
ELOGGERSERVICELOGTYPE CLoggerUtil::QueryLoggerservicelogType(std::string f_logname) {
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
//  if (f_logname.find("_ILG_RESET.tar.gz") != std::string::npos
  if (f_logname.find(SS_STORE_FILENAME_SYSILG_TERM) != std::string::npos) {
    return eLoggerservicelogTypeAbnormal;
  } else if (f_logname.find(SS_STORE_FILENAME__CWORD52__TERM) != std::string::npos) {
    return eLoggerservicelogTypeAbnormal;
  } else if (f_logname.find("_ILG_RESET.tar.gz") != std::string::npos

      || f_logname.find("_ERR.tar.gz") != std::string::npos) {
    return eLoggerservicelogTypeAbnormal;
  } else if (f_logname.find("_GRP_RELAUNCH.tar.gz") != std::string::npos) {
    return eLoggerservicelogTypeGrpRelaunch;
  } else if (f_logname.find(".tar.gz") != std::string::npos) {
    return eLoggerservicelogTypeNormal;
  } else {
    return eLoggerservicelogTypeOther;
  }
}
// LCOV_EXCL_STOP

void CLoggerUtil::SyncDir(std::string f_dir_path) {
  int fd = open(f_dir_path.c_str(), O_RDONLY | O_DIRECTORY | O_CLOEXEC);
#define OPE_ERR_MSG "%s %s failed. errno:%d,msg:%s"
  if (fd == -1) {  // LCOV_EXCL_BR_LINE 5: open's error case.
    // LCOV_EXCL_START 5: open's error case.
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, OPE_ERR_MSG, f_dir_path.c_str(), "open",
           errno, strerror(errno));
    // LCOV_EXCL_STOP
  } else {
    if (fsync(fd) == -1) {  // LCOV_EXCL_BR_LINE 5: open's error case.
    // LCOV_EXCL_START 5: open's error case.
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, OPE_ERR_MSG, f_dir_path.c_str(), "fsync",
             errno, strerror(errno));
    // LCOV_EXCL_STOP
    }
    if (close(fd) == -1) {  // LCOV_EXCL_BR_LINE 5: open's error case.
    // LCOV_EXCL_START 5: open's error case.
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, OPE_ERR_MSG, f_dir_path.c_str(), "close",
             errno, strerror(errno));
    // LCOV_EXCL_STOP
    }
  }
#undef OPE_ERR_MSG
}