/*
 *
 *    Copyright (c) 2013-2017 Nest Labs, Inc.
 *    All rights reserved.
 *
 *    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.
 */

/**
 *    @file
 *      This file implements functions to translate error codes used
 *      throughout the Weave package into human-readable strings.
 *
 */

#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif

#include <inttypes.h>
#include <stdio.h>

#include <SystemLayer/SystemError.h>

#if CONFIG_NETWORK_LAYER_BLE
#include <BleLayer/BleError.h>
#endif // CONFIG_NETWORK_LAYER_BLE

#include <InetLayer/InetError.h>
#include <Weave/Core/WeaveCore.h>
#include <Weave/Support/CodeUtils.h>

#include "ASN1Error.h"

namespace nl {

#if WEAVE_CONFIG_SHORT_ERROR_STR

/**
 *  @def ERROR_STR_SIZE
 *
 *  @brief
 *    This defines the size of the buffer to store the formatted error string.
 *
 *    Static buffer to store the short version of error string, which includes
 *    subsystem name and 32-bit error code in hex
 *
 *    At max 22 bytes would be needed according to this calculation/formating:
 *    - 10 characters for subsystem name,
 *    - ':',
 *    - "0x", 8 characters for error code in hex,
 *    - '\0'
 *
 *        An example would be "Weave:0xDEAFBEEF"
 *        - The output string would be truncated if the subsystem name is longer
 *      than 10
 */
#define ERROR_STR_SIZE (10 + 3 + 8 + 1)

/**
 *  @def _SubsystemFormatError(name, err, desc)
 *
 *  @brief
 *    This defines a function that formats the specified error and string
 *    describing the subsystem into a platform- or system-specific manner.
 *
 */
#define _SubsystemFormatError(name, err, desc) SubsystemFormatError(name, err)

#else // #if WEAVE_CONFIG_SHORT_ERROR_STR

/**
 *  @def ERROR_STR_SIZE
 *
 *  @brief
 *    This defines the size of the buffer to store the formatted error string.
 *
 *    Note that the size is arbitrary and probably doesn't have to be this big.
 *    On platforms where 1kB RAM matters, it is probably better to choose the
 *    short version, or don't call ErrorStr at all.
 *
 */
#define ERROR_STR_SIZE (1000)

/**
 *  @def _SubsystemFormatError(name, err, desc)
 *
 *  @brief
 *    This defines a function that formats the specified error and string
 *    describing the subsystem into a platform- or system-specific manner.
 *
 */
#define _SubsystemFormatError(name, err, desc) SubsystemFormatError(name, err, desc)

#endif // #if WEAVE_CONFIG_SHORT_ERROR_STR


/**
 *  @var static char sErrorStr[ERROR_STR_SIZE]
 *
 *  @brief
 *    Static buffer to store the formated error string
 *
 */
static char sErrorStr[ERROR_STR_SIZE];

/**
 * This routine formats the specified error into a human-readable
 * NULL-terminated C string describing the provided error.
 *
 * @param[in] err    The error for formatting and description.
 *
 * @return A pointer to a NULL-terminated C string describing the
 *         provided error.
 */
static const char *FormatError(int32_t err)
{
#if WEAVE_CONFIG_SHORT_ERROR_STR
    (void)snprintf(sErrorStr, sizeof(sErrorStr), "Error 0x%" PRIx32, err);
#else
    (void)snprintf(sErrorStr, sizeof(sErrorStr), "Error %" PRId32, err);
#endif
    return sErrorStr;
}

/**
 * This routine formats the specified error and string describing the
 * subsystem into the provided format string and returns a human-readable
 * NULL-terminated C string describing the provided error.
 *
 * @param[in] subsystem  A pointer to a NULL-terminated C string representing
 *                       the package subsystem to which the error corresponds.
 * @param[in] err        The error for formatting and description.
 *
 * @return A pointer to a NULL-terminated C string describing the
 *         provided error.
 */
static const char *SubsystemFormatError(const char *subsystem, int32_t err)
{
    // note that snprintf shall zero-terminate the string as long as sizeof(sErrorStr) > 0
    // note that the return value of snprintf is ignored for an error is very unlikely to happen and we do not care about truncation
#if WEAVE_CONFIG_SHORT_ERROR_STR
    (void)snprintf(sErrorStr, sizeof(sErrorStr), "%s:0x%" PRIx32, subsystem, err);
#else
    (void)snprintf(sErrorStr, sizeof(sErrorStr), "%s Error %" PRId32, subsystem, err);
#endif
    return sErrorStr;
}

#if !(WEAVE_CONFIG_SHORT_ERROR_STR)

/**
 * This routine formats the specified error and string describing the
 * subsystem into the provided format string and returns a human-readable
 * NULL-terminated C string describing the provided error.
 *
 * @param[in] subsystem    A pointer to a NULL-terminated C string representing
 *                         the package subsystem to which the error corresponds.
 * @param[in] err          The error for formatting and description.
 * @param[in] description  A pointer to a NULL-terminated C string describing
 *                         the error. Ignored when WEAVE_CONFIG_SHORT_ERROR_STR is defined
 *
 * @return A pointer to a NULL-terminated C string describing the
 *         provided error.
 */
static const char *SubsystemFormatError(const char *subsystem, int32_t err, const char *description)
{
    (void)snprintf(sErrorStr, sizeof(sErrorStr), "%s Error %" PRId32 ": %s", subsystem, err, description);
    return sErrorStr;
}

/**
 * This routine formats the specified error and string describing the
 * System layer into the provided format string and returns a human-readable
 * NULL-terminated C string describing the provided error.
 *
 * @param[in] err          The error for formatting and description.
 * @param[in] description  A pointer to a NULL-terminated C string describing
 *                         the error. Ignored when WEAVE_CONFIG_SHORT_ERROR_STR is defined
 *
 * @return A pointer to a NULL-terminated C string describing the
 *         provided error.
 */
static const char *SystemLayerFormatError(int32_t err, const char *description)
{
    return SubsystemFormatError("Sys", err, description);
}

/**
 * This routine formats the specified error and string describing the
 * Inet layer into the provided format string and returns a human-readable
 * NULL-terminated C string describing the provided error.
 *
 * @param[in] err          The error for formatting and description.
 * @param[in] description  A pointer to a NULL-terminated C string describing
 *                         the error. Ignored when WEAVE_CONFIG_SHORT_ERROR_STR is defined
 *
 * @return A pointer to a NULL-terminated C string describing the
 *         provided error.
 */
static const char *InetFormatError(int32_t err, const char *description)
{
    return SubsystemFormatError("Inet", err, description);
}

#if CONFIG_NETWORK_LAYER_BLE
/**
 * This routine formats the specified error and string describing the
 * BLE layer into the provided format string and returns a human-readable
 * NULL-terminated C string describing the provided error.
 *
 * @param[in] err          The error for formatting and description.
 * @param[in] description  A pointer to a NULL-terminated C string describing
 *                         the error. Ignored when WEAVE_CONFIG_SHORT_ERROR_STR is defined
 *
 * @return A pointer to a NULL-terminated C string describing the
 *         provided error.
 */
static const char *BleFormatError(int32_t err, const char *description)
{
    return SubsystemFormatError("Ble", err, description);
}
#endif // CONFIG_NETWORK_LAYER_BLE

/**
 * This routine formats the specified error and string describing Weave
 * into the provided format string and returns a human-readable NULL-terminated
 * C string describing the provided error.
 *
 * @param[in] err          The error for formatting and description.
 * @param[in] description  A pointer to a NULL-terminated C string describing
 *                         the error. Ignored when WEAVE_CONFIG_SHORT_ERROR_STR is defined
 *
 * @return A pointer to a NULL-terminated C string describing the
 *         provided error.
 */
static const char *WeaveFormatError(int32_t err, const char *description)
{
    return SubsystemFormatError("Weave", err, description);
}

/**
 * This routine formats the specified error and string describing ASN1
 * into the provided format string and returns a human-readable NULL-terminated
 * C string describing the provided error.
 *
 * @param[in] err          The error for formatting and description.
 * @param[in] description  A pointer to a NULL-terminated C string describing
 *                         the error. Ignored when WEAVE_CONFIG_SHORT_ERROR_STR is defined
 *
 * @return A pointer to a NULL-terminated C string describing the
 *         provided error.
 */
static const char *ASN1FormatError(int32_t err, const char *description)
{
    return SubsystemFormatError("ASN1", err, description);
}
#endif // #if !(WEAVE_CONFIG_SHORT_ERROR_STR)

/**
 * This routine returns a human-readable NULL-terminated C string
 * describing the provided error.
 *
 * @param[in] err     The error for format and describe.
 *
 * @return A pointer to a NULL-terminated C string describing the
 *         provided error.
 */
NL_DLL_EXPORT const char *ErrorStr(int32_t err)
{
    switch (err)
    {
    case 0                                                      : return "No Error";

#if !WEAVE_CONFIG_SHORT_ERROR_STR
    // ----- SystemLayer Errors ----
    case WEAVE_SYSTEM_ERROR_NOT_IMPLEMENTED                     : return SystemLayerFormatError(err, "Not implemented");
    case WEAVE_SYSTEM_ERROR_NOT_SUPPORTED                       : return SystemLayerFormatError(err, "Not supported");
    case WEAVE_SYSTEM_ERROR_BAD_ARGS                            : return SystemLayerFormatError(err, "Bad arguments");
    case WEAVE_SYSTEM_ERROR_UNEXPECTED_STATE                    : return SystemLayerFormatError(err, "Unexpected state");
    case WEAVE_SYSTEM_ERROR_UNEXPECTED_EVENT                    : return SystemLayerFormatError(err, "Unexpected event");
    case WEAVE_SYSTEM_ERROR_NO_MEMORY                           : return SystemLayerFormatError(err, "No memory");

    // ----- InetLayer Errors -----
    case INET_ERROR_WRONG_ADDRESS_TYPE                          : return InetFormatError(err, "Wrong address type");
    case INET_ERROR_CONNECTION_ABORTED                          : return InetFormatError(err, "TCP connection aborted");
    case INET_ERROR_PEER_DISCONNECTED                           : return InetFormatError(err, "Peer disconnected");
    case INET_ERROR_INCORRECT_STATE                             : return InetFormatError(err, "Incorrect state");
    case INET_ERROR_MESSAGE_TOO_LONG                            : return InetFormatError(err, "Message too long");
    case INET_ERROR_NO_CONNECTION_HANDLER                       : return InetFormatError(err, "No TCP connection handler");
    case INET_ERROR_NO_MEMORY                                   : return InetFormatError(err, "No memory");
    case INET_ERROR_OUTBOUND_MESSAGE_TRUNCATED                  : return InetFormatError(err, "Outbound message truncated");
    case INET_ERROR_INBOUND_MESSAGE_TOO_BIG                     : return InetFormatError(err, "Inbound message too big");
    case INET_ERROR_HOST_NOT_FOUND                              : return InetFormatError(err, "Host not found");
    case INET_ERROR_DNS_TRY_AGAIN                               : return InetFormatError(err, "DNS try again");
    case INET_ERROR_DNS_NO_RECOVERY                             : return InetFormatError(err, "DNS no recovery");
    case INET_ERROR_BAD_ARGS                                    : return InetFormatError(err, "Bad arguments");
    case INET_ERROR_WRONG_PROTOCOL_TYPE                         : return InetFormatError(err, "Wrong protocol type");
    case INET_ERROR_UNKNOWN_INTERFACE                           : return InetFormatError(err, "Unknown interface");
    case INET_ERROR_NOT_IMPLEMENTED                             : return InetFormatError(err, "Not implemented");
    case INET_ERROR_ADDRESS_NOT_FOUND                           : return InetFormatError(err, "Address not found");
    case INET_ERROR_HOST_NAME_TOO_LONG                          : return InetFormatError(err, "Host name too long");
    case INET_ERROR_INVALID_HOST_NAME                           : return InetFormatError(err, "Invalid host name");
    case INET_ERROR_NOT_SUPPORTED                               : return InetFormatError(err, "Not supported");
    case INET_ERROR_NO_ENDPOINTS                                : return InetFormatError(err, "No more TCP endpoints");
    case INET_ERROR_IDLE_TIMEOUT                                : return InetFormatError(err, "Idle timeout");
    case INET_ERROR_UNEXPECTED_EVENT                            : return InetFormatError(err, "Unexpected event");
    case INET_ERROR_INVALID_IPV6_PKT                            : return InetFormatError(err, "Invalid IPv6 Packet");
    case INET_ERROR_INTERFACE_INIT_FAILURE                      : return InetFormatError(err, "Failure to initialize interface");
    case INET_ERROR_TCP_USER_TIMEOUT                            : return InetFormatError(err, "TCP User Timeout");
    case INET_ERROR_TCP_CONNECT_TIMEOUT                         : return InetFormatError(err, "TCP Connect Timeout");

#if CONFIG_NETWORK_LAYER_BLE
    // ----- BleLayer Errors -----
    case BLE_ERROR_BAD_ARGS                                     : return BleFormatError(err, "Bad arguments");
    case BLE_ERROR_INCORRECT_STATE                              : return BleFormatError(err, "Incorrect state");
    case BLE_ERROR_NO_ENDPOINTS                                 : return BleFormatError(err, "No more BLE endpoints");
    case BLE_ERROR_NO_CONNECTION_RECEIVED_CALLBACK              : return BleFormatError(err, "No Weave over BLE connection received callback set");
    case BLE_ERROR_CENTRAL_UNSUBSCRIBED                         : return BleFormatError(err, "BLE central unsubscribed");
    case BLE_ERROR_GATT_SUBSCRIBE_FAILED                        : return BleFormatError(err, "GATT subscribe operation failed");
    case BLE_ERROR_GATT_UNSUBSCRIBE_FAILED                      : return BleFormatError(err, "GATT unsubscribe operation failed");
    case BLE_ERROR_GATT_WRITE_FAILED                            : return BleFormatError(err, "GATT write characteristic operation failed");
    case BLE_ERROR_GATT_INDICATE_FAILED                         : return BleFormatError(err, "GATT indicate characteristic operation failed");
    case BLE_ERROR_NOT_IMPLEMENTED                              : return BleFormatError(err, "Not implemented");
    case BLE_ERROR_INVALID_ROLE                                 : return BleFormatError(err, "Invalid BLE device role specified");
    case BLE_ERROR_WOBLE_PROTOCOL_ABORT                         : return BleFormatError(err, "BLE transport protocol fired abort");
    case BLE_ERROR_REMOTE_DEVICE_DISCONNECTED                   : return BleFormatError(err, "Remote device closed BLE connection");
    case BLE_ERROR_APP_CLOSED_CONNECTION                        : return BleFormatError(err, "Application closed BLE connection");
    case BLE_ERROR_OUTBOUND_MESSAGE_TOO_BIG                     : return BleFormatError(err, "Outbound message too big");
    case BLE_ERROR_NOT_WEAVE_DEVICE                             : return BleFormatError(err, "BLE device doesn't seem to support Weave");
    case BLE_ERROR_INCOMPATIBLE_PROTOCOL_VERSIONS               : return BleFormatError(err, "Incompatible BLE transport protocol versions");
    case BLE_ERROR_NO_MEMORY                                    : return BleFormatError(err, "No memory");
    case BLE_ERROR_MESSAGE_INCOMPLETE                           : return BleFormatError(err, "Message incomplete");
    case BLE_ERROR_INVALID_FRAGMENT_SIZE                        : return BleFormatError(err, "Invalid fragment size");
    case BLE_ERROR_START_TIMER_FAILED                           : return BleFormatError(err, "Start timer failed");
    case BLE_ERROR_CONNECT_TIMED_OUT                            : return BleFormatError(err, "Connect handshake timed out");
    case BLE_ERROR_RECEIVE_TIMED_OUT                            : return BleFormatError(err, "Receive handshake timed out");
    case BLE_ERROR_INVALID_MESSAGE                              : return BleFormatError(err, "Invalid message");
    case BLE_ERROR_FRAGMENT_ACK_TIMED_OUT                       : return BleFormatError(err, "Message fragment acknowledgement timed out");
    case BLE_ERROR_KEEP_ALIVE_TIMED_OUT                         : return BleFormatError(err, "Keep-alive receipt timed out");
    case BLE_ERRROR_NO_CONNECT_COMPLETE_CALLBACK                : return BleFormatError(err, "Missing required callback");
    case BLE_ERROR_INVALID_ACK                                  : return BleFormatError(err, "Received invalid BLE transport protocol fragment acknowledgement");
    case BLE_ERROR_REASSEMBLER_MISSING_DATA                     : return BleFormatError(err, "BLE message reassembler did not receive enough data");
    case BLE_ERROR_INVALID_BTP_HEADER_FLAGS                     : return BleFormatError(err, "Received invalid BLE transport protocol header flags");
    case BLE_ERROR_INVALID_BTP_SEQUENCE_NUMBER                  : return BleFormatError(err, "Received invalid BLE transport protocol sequence number");
    case BLE_ERROR_REASSEMBLER_INCORRECT_STATE                  : return BleFormatError(err, "BLE message reassembler received packet in incorrect state");
    case BLE_ERROR_RECEIVED_MESSAGE_TOO_BIG                     : return BleFormatError(err, "Message received by BLE message reassembler was too large");
#endif // CONFIG_NETWORK_LAYER_BLE

    // ----- Weave Errors -----
    case WEAVE_ERROR_TOO_MANY_CONNECTIONS                       : return WeaveFormatError(err, "Too many connections");
    case WEAVE_ERROR_SENDING_BLOCKED                            : return WeaveFormatError(err, "Sending blocked");
    case WEAVE_ERROR_CONNECTION_ABORTED                         : return WeaveFormatError(err, "Connection aborted");
    case WEAVE_ERROR_INCORRECT_STATE                            : return WeaveFormatError(err, "Incorrect state");
    case WEAVE_ERROR_MESSAGE_TOO_LONG                           : return WeaveFormatError(err, "Message too long");
    case WEAVE_ERROR_UNSUPPORTED_EXCHANGE_VERSION               : return WeaveFormatError(err, "Unsupported exchange version");
    case WEAVE_ERROR_TOO_MANY_UNSOLICITED_MESSAGE_HANDLERS      : return WeaveFormatError(err, "Too many unsolicited message handlers");
    case WEAVE_ERROR_NO_UNSOLICITED_MESSAGE_HANDLER             : return WeaveFormatError(err, "No unsolicited message handler");
    case WEAVE_ERROR_NO_CONNECTION_HANDLER                      : return WeaveFormatError(err, "No connection handler");
    case WEAVE_ERROR_TOO_MANY_PEER_NODES                        : return WeaveFormatError(err, "Too many peer nodes");
    case WEAVE_ERROR_NO_MEMORY                                  : return WeaveFormatError(err, "No memory");
    case WEAVE_ERROR_NO_MESSAGE_HANDLER                         : return WeaveFormatError(err, "No message handler");
    case WEAVE_ERROR_MESSAGE_INCOMPLETE                         : return WeaveFormatError(err, "Message incomplete");
    case WEAVE_ERROR_DATA_NOT_ALIGNED                           : return WeaveFormatError(err, "Data not aligned");
    case WEAVE_ERROR_UNKNOWN_KEY_TYPE                           : return WeaveFormatError(err, "Unknown key type");
    case WEAVE_ERROR_KEY_NOT_FOUND                              : return WeaveFormatError(err, "Key not found");
    case WEAVE_ERROR_WRONG_ENCRYPTION_TYPE                      : return WeaveFormatError(err, "Wrong encryption type");
    case WEAVE_ERROR_TOO_MANY_KEYS                              : return WeaveFormatError(err, "Too many keys");
    case WEAVE_ERROR_INTEGRITY_CHECK_FAILED                     : return WeaveFormatError(err, "Integrity check failed");
    case WEAVE_ERROR_INVALID_SIGNATURE                          : return WeaveFormatError(err, "Invalid signature");
    case WEAVE_ERROR_UNSUPPORTED_MESSAGE_VERSION                : return WeaveFormatError(err, "Unsupported message version");
    case WEAVE_ERROR_UNSUPPORTED_ENCRYPTION_TYPE                : return WeaveFormatError(err, "Unsupported encryption type");
    case WEAVE_ERROR_UNSUPPORTED_SIGNATURE_TYPE                 : return WeaveFormatError(err, "Unsupported signature type");
    case WEAVE_ERROR_INVALID_MESSAGE_LENGTH                     : return WeaveFormatError(err, "Invalid message length");
    case WEAVE_ERROR_BUFFER_TOO_SMALL                           : return WeaveFormatError(err, "Buffer too small");
    case WEAVE_ERROR_DUPLICATE_KEY_ID                           : return WeaveFormatError(err, "Duplicate key id");
    case WEAVE_ERROR_WRONG_KEY_TYPE                             : return WeaveFormatError(err, "Wrong key type");
    case WEAVE_ERROR_WELL_UNINITIALIZED                         : return WeaveFormatError(err, "Well uninitialized");
    case WEAVE_ERROR_WELL_EMPTY                                 : return WeaveFormatError(err, "Well empty");
    case WEAVE_ERROR_INVALID_STRING_LENGTH                      : return WeaveFormatError(err, "Invalid string length");
    case WEAVE_ERROR_INVALID_LIST_LENGTH                        : return WeaveFormatError(err, "invalid list length");
    case WEAVE_ERROR_INVALID_INTEGRITY_TYPE                     : return WeaveFormatError(err, "Invalid integrity type");
    case WEAVE_END_OF_TLV                                       : return WeaveFormatError(err, "End of TLV");
    case WEAVE_ERROR_TLV_UNDERRUN                               : return WeaveFormatError(err, "TLV underrun");
    case WEAVE_ERROR_INVALID_TLV_ELEMENT                        : return WeaveFormatError(err, "Invalid TLV element");
    case WEAVE_ERROR_INVALID_TLV_TAG                            : return WeaveFormatError(err, "Invalid TLV tag");
    case WEAVE_ERROR_UNKNOWN_IMPLICIT_TLV_TAG                   : return WeaveFormatError(err, "Unknown implicit TLV tag");
    case WEAVE_ERROR_WRONG_TLV_TYPE                             : return WeaveFormatError(err, "Wrong TLV type");
    case WEAVE_ERROR_TLV_CONTAINER_OPEN                         : return WeaveFormatError(err, "TLV container open");
    case WEAVE_ERROR_INVALID_TRANSFER_MODE                      : return WeaveFormatError(err, "Invalid transfer mode");
    case WEAVE_ERROR_INVALID_PROFILE_ID                         : return WeaveFormatError(err, "Invalid profile id");
    case WEAVE_ERROR_INVALID_MESSAGE_TYPE                       : return WeaveFormatError(err, "Invalid message type");
    case WEAVE_ERROR_UNEXPECTED_TLV_ELEMENT                     : return WeaveFormatError(err, "Unexpected TLV element");
    case WEAVE_ERROR_STATUS_REPORT_RECEIVED                     : return WeaveFormatError(err, "Status Report received from peer");
    case WEAVE_ERROR_NOT_IMPLEMENTED                            : return WeaveFormatError(err, "Not Implemented");
    case WEAVE_ERROR_INVALID_ADDRESS                            : return WeaveFormatError(err, "Invalid address");
    case WEAVE_ERROR_INVALID_ARGUMENT                           : return WeaveFormatError(err, "Invalid argument");
    case WEAVE_ERROR_TLV_TAG_NOT_FOUND                          : return WeaveFormatError(err, "TLV tag not found");

    case WEAVE_ERROR_INVALID_PATH_LIST                          : return WeaveFormatError(err, "Invalid TLV path list");
    case WEAVE_ERROR_INVALID_DATA_LIST                          : return WeaveFormatError(err, "Invalid TLV data list");
    case WEAVE_ERROR_TRANSACTION_CANCELED                       : return WeaveFormatError(err, "Transaction canceled");
    case WEAVE_ERROR_LISTENER_ALREADY_STARTED                   : return WeaveFormatError(err, "Listener already started");
    case WEAVE_ERROR_LISTENER_ALREADY_STOPPED                   : return WeaveFormatError(err, "Listener already stopped");
    case WEAVE_ERROR_UNKNOWN_TOPIC                              : return WeaveFormatError(err, "Unknown Topic");

    case WEAVE_ERROR_TIMEOUT                                    : return WeaveFormatError(err, "Timeout");
    case WEAVE_ERROR_INVALID_DEVICE_DESCRIPTOR                  : return WeaveFormatError(err, "Invalid device descriptor");
    case WEAVE_ERROR_UNSUPPORTED_DEVICE_DESCRIPTOR_VERSION      : return WeaveFormatError(err, "Unsupported device descriptor version");
    case WEAVE_END_OF_INPUT                                     : return WeaveFormatError(err, "End of input");
    case WEAVE_ERROR_RATE_LIMIT_EXCEEDED                        : return WeaveFormatError(err, "Rate limit exceeded");
    case WEAVE_ERROR_SECURITY_MANAGER_BUSY                      : return WeaveFormatError(err, "Security manager busy");
    case WEAVE_ERROR_INVALID_PASE_PARAMETER                     : return WeaveFormatError(err, "Invalid PASE parameter");
    case WEAVE_ERROR_PASE_SUPPORTS_ONLY_CONFIG1                 : return WeaveFormatError(err, "PASE supports only Config1");
    case WEAVE_ERROR_NO_COMMON_PASE_CONFIGURATIONS              : return WeaveFormatError(err, "No supported PASE configurations in common");
    case WEAVE_ERROR_INVALID_PASE_CONFIGURATION                 : return WeaveFormatError(err, "Invalid PASE configuration");
    case WEAVE_ERROR_KEY_CONFIRMATION_FAILED                    : return WeaveFormatError(err, "Key confirmation failed");
    case WEAVE_ERROR_INVALID_USE_OF_SESSION_KEY                 : return WeaveFormatError(err, "Invalid use of session key");
    case WEAVE_ERROR_CONNECTION_CLOSED_UNEXPECTEDLY             : return WeaveFormatError(err, "Connection closed unexpectedly");
    case WEAVE_ERROR_MISSING_TLV_ELEMENT                        : return WeaveFormatError(err, "Missing TLV element");
    case WEAVE_ERROR_RANDOM_DATA_UNAVAILABLE                    : return WeaveFormatError(err, "Random data unavailable");
    case WEAVE_ERROR_UNSUPPORTED_HOST_PORT_ELEMENT              : return WeaveFormatError(err, "Unsupported type in host/port list");
    case WEAVE_ERROR_INVALID_HOST_SUFFIX_INDEX                  : return WeaveFormatError(err, "Invalid suffix index in host/port list");
    case WEAVE_ERROR_HOST_PORT_LIST_EMPTY                       : return WeaveFormatError(err, "Host/port empty");
    case WEAVE_ERROR_UNSUPPORTED_AUTH_MODE                      : return WeaveFormatError(err, "Unsupported authentication mode");

    case WEAVE_ERROR_INVALID_SERVICE_EP                         : return WeaveFormatError(err, "Invalid service endpoint");
    case WEAVE_ERROR_INVALID_DIRECTORY_ENTRY_TYPE               : return WeaveFormatError(err, "Invalid directory entry type");
    case WEAVE_ERROR_FORCED_RESET                               : return WeaveFormatError(err, "Service manager forced reset");
    case WEAVE_ERROR_NO_ENDPOINT                                : return WeaveFormatError(err, "No endpoint was available to send the message");
    case WEAVE_ERROR_INVALID_DESTINATION_NODE_ID                : return WeaveFormatError(err, "Invalid destination node id");
    case WEAVE_ERROR_NOT_CONNECTED                              : return WeaveFormatError(err, "Not connected");
    case WEAVE_ERROR_NO_SW_UPDATE_AVAILABLE                     : return WeaveFormatError(err, "No SW update available");

    case WEAVE_ERROR_CA_CERT_NOT_FOUND                          : return WeaveFormatError(err, "CA certificate not found");
    case WEAVE_ERROR_CERT_PATH_LEN_CONSTRAINT_EXCEEDED          : return WeaveFormatError(err, "Certificate path length constraint exceeded");
    case WEAVE_ERROR_CERT_PATH_TOO_LONG                         : return WeaveFormatError(err, "Certificate path too long");
    case WEAVE_ERROR_CERT_USAGE_NOT_ALLOWED                     : return WeaveFormatError(err, "Requested certificate usage is not allowed");
    case WEAVE_ERROR_CERT_EXPIRED                               : return WeaveFormatError(err, "Certificate expired");
    case WEAVE_ERROR_CERT_NOT_VALID_YET                         : return WeaveFormatError(err, "Certificate not yet valid");
    case WEAVE_ERROR_UNSUPPORTED_CERT_FORMAT                    : return WeaveFormatError(err, "Unsupported certificate format");
    case WEAVE_ERROR_UNSUPPORTED_ELLIPTIC_CURVE                 : return WeaveFormatError(err, "Unsupported elliptic curve");
    case WEAVE_CERT_NOT_USED                                    : return WeaveFormatError(err, "Certificate was not used in chain validation");
    case WEAVE_ERROR_CERT_NOT_FOUND                             : return WeaveFormatError(err, "Certificate not found");
    case WEAVE_ERROR_INVALID_CASE_PARAMETER                     : return WeaveFormatError(err, "Invalid CASE parameter");
    case WEAVE_ERROR_UNSUPPORTED_CASE_CONFIGURATION             : return WeaveFormatError(err, "Unsupported CASE configuration");
    case WEAVE_ERROR_CERT_LOAD_FAIL                             : return WeaveFormatError(err, "Unable to load certificate");
    case WEAVE_ERROR_CERT_NOT_TRUSTED                           : return WeaveFormatError(err, "Certificate not trusted");
    case WEAVE_ERROR_INVALID_ACCESS_TOKEN                       : return WeaveFormatError(err, "Invalid access token");
    case WEAVE_ERROR_WRONG_CERT_SUBJECT                         : return WeaveFormatError(err, "Wrong certificate subject");
    case WEAVE_ERROR_WRONG_NODE_ID                              : return WeaveFormatError(err, "Wrong node ID");
    case WEAVE_ERROR_CONN_ACCEPTED_ON_WRONG_PORT                : return WeaveFormatError(err, "Connection accepted on wrong port");
    case WEAVE_ERROR_CALLBACK_REPLACED                          : return WeaveFormatError(err, "Application callback replaced");
    case WEAVE_ERROR_NO_CASE_AUTH_DELEGATE                      : return WeaveFormatError(err, "No CASE auth delegate set");
    case WEAVE_ERROR_DEVICE_LOCATE_TIMEOUT                      : return WeaveFormatError(err, "Timeout attempting to locate device");
    case WEAVE_ERROR_DEVICE_CONNECT_TIMEOUT                     : return WeaveFormatError(err, "Timeout connecting to device");
    case WEAVE_ERROR_DEVICE_AUTH_TIMEOUT                        : return WeaveFormatError(err, "Timeout authenticating device");
    case WEAVE_ERROR_MESSAGE_NOT_ACKNOWLEDGED                   : return WeaveFormatError(err, "Message not acknowledged after max retries");
    case WEAVE_ERROR_RETRANS_TABLE_FULL                         : return WeaveFormatError(err, "Retransmit Table is already full");
    case WEAVE_ERROR_INVALID_ACK_ID                             : return WeaveFormatError(err, "Invalid Acknowledgment Id");
    case WEAVE_ERROR_SEND_THROTTLED                             : return WeaveFormatError(err, "Sending to peer is throttled on this Exchange");
    case WEAVE_ERROR_WRONG_MSG_VERSION_FOR_EXCHANGE             : return WeaveFormatError(err, "Message version not supported by current exchange context");
    case WEAVE_ERROR_UNSUPPORTED_WEAVE_FEATURE                  : return WeaveFormatError(err, "Required feature not supported by this configuration");
    case WEAVE_ERROR_UNSOLICITED_MSG_NO_ORIGINATOR              : return WeaveFormatError(err, "Unsolicited msg with originator bit clear");
    case WEAVE_ERROR_UNSUPPORTED_TUNNEL_VERSION                 : return WeaveFormatError(err, "Unsupported Tunnel version");
    case WEAVE_ERROR_INVALID_FABRIC_ID                          : return WeaveFormatError(err, "Invalid Fabric Id");
    case WEAVE_ERROR_TUNNEL_NEXTHOP_TABLE_FULL                  : return WeaveFormatError(err, "Local tunnel nexthop table full");
    case WEAVE_ERROR_TUNNEL_SERVICE_QUEUE_FULL                  : return WeaveFormatError(err, "Service queue full");
    case WEAVE_ERROR_TUNNEL_PEER_ENTRY_NOT_FOUND                : return WeaveFormatError(err, "Shortcut Tunnel peer entry not found");
    case WEAVE_ERROR_TUNNEL_FORCE_ABORT                         : return WeaveFormatError(err, "Forced Tunnel Abort.");
    case WEAVE_ERROR_DRBG_ENTROPY_SOURCE_FAILED                 : return WeaveFormatError(err, "DRBG entropy source failed to generate entropy data");
    case WEAVE_ERROR_NO_TAKE_AUTH_DELEGATE                      : return WeaveFormatError(err, "No TAKE auth delegate set");
    case WEAVE_ERROR_TAKE_RECONFIGURE_REQUIRED                  : return WeaveFormatError(err, "TAKE requires a reconfigure");
    case WEAVE_ERROR_TAKE_REAUTH_POSSIBLE                       : return WeaveFormatError(err, "TAKE can do a reauthentication");
    case WEAVE_ERROR_INVALID_TAKE_PARAMETER                     : return WeaveFormatError(err, "TAKE received an invalid parameter");
    case WEAVE_ERROR_UNSUPPORTED_TAKE_CONFIGURATION             : return WeaveFormatError(err, "TAKE Unsupported configuration");
    case WEAVE_ERROR_TAKE_TOKEN_IDENTIFICATION_FAILED           : return WeaveFormatError(err, "TAKE token identification failed");
    case WEAVE_ERROR_INVALID_TOKENPAIRINGBUNDLE                 : return WeaveFormatError(err, "Invalid Token Pairing Bundle");
    case WEAVE_ERROR_UNSUPPORTED_TOKENPAIRINGBUNDLE_VERSION     : return WeaveFormatError(err, "Unsupported Token Pairing Bundle version");
    case WEAVE_ERROR_KEY_NOT_FOUND_FROM_PEER                    : return WeaveFormatError(err, "Key not found error code received from peer");
    case WEAVE_ERROR_WRONG_ENCRYPTION_TYPE_FROM_PEER            : return WeaveFormatError(err, "Wrong encryption type error code received from peer");
    case WEAVE_ERROR_UNKNOWN_KEY_TYPE_FROM_PEER                 : return WeaveFormatError(err, "Unknown key type error code received from peer");
    case WEAVE_ERROR_INVALID_USE_OF_SESSION_KEY_FROM_PEER       : return WeaveFormatError(err, "Invalid use of session key error code received from peer");
    case WEAVE_ERROR_UNSUPPORTED_ENCRYPTION_TYPE_FROM_PEER      : return WeaveFormatError(err, "Unsupported encryption type error code received from peer");
    case WEAVE_ERROR_INTERNAL_KEY_ERROR_FROM_PEER               : return WeaveFormatError(err, "Internal key error code received from peer");
    case WEAVE_ERROR_INVALID_KEY_ID                             : return WeaveFormatError(err, "Invalid key identifier");
    case WEAVE_ERROR_INVALID_TIME                               : return WeaveFormatError(err, "Valid time value is not available");
    case WEAVE_ERROR_LOCKING_FAILURE                            : return WeaveFormatError(err, "Failure to lock/unlock OS-provided lock");
    case WEAVE_ERROR_UNSUPPORTED_PASSCODE_CONFIG                : return WeaveFormatError(err, "Unsupported passcode encryption configuration.");
    case WEAVE_ERROR_PASSCODE_AUTHENTICATION_FAILED             : return WeaveFormatError(err, "Passcode authentication failed.");
    case WEAVE_ERROR_PASSCODE_FINGERPRINT_FAILED                : return WeaveFormatError(err, "Passcode fingerprint failed.");
    case WEAVE_ERROR_SERIALIZATION_ELEMENT_NULL                 : return WeaveFormatError(err, "Element requested is null.");
    case WEAVE_ERROR_WRONG_CERT_SIGNATURE_ALGORITHM             : return WeaveFormatError(err, "Certificate not signed with required signature algorithm");
    case WEAVE_ERROR_WRONG_WEAVE_SIGNATURE_ALGORITHM            : return WeaveFormatError(err, "Weave signature not signed with required signature algorithm");
    case WEAVE_ERROR_WDM_SCHEMA_MISMATCH                        : return WeaveFormatError(err, "Schema mismatch in WDM.");
    case WEAVE_ERROR_INVALID_INTEGER_VALUE                      : return WeaveFormatError(err, "Invalid integer value.");
    case WEAVE_ERROR_TOO_MANY_CASE_RECONFIGURATIONS             : return WeaveFormatError(err, "Too many CASE reconfigurations were received.");
    case WEAVE_ERROR_INVALID_MESSAGE_FLAG                       : return WeaveFormatError(err, "Invalid message flag.");
    case WEAVE_ERROR_NO_COMMON_KEY_EXPORT_CONFIGURATIONS        : return WeaveFormatError(err, "No supported key export protocol configurations in common");
    case WEAVE_ERROR_INVALID_KEY_EXPORT_CONFIGURATION           : return WeaveFormatError(err, "Invalid key export protocol configuration");
    case WEAVE_ERROR_NO_KEY_EXPORT_DELEGATE                     : return WeaveFormatError(err, "No key export protocol delegate set");
    case WEAVE_ERROR_UNAUTHORIZED_KEY_EXPORT_REQUEST            : return WeaveFormatError(err, "Unauthorized key export request");
    case WEAVE_ERROR_UNAUTHORIZED_KEY_EXPORT_RESPONSE           : return WeaveFormatError(err, "Unauthorized key export response");
    case WEAVE_ERROR_EXPORTED_KEY_AUTHENTICATION_FAILED         : return WeaveFormatError(err, "Exported key authentication failed");
    case WEAVE_ERROR_TOO_MANY_SHARED_SESSION_END_NODES          : return WeaveFormatError(err, "Too many shared session end nodes");
    case WEAVE_ERROR_WDM_MALFORMED_DATA_ELEMENT                 : return WeaveFormatError(err, "Malformed WDM DataElement");
    case WEAVE_ERROR_WRONG_CERT_TYPE                            : return WeaveFormatError(err, "Wrong certificate type");
    case WEAVE_ERROR_TIME_NOT_SYNCED_YET                        : return WeaveFormatError(err, "Time not synced yet");
    case WEAVE_ERROR_UNSUPPORTED_CLOCK                          : return WeaveFormatError(err, "Unsupported clock");
    case WEAVE_ERROR_DEFAULT_EVENT_HANDLER_NOT_CALLED           : return WeaveFormatError(err, "Default event handler not called");
    case WEAVE_ERROR_PERSISTED_STORAGE_FAIL                     : return WeaveFormatError(err, "Persisted storage failed");
    case WEAVE_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND          : return WeaveFormatError(err, "Value not found in the persisted storage");
    case WEAVE_ERROR_PROFILE_STRING_CONTEXT_ALREADY_REGISTERED  : return WeaveFormatError(err, "String context already registered");
    case WEAVE_ERROR_PROFILE_STRING_CONTEXT_NOT_REGISTERED      : return WeaveFormatError(err, "String context not registered");
    case WEAVE_ERROR_INCOMPATIBLE_SCHEMA_VERSION                : return WeaveFormatError(err, "Incompatible data schema version");
    case WEAVE_ERROR_TUNNEL_ROUTING_RESTRICTED                  : return WeaveFormatError(err, "Restricted Routing: Border Routing disabled");

    // ----- ASN1 Errors -----
    case ASN1_END                                               : return ASN1FormatError(err, "End of input");
    case ASN1_ERROR_UNDERRUN                                    : return ASN1FormatError(err, "Reader underrun");
    case ASN1_ERROR_OVERFLOW                                    : return ASN1FormatError(err, "Writer overflow");
    case ASN1_ERROR_INVALID_STATE                               : return ASN1FormatError(err, "Invalid state");
    case ASN1_ERROR_MAX_DEPTH_EXCEEDED                          : return ASN1FormatError(err, "Max depth exceeded");
    case ASN1_ERROR_INVALID_ENCODING                            : return ASN1FormatError(err, "Invalid encoding");
    case ASN1_ERROR_UNSUPPORTED_ENCODING                        : return ASN1FormatError(err, "Unsupported encoding");
    case ASN1_ERROR_TAG_OVERFLOW                                : return ASN1FormatError(err, "Tag overflow");
    case ASN1_ERROR_LENGTH_OVERFLOW                             : return ASN1FormatError(err, "Length overflow");
    case ASN1_ERROR_VALUE_OVERFLOW                              : return ASN1FormatError(err, "Value overflow");
    case ASN1_ERROR_UNKNOWN_OBJECT_ID                           : return ASN1FormatError(err, "Unknown object id");
#endif // if !WEAVE_CONFIG_SHORT_ERROR_STR

    }

#if WEAVE_SYSTEM_CONFIG_USE_LWIP
    // Handle any Weave System Layer LwIP stack-specific errors.
    // description is ignored, and the actual printout is different when WEAVE_CONFIG_SHORT_ERROR_STR is defined
    if (Weave::System::IsErrorLwIP(static_cast<Weave::System::Error>(err)))
        return _SubsystemFormatError("LwIP", err, Weave::System::DescribeErrorLwIP(static_cast<Weave::System::Error>(err)));
#endif // WEAVE_SYSTEM_CONFIG_USE_LWIP

#if WEAVE_SYSTEM_CONFIG_USE_SOCKETS
    // Handle any Weave System Layer POSIX stack-specific errors.
    // description is ignored, and the actual printout is different when WEAVE_CONFIG_SHORT_ERROR_STR is defined
    if (Weave::System::IsErrorPOSIX(static_cast<Weave::System::Error>(err)))
        return _SubsystemFormatError("OS", err, Weave::System::DescribeErrorPOSIX(static_cast<Weave::System::Error>(err)));
#endif // WEAVE_SYSTEM_CONFIG_USE_SOCKETS

    // Handle any default cases not explicitly handled in the switch
    // statement above.
    // Note this is the only case, and the actual printout is different when WEAVE_CONFIG_SHORT_ERROR_STR is defined

    if (err >= INET_ERROR_MIN && err <= INET_ERROR_MAX)
        return SubsystemFormatError("Inet", (int)err);

    if (err >= WEAVE_ERROR_MIN && err <= WEAVE_ERROR_MAX)
        return SubsystemFormatError("Weave", (int)err);

    if (err >= ASN1_ERROR_MIN && err <= ASN1_ERROR_MAX)
        return SubsystemFormatError("ASN1", (int)err);

#if CONFIG_NETWORK_LAYER_BLE
    if (err >= BLE_ERROR_MIN && err <= BLE_ERROR_MAX)
        return SubsystemFormatError("Ble", (int)err);
#endif // CONFIG_NETWORK_LAYER_BLE

    // note the actual printout is different when WEAVE_CONFIG_SHORT_ERROR_STR is defined
    return FormatError((int)err);
}

} // namespace nl