#include "utils.h"

namespace Utils {
std::string CustomErrorCodeToString(CustomErrorCode error) {
  switch (error) {
  case ERROR_NONE:
    return "ERROR_NONE";
  case AUTO_ON_ACTIVE:
    return "AUTO_ON_ACTIVE";
  case DEVICE_NOT_OPENED:
    return "DEVICE_NOT_OPENED";
  case CAPTURE_LOW_QUALITY:
    return "CAPTURE_LOW_QUALITY";
  default:
    return "UNKNOWN_ERROR";
  }
}

std::string CustomErrorCodeToMessage(CustomErrorCode error) {
  switch (error) {
  case ERROR_NONE:
    return "Function Success";
  case AUTO_ON_ACTIVE:
    return "Auto-On is currently active. Please turn off before executing this "
           "function.";
  case DEVICE_NOT_OPENED:
    return "Device is not opened";
  case CAPTURE_LOW_QUALITY:
    return "Capture image quality is too low";
  default:
    return "Unknown error has occured.";
  }
}

std::string SGErrortoString(SGFDxErrorCode error) {
  switch (error) {
  case SGFDX_ERROR_NONE:
    return "ERROR_NONE";
  case SGFDX_ERROR_CREATION_FAILED:
    return "ERROR_CREATION_FAILED";
  case SGFDX_ERROR_FUNCTION_FAILED:
    return "ERROR_FUNCTION_FAILED";
  case SGFDX_ERROR_INVALID_PARAM:
    return "ERROR_INVALID_PARAM";
  case SGFDX_ERROR_NOT_USED:
    return "ERROR_NOT_USED";
  case SGFDX_ERROR_DLLLOAD_FAILED:
    return "ERROR_DLLLOAD_FAILED";
  case SGFDX_ERROR_DLLLOAD_FAILED_DRV:
    return "ERROR_DLLLOAD_FAILED_DRV";
  case SGFDX_ERROR_DLLLOAD_FAILED_ALGO:
    return "ERROR_DLLLOAD_FAILED_ALGO";
  case SGFDX_ERROR_NO_LONGER_SUPPORTED:
    return "ERROR_NO_LONGER_SUPPORTED";
  case SGFDX_ERROR_DLLLOAD_FAILED_WSQ:
    return "ERROR_DLLLOAD_FAILED_WSQ";
  case SGFDX_ERROR_SYSLOAD_FAILED:
    return "ERROR_SYSLOAD_FAILED";
  case SGFDX_ERROR_INITIALIZE_FAILED:
    return "ERROR_INITIALIZE_FAILED";
  case SGFDX_ERROR_LINE_DROPPED:
    return "ERROR_LINE_DROPPED";
  case SGFDX_ERROR_TIME_OUT:
    return "ERROR_TIME_OUT";
  case SGFDX_ERROR_DEVICE_NOT_FOUND:
    return "ERROR_DEVICE_NOT_FOUND";
  case SGFDX_ERROR_WRONG_IMAGE:
    return "ERROR_WRONG_IMAGE";
  case SGFDX_ERROR_LACK_OF_BANDWIDTH:
    return "ERROR_LACK_OF_BANDWIDTH";
  case SGFDX_ERROR_DEV_ALREADY_OPEN:
    return "ERROR_DEV_ALREADY_OPEN";
  case SGFDX_ERROR_GETSN_FAILED:
    return "ERROR_GETSN_FAILED";
  case SGFDX_ERROR_UNSUPPORTED_DEV:
    return "ERROR_UNSUPPORTED_DEV";
  case SGFDX_ERROR_FAKE_FINGER:
    return "ERROR_FAKE_FINGER";
  case SGFDX_ERROR_FAKE_INITIALIZE_FAILED:
    return "ERROR_FAKE_INITIALIZE_FAILED";
  case SGFDX_ERROR_FEAT_NUMBER:
    return "ERROR_FEAT_NUMBER";
  case SGFDX_ERROR_INVALID_TEMPLATE_TYPE:
    return "ERROR_INVALID_TEMPLATE_TYPE";
  case SGFDX_ERROR_INVALID_TEMPLATE1:
    return "ERROR_INVALID_TEMPLATE1";
  case SGFDX_ERROR_INVALID_TEMPLATE2:
    return "ERROR_INVALID_TEMPLATE2";
  case SGFDX_ERROR_EXTRACT_FAIL:
    return "ERROR_EXTRACT_FAIL";
  case SGFDX_ERROR_MATCH_FAIL:
    return "ERROR_MATCH_FAIL";
  case SGFDX_ERROR_LICENSE_LOAD:
    return "ERROR_LICENSE_LOAD";
  case SGFDX_ERROR_LICENSE_KEY:
    return "ERROR_LICENSE_KEY";
  case SGFDX_ERROR_LICENSE_EXPIRED:
    return "ERROR_LICENSE_EXPIRED";
  case SGFDX_ERROR_NO_IMAGE:
    return "ERROR_NO_IMAGE";
  default:
    return "UNKNOWN_ERROR";
  }
}

std::string SGFPMErrorToMessage(int sgfpmError) {
  switch (sgfpmError) {
  case static_cast<int>(SGFDX_ERROR_NONE):
    return "Function Success";
  case static_cast<int>(SGFDX_ERROR_CREATION_FAILED):
    return "Failed to create SGFPM instance";
  case static_cast<int>(SGFDX_ERROR_FUNCTION_FAILED):
    return "Function failed to call for unknown reason";
  case static_cast<int>(SGFDX_ERROR_INVALID_PARAM):
    return "Invalid parameter";
  case static_cast<int>(SGFDX_ERROR_NOT_USED):
    return "Function is not used or not supported";
  case static_cast<int>(SGFDX_ERROR_DLLLOAD_FAILED):
    return "Failed to load sgfplib.dll. Make sure that sgfplib.dll is located "
           "at node's path";
  case static_cast<int>(SGFDX_ERROR_DLLLOAD_FAILED_DRV):
    return "Cannot load device driver";
  case static_cast<int>(SGFDX_ERROR_DLLLOAD_FAILED_ALGO):
    return "Cannot load matching module";
  case static_cast<int>(SGFDX_ERROR_NO_LONGER_SUPPORTED):
    return "Function is no longer supported";
  case static_cast<int>(SGFDX_ERROR_DLLLOAD_FAILED_WSQ):
    return "Sgwsqlib.dll not loaded";
  case static_cast<int>(SGFDX_ERROR_SYSLOAD_FAILED):
    return "Failed to load driver sys file";
  case static_cast<int>(SGFDX_ERROR_INITIALIZE_FAILED):
    return "Failed to initialize device";
  case static_cast<int>(SGFDX_ERROR_LINE_DROPPED):
    return "Image data loss occurred during capture";
  case static_cast<int>(SGFDX_ERROR_TIME_OUT):
    return "Timeout occurred during capture";
  case static_cast<int>(SGFDX_ERROR_DEVICE_NOT_FOUND):
    return "Device not found";
  case static_cast<int>(SGFDX_ERROR_WRONG_IMAGE):
    return "Wrong image - not recognized as a fingerprint image";
  case static_cast<int>(SGFDX_ERROR_LACK_OF_BANDWIDTH):
    return "USB Bandwidth is not sufficient for image transfer";
  case static_cast<int>(SGFDX_ERROR_DEV_ALREADY_OPEN):
    return "Device is already in use";
  case static_cast<int>(SGFDX_ERROR_GETSN_FAILED):
    return "Failed to get serial number of the device";
  case static_cast<int>(SGFDX_ERROR_UNSUPPORTED_DEV):
    return "Cannot determine device type";
  case static_cast<int>(SGFDX_ERROR_FAKE_FINGER):
    return "Fake finger detected";
  case static_cast<int>(SGFDX_ERROR_FAKE_INITIALIZE_FAILED):
    return "Initialization of fake module failed";
  case static_cast<int>(SGFDX_ERROR_FEAT_NUMBER):
    return "Not enough minutiae features";
  case static_cast<int>(SGFDX_ERROR_INVALID_TEMPLATE_TYPE):
    return "Template type is invalid";
  case static_cast<int>(SGFDX_ERROR_INVALID_TEMPLATE1):
    return "1st template is invalid";
  case static_cast<int>(SGFDX_ERROR_INVALID_TEMPLATE2):
    return "2nd template is invalid";
  case static_cast<int>(SGFDX_ERROR_EXTRACT_FAIL):
    return "Failed to extract template";
  case static_cast<int>(SGFDX_ERROR_MATCH_FAIL):
    return "Cannot find matched template";
  case static_cast<int>(SGFDX_ERROR_LICENSE_LOAD):
    return "Failed to load license";
  case static_cast<int>(SGFDX_ERROR_LICENSE_KEY):
    return "Invalid license key";
  case static_cast<int>(SGFDX_ERROR_LICENSE_EXPIRED):
    return "License expired";
  case static_cast<int>(SGFDX_ERROR_NO_IMAGE):
    return "Invalid image";
  default:
    return "Unknown error";
  }
}
} // namespace Utils