/**
 *
 *    Copyright (c) 2020 Project CHIP Authors
 *
 *    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.
 */

/**
 *
 *    Copyright (c) 2020 Silicon Labs
 *
 *    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
 * @brief This file contains function that processes
 *global ZCL message.
 *******************************************************************************
 ******************************************************************************/

#include "af.h"
#include "common.h"

#include <app/clusters/ias-zone-client/ias-zone-client.h>

#ifdef EMBER_AF_PLUGIN_REPORTING
#include <app/reporting/reporting.h>
#endif // EMBER_AF_PLUGIN_REPORTING

#include "gen/attribute-id.h"
#include "gen/attribute-type.h"
#include "gen/callback.h"
#include "gen/cluster-id.h"
#include "gen/command-id.h"

#ifdef EMBER_AF_PLUGIN_COMMS_HUB_FUNCTION_SUB_GHZ
#include "app/framework/plugin/comms-hub-function-sub-ghz/comms-hub-function-sub-ghz.h"
#endif

#include <support/CodeUtils.h>

using namespace chip;

// flag to keep track of the fact that we just sent a read attr for time and
// we should set our time to the result of the read attr response.
bool emAfSyncingTime = false;

#ifdef EMBER_AF_GBCS_COMPATIBLE
// Some GBCS use cases (e.g. GCS15e, GCS21f) require that ReadAttributesResponse
// should be send back with Disable Default Response flag set. The only pattern
// is that the decision is based on the cluster and attribute IDs requested.
// To reduce the possibility of false positives, we disable default response
// only for responses containing at least the specified minimum of attributes.
#define MIN_MATCHING_ATTR_IDS_TO_DISABLE_DEFAULT_RESPONSE 3
#endif

#define DISC_ATTR_RSP_MAX_ATTRIBUTES                                                                                               \
    (((EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH - EMBER_AF_ZCL_MANUFACTURER_SPECIFIC_OVERHEAD /* max ZCL header size */                 \
       - 1)                                                                              /* discovery is complete boolean */       \
      / 3)        /* size of one discover attributes response entry */                                                             \
     % UINT8_MAX) /* make count fit in an 8 bit integer */
#define DISC_ATTR_EXT_RSP_MAX_ATTRIBUTES                                                                                           \
    (((EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH - EMBER_AF_ZCL_MANUFACTURER_SPECIFIC_OVERHEAD /* max ZCL header size */                 \
       - 1)                                                                              /* discovery is complete boolean */       \
      / 4)        /* size of one discover attributes extended response entry */                                                    \
     % UINT8_MAX) /* make count fit in an 8 bit integer */

#if defined(EMBER_AF_SUPPORT_COMMAND_DISCOVERY)
static void printDiscoverCommandsResponse(bool generated, ClusterId clusterId, bool discoveryComplete, uint8_t * buffer,
                                          uint16_t length)
{
    uint16_t i;
    emberAfServiceDiscoveryPrint("Discover Commands response (complete: %c), %p IDs: ", (discoveryComplete ? 'y' : 'n'),
                                 (generated ? "Generated" : "Received"));
    for (i = 0; i < length; i++)
    {
        emberAfServiceDiscoveryPrint("0x%X ", buffer[i]);
    }
    emberAfServiceDiscoveryPrintln("");
}
#endif

bool emAfProcessGlobalCommand(EmberAfClusterCommand * cmd)
{
    AttributeId attrId;
    uint8_t frameControl;
    // This is a little clumsy but easier to read and port
    // from earlier implementation.
    ClusterId clusterId      = cmd->apsFrame->clusterId;
    CommandId zclCmd         = cmd->commandId;
    uint8_t * message        = cmd->buffer;
    uint16_t msgLen          = cmd->bufLen;
    uint16_t msgIndex        = cmd->payloadStartIndex;
    uint8_t clientServerMask = (cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER ? CLUSTER_MASK_SERVER : CLUSTER_MASK_CLIENT);

    // If we are disabled then we can only respond to read or write commands
    // or identify cluster (see device enabled attr of basic cluster)
    if (!emberAfIsDeviceEnabled(cmd->apsFrame->destinationEndpoint) && zclCmd != ZCL_READ_ATTRIBUTES_COMMAND_ID &&
        zclCmd != ZCL_WRITE_ATTRIBUTES_COMMAND_ID && zclCmd != ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID &&
        zclCmd != ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID && clusterId != ZCL_IDENTIFY_CLUSTER_ID)
    {
        emberAfCorePrintln("disabled");
        emberAfDebugPrintln("%pd, dropping global cmd:%x", "disable", zclCmd);
        emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_FAILURE);
        return true;
    }

    // If a manufacturer-specific command arrives using our special internal "not
    // manufacturer specific" code, we need to reject it outright without letting
    // it pass through to the rest of the code.  The internal read and write APIs
    // would interpret it as a standard attribute or cluster and return incorrect
    // results.
    if (cmd->mfgSpecific && cmd->mfgCode == EMBER_AF_NULL_MANUFACTURER_CODE)
    {
        goto kickout;
    }

    // Clear out the response buffer by setting its length to zero
    appResponseLength = 0;

    // Make the ZCL header for the response
    // note: cmd byte is set below
    frameControl = static_cast<uint8_t>(ZCL_GLOBAL_COMMAND |
                                        (cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER
                                             ? ZCL_FRAME_CONTROL_SERVER_TO_CLIENT | EMBER_AF_DEFAULT_RESPONSE_POLICY_RESPONSES
                                             : ZCL_FRAME_CONTROL_CLIENT_TO_SERVER | EMBER_AF_DEFAULT_RESPONSE_POLICY_RESPONSES));
    if (cmd->mfgSpecific)
    {
        frameControl |= ZCL_MANUFACTURER_SPECIFIC_MASK;
    }
    emberAfPutInt8uInResp(frameControl);
    if (cmd->mfgSpecific)
    {
        emberAfPutInt16uInResp(cmd->mfgCode);
    }
    emberAfPutInt8uInResp(cmd->seqNum);

    switch (zclCmd)
    {
    // The format of the read attributes cmd is:
    // ([attr ID:2]) * N
    // The format of the read attributes response is:
    // ([attr ID:2] [status:1] [data type:0/1] [data:0/N]) * N
    case ZCL_READ_ATTRIBUTES_COMMAND_ID: {
        emberAfAttributesPrintln("%p: clus %2x", "READ_ATTR", clusterId);
        // Set the cmd byte - this is byte 3 index 2, but since we have
        // already incremented past the 3 byte ZCL header (our index is at 3),
        // this gets written to "-1" since 3 - 1 = 2.
        emberAfPutInt8uInResp(ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID);

        // This message contains N 2-byte attr IDs after the 3 byte ZCL header,
        // for each one we need to look it up and make a response
        while (msgIndex + 2 <= msgLen)
        {
            // Get the attribute ID and store it in the response buffer
            // least significant byte is first OTA
            attrId = emberAfGetInt16u(message, msgIndex, msgLen);

#ifdef EMBER_AF_GBCS_COMPATIBLE
            // GBCS explicitly lists some commands that need to be sent with "disable
            // default response" flag set, including some ReadAttributes responses.
            // We make it conditional on GBCS so it does not affect standard SE apps.
            {
                static const struct
                {
                    ClusterId clusterId;
                    AttributeId attrId;
                } noDefaultResponseSet[] = {
                    { ZCL_PRICE_CLUSTER_ID, ZCL_THRESHOLD_MULTIPLIER_ATTRIBUTE_ID },
                    { ZCL_PRICE_CLUSTER_ID, ZCL_THRESHOLD_DIVISOR_ATTRIBUTE_ID },
                    { ZCL_PRICE_CLUSTER_ID, ZCL_STANDING_CHARGE_ATTRIBUTE_ID },
                    { ZCL_PRICE_CLUSTER_ID, ZCL_TARIFF_UNIT_OF_MEASURE_ATTRIBUTE_ID },
                    { ZCL_SIMPLE_METERING_CLUSTER_ID, ZCL_UNIT_OF_MEASURE_ATTRIBUTE_ID },
                    { ZCL_SIMPLE_METERING_CLUSTER_ID, ZCL_MULTIPLIER_ATTRIBUTE_ID },
                    { ZCL_SIMPLE_METERING_CLUSTER_ID, ZCL_DIVISOR_ATTRIBUTE_ID },
                };
                uint8_t i;
                uint8_t foundMatchingAttrIdsCount = 0;

                for (i = 0; i < sizeof noDefaultResponseSet / sizeof noDefaultResponseSet[0]; ++i)
                {
                    if (noDefaultResponseSet[i].clusterId == clusterId && noDefaultResponseSet[i].attrId == attrId)
                    {
                        if (++foundMatchingAttrIdsCount >= MIN_MATCHING_ATTR_IDS_TO_DISABLE_DEFAULT_RESPONSE)
                        {
                            emberAfSetDisableDefaultResponse(EMBER_AF_DISABLE_DEFAULT_RESPONSE_ONE_SHOT);
                            break;
                        }
                    }
                }
            }

#ifdef EMBER_AF_PLUGIN_COMMS_HUB_FUNCTION_SUB_GHZ
            // This plugin sets channel change notification flags and needs to know
            // when those flags have been read.
            if (clientServerMask == CLUSTER_MASK_SERVER)
            {
                emAfCommsHubFunctionSubGhzReadAttributeNotification(cmd->source, clusterId, attrId);
            }
#endif
#endif

            // This function reads the attribute and creates the correct response
            // in the response buffer
            emberAfRetrieveAttributeAndCraftResponse(cmd->apsFrame->destinationEndpoint, clusterId, attrId, clientServerMask,
                                                     cmd->mfgCode,
                                                     static_cast<uint16_t>(EMBER_AF_RESPONSE_BUFFER_LEN - appResponseLength));
            // Go to next attrID
            msgIndex = static_cast<uint16_t>(msgIndex + 2);
        }
    }

        emberAfSendResponse();
        return true;

    // Write undivided means all attributes must be written in order to write
    // any of them. So first do a check. If the check fails, send back a fail
    // response. If it works, fall through to the normal write attr code.
    // write attr responses are the same for undivided and normal writes.
    case ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID: {
        uint8_t numFailures = 0;
        uint8_t dataType;
        uint16_t dataSize;
        EmberAfStatus status;

        emberAfPutInt8uInResp(ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID);

        // Go through the message until there are no more attrID/type/data
        while (msgIndex < msgLen - 3)
        {
            attrId   = emberAfGetInt16u(message, msgIndex, msgLen);
            dataType = emberAfGetInt8u(message, msgIndex + 2, msgLen);

            dataSize = emberAfAttributeValueSize(dataType, message + msgIndex + 3);

            // Check to see if there are dataSize bytes left in the message if it is a string
            if (emberAfIsThisDataTypeAStringType(dataType) && (dataSize < msgLen - (msgIndex + 3)))
            {
                // This command is malformed
                status = EMBER_ZCL_STATUS_MALFORMED_COMMAND;
            }
            else
            {
                status = emberAfVerifyAttributeWrite(cmd->apsFrame->destinationEndpoint, clusterId, attrId, clientServerMask,
                                                     cmd->mfgCode, &(message[msgIndex + 3]), dataType);
            }

            if (status != EMBER_ZCL_STATUS_SUCCESS)
            {
                numFailures++;
                // Write to the response buffer - status and then attrID
                emberAfPutInt8uInResp(status);
                emberAfPutInt16uInResp(attrId);

                emberAfAttributesPrintln("WRITE: clus %2x attr %2x ", clusterId, attrId);
                emberAfAttributesPrintln("FAIL %x", status);
                emberAfCoreFlush();
                if (status == EMBER_ZCL_STATUS_MALFORMED_COMMAND)
                {
                    // this attribute is malformed, terminate attribute processing.
                    break;
                }
            }

            // Increment past the attribute id (two bytes), the type (one byte), and
            // the data (N bytes, including the length byte for strings).
            msgIndex = static_cast<uint16_t>(msgIndex + 3 + dataSize);
        }
        // If there are any failures, send the response and exit
        if (numFailures > 0)
        {
            emberAfSendResponse();
            return true;
        }
    }
        // Reset message back to start
        msgIndex          = cmd->payloadStartIndex;
        appResponseLength = (cmd->mfgSpecific ? 4 : 2);
        FALLTHROUGH;
        /* fall through */
    // DO NOT BREAK from this case

    // the format of the write attributes cmd is:
    // ([attr ID:2] [data type:1] [data:N]) * N
    // the format of the write attributes response is:
    // ([status 1] [attr ID 2]) * n
    // ONLY errors are reported unless all are successful then a single success
    // is sent. write attr no response is handled by just executing the same
    // code but not setting the flag that sends the response at the end.
    case ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID:
    case ZCL_WRITE_ATTRIBUTES_COMMAND_ID: {
        uint8_t numFailures = 0;
        uint8_t numSuccess  = 0;
        uint8_t dataType;
        uint16_t dataSize;
#if (BIGENDIAN_CPU)
        uint8_t writeData[ATTRIBUTE_LARGEST];
#endif //(BIGENDIAN_CPU)
        EmberAfStatus status;

        // set the cmd byte - this is byte 3 index 2, but since we have
        // already incremented past the 3 byte ZCL header (our index is at 3),
        // this gets written to "-1" since 3 - 1 = 2.
        emberAfPutInt8uInResp(ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID);

        // go through the message until there are no more attrID/type/data
        while (msgLen > msgIndex + 3)
        {
            attrId   = emberAfGetInt16u(message, msgIndex, msgLen);
            dataType = emberAfGetInt8u(message, msgIndex + 2, msgLen);

            dataSize = emberAfAttributeValueSize(dataType, message + msgIndex + 3);

            // the data is sent little endian over-the-air, it needs to be
            // inserted into the table big endian for the EM250 and little
            // endian for the EZSP hosts. This means for the EM250 the data
            // needs to be reversed before sending to writeAttributes
#if (BIGENDIAN_CPU)
            if (dataSize <= msgLen - (msgIndex + 3) && dataSize <= ATTRIBUTE_LARGEST)
            {
                // strings go over the air as length byte and then in human
                // readable format. These should not be flipped.
                if (emberAfIsThisDataTypeAStringType(dataType))
                {
                    memmove(writeData, message + msgIndex + 3, dataSize);
                }
                else
                {
                    // the data is sent little endian over-the-air, it needs to be
                    // inserted into the table big endian
                    uint16_t i;
                    for (i = 0; i < dataSize; i++)
                    {
                        writeData[i] = message[msgIndex + 3 + dataSize - i - 1];
                    }
                }
#else  //(BIGENDIAN_CPU)
            if (dataSize <= msgLen - (msgIndex + 3))
            {
#endif //(BIGENDIAN_CPU)

                status = emberAfWriteAttributeExternal(cmd->apsFrame->destinationEndpoint, clusterId, attrId, clientServerMask,
                                                       cmd->mfgCode,
#if (BIGENDIAN_CPU)
                                                       writeData,
#else  //(BIGENDIAN_CPU)
                                                       &(message[msgIndex + 3]),
#endif //(BIGENDIAN_CPU)
                                                       dataType);
                emberAfAttributesPrint("WRITE: clus %2x attr %2x ", clusterId, attrId);
                if (status == EMBER_ZCL_STATUS_SUCCESS)
                {
                    numSuccess++;
                    emberAfAttributesPrintln("OK");
                }
                else
                {
                    numFailures++;
                    // write to the response buffer - status and then attrID
                    emberAfPutInt8uInResp(status);
                    emberAfPutInt16uInResp(attrId);
                    emberAfAttributesPrintln("FAIL %x", status);
                }
                emberAfCoreFlush();

                // Increment past the attribute id (two bytes), the type (one byte), and
                // the data (N bytes, including the length byte for strings).
                msgIndex = static_cast<uint16_t>(msgIndex + 3 + dataSize);
            }
            else
            {
                numFailures++;
                status = EMBER_ZCL_STATUS_INVALID_VALUE;
                // write to the response buffer - status and then attrID
                emberAfPutInt8uInResp(status);
                emberAfPutInt16uInResp(attrId);
                emberAfAttributesPrintln("FAIL %x", status);
                // size exceeds buffer, terminate loop
                break;
            }
        }

        // always send a response unless the cmd requested no response
        if (zclCmd == ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID)
        {
            return true;
        }

        if (numFailures == 0)
        {
            // if no failures and no success this means the packet was too short
            // print an error message but still return true as we consumed the
            // message
            if (numSuccess == 0)
            {
                emberAfAttributesPrintln("WRITE: too short");
                emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_MALFORMED_COMMAND);
                return true;
            }
            // if no failures and at least one success, write a success status
            // that means everything worked
            else
            {
                emberAfPutInt8uInResp(EMBER_ZCL_STATUS_SUCCESS);
            }
        }
        emberAfSendResponse();
        return true;
    }

    // the format of discover is: [start attr ID:2] [max attr IDs:1]
    // the format of the response is: [done:1] ([attrID:2] [type:1]) * N
    case ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID:
    case ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID: {
        AttributeId startingAttributeId;
        uint8_t numberAttributes;
        uint8_t * complete;

        emberAfAttributesPrintln("%p%p: clus %2x", "DISC_ATTR",
                                 (zclCmd == ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID ? "_EXT" : ""), clusterId);

        // set the cmd byte - this is byte 3 index 2, but since we have
        // already incremented past the 3 byte ZCL header (our index is at 3),
        // this gets written to "-1" since 3 - 1 = 2.
        emberAfPutInt8uInResp((zclCmd == ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID
                                   ? ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID
                                   : ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID));

        // get the attrId to start on and the max count
        startingAttributeId = emberAfGetInt16u(message, msgIndex, msgLen);
        numberAttributes    = emberAfGetInt8u(message, msgIndex + 2, msgLen);

        // BUGZID: EMAPPFWKV2-828, EMAPPFWKV2-1401
        if (zclCmd == ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID && numberAttributes > DISC_ATTR_RSP_MAX_ATTRIBUTES)
        {
            numberAttributes = DISC_ATTR_RSP_MAX_ATTRIBUTES;
        }
        else if (zclCmd == ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID && numberAttributes > DISC_ATTR_EXT_RSP_MAX_ATTRIBUTES)
        {
            numberAttributes = DISC_ATTR_EXT_RSP_MAX_ATTRIBUTES;
        }
        else
        {
            // MISRA requires ..else if.. to have terminating else.
        }

        // The response has a one-byte field indicating whether discovery is
        // complete.  We can't populate that field until we've finished going
        // through all the attributes, so save a placeholder, write a temporary
        // value for now (so that the offset moves forward), and write the real
        // value when we're done.
        complete = &(appResponseData[appResponseLength]);
        emberAfPutInt8uInResp(false);
        *complete = emberAfReadSequentialAttributesAddToResponse(cmd->apsFrame->destinationEndpoint, clusterId, startingAttributeId,
                                                                 clientServerMask, cmd->mfgCode, numberAttributes,
                                                                 (zclCmd == ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID));
        emberAfSendResponse();
        return true;
    }

#ifdef EMBER_AF_PLUGIN_REPORTING
    case ZCL_CONFIGURE_REPORTING_COMMAND_ID:
        if (emberAfConfigureReportingCommandCallback(cmd))
        {
            return true;
        }
        break;

    case ZCL_READ_REPORTING_CONFIGURATION_COMMAND_ID:
        if (emberAfReadReportingConfigurationCommandCallback(cmd))
        {
            return true;
        }
        break;
#endif // EMBER_AF_PLUGIN_REPORTING

    // ([attribute id:2] [status:1] [type:0/1] [value:0/V])+
    case ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID:
        // The "timesync" command in the CLI sends a Read Attributes command for the
        // Time attribute on another device and then sets a flag.  If that flag is
        // set and a Read Attributes Response command for the time comes in, we set
        // the time to the value in the message.
        if (clusterId == ZCL_TIME_CLUSTER_ID)
        {
            if (emAfSyncingTime && !cmd->mfgSpecific && msgLen - msgIndex == 8 // attr:2 status:1 type:1 data:4
                && (emberAfGetInt16u(message, msgIndex, msgLen) == ZCL_TIME_ATTRIBUTE_ID) &&
                (emberAfGetInt8u(message, msgIndex + 2, msgLen) == EMBER_ZCL_STATUS_SUCCESS) &&
                (emberAfGetInt8u(message, msgIndex + 3, msgLen) == ZCL_UTC_TIME_ATTRIBUTE_TYPE))
            {
                // emberAfSetTime(emberAfGetInt32u(message, msgIndex + 4, msgLen));
                // emberAfDebugPrintln("time sync ok, time: %4x", emberAfGetCurrentTime());
                emAfSyncingTime = false;
            }
#ifdef EMBER_AF_PLUGIN_SMART_ENERGY_REGISTRATION_TIME_SOURCE_REQUIRED
            emAfPluginSmartEnergyRegistrationReadAttributesResponseCallback(message + msgIndex, msgLen - msgIndex);
#endif // EMBER_AF_PLUGIN_SMART_ENERGY_REGISTRATION_TIME_SOURCE_REQUIRED
#ifdef EMBER_AF_PLUGIN_WWAH_SERVER_SILABS
            emAfPluginSlWwahReadAttributesResponseCallback(clusterId, message, msgLen);
#endif
        }

#ifdef EMBER_AF_PLUGIN_TRUST_CENTER_KEEPALIVE
        if (clusterId == ZCL_KEEPALIVE_CLUSTER_ID && !cmd->mfgSpecific)
        {
            emAfPluginTrustCenterKeepaliveReadAttributesResponseCallback(message + msgIndex, msgLen - msgIndex);
        }
#endif // EMBER_AF_PLUGIN_TRUST_CENTER_KEEPALIVE

#if defined(EMBER_AF_PLUGIN_KEY_ESTABLISHMENT)
        if (clusterId == ZCL_KEY_ESTABLISHMENT_CLUSTER_ID && !cmd->mfgSpecific &&
            msgLen - msgIndex == 6 // attr:2 status:1 type:1 data:2
            && (emberAfGetInt16u(message, msgIndex, msgLen) == ZCL_KEY_ESTABLISHMENT_SUITE_CLIENT_ATTRIBUTE_ID) &&
            (emberAfGetInt8u(message, msgIndex + 2, msgLen) == EMBER_ZCL_STATUS_SUCCESS) &&
            ((emberAfGetInt8u(message, msgIndex + 3, msgLen) == ZCL_ENUM16_ATTRIBUTE_TYPE) ||
             (emberAfGetInt8u(message, msgIndex + 3, msgLen) == ZCL_BITMAP16_ATTRIBUTE_TYPE)))
        {
            uint16_t suite = emberAfGetInt16u(message, msgIndex + 4, msgLen);
            emberAfPluginKeyEstablishmentReadAttributesCallback(suite);
        }
#endif

#if defined(EMBER_AF_PLUGIN_TEST_HARNESS)
        emberAfPluginTestHarnessReadAttributesResponseCallback(clusterId, message + msgIndex, msgLen - msgIndex);
#endif

#if defined(EMBER_AF_PLUGIN_IAS_ZONE_CLIENT)
        emberAfPluginIasZoneClientReadAttributesResponseCallback(clusterId, message + msgIndex,
                                                                 static_cast<uint16_t>(msgLen - msgIndex));
#endif

#if defined(EMBER_AF_PLUGIN_SIMPLE_METERING_SERVER)
        emberAfPluginSimpleMeteringClusterReadAttributesResponseCallback(clusterId, message + msgIndex,
                                                                         static_cast<uint16_t>(msgLen - msgIndex));
#endif

        if (!emberAfReadAttributesResponseCallback(clusterId, message + msgIndex, static_cast<uint16_t>(msgLen - msgIndex)))
        {
            emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS);
        }
        return true;

    // ([status:1] [attribute id:2])+
    case ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID:

#if defined(EMBER_AF_PLUGIN_TEST_HARNESS)
        emberAfPluginTestHarnessWriteAttributesResponseCallback(clusterId, message + msgIndex,
                                                                static_cast<uint16_t>(msgLen - msgIndex));
#endif

#if defined(EMBER_AF_PLUGIN_IAS_ZONE_CLIENT)
        emberAfPluginIasZoneClientWriteAttributesResponseCallback(clusterId, message + msgIndex,
                                                                  static_cast<uint16_t>(msgLen - msgIndex));
#endif

        if (!emberAfWriteAttributesResponseCallback(clusterId, message + msgIndex, static_cast<uint16_t>(msgLen - msgIndex)))
        {
            emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS);
        }
        return true;

#ifdef EMBER_AF_PLUGIN_REPORTING
    // ([status:1] [direction:1] [attribute id:2])+
    case ZCL_CONFIGURE_REPORTING_RESPONSE_COMMAND_ID:
        if (!emberAfConfigureReportingResponseCallback(clusterId, message + msgIndex, static_cast<uint16_t>(msgLen - msgIndex)))
        {
            emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS);
        }
        return true;

    // ([status:1] [direction:1] [attribute id:2] [type:0/1] ...
    // ... [min interval:0/2] [max interval:0/2] [reportable change:0/V] ...
    // ... [timeout:0/2])+
    case ZCL_READ_REPORTING_CONFIGURATION_RESPONSE_COMMAND_ID:
        if (!emberAfReadReportingConfigurationResponseCallback(clusterId, message + msgIndex,
                                                               static_cast<uint16_t>(msgLen - msgIndex)))
        {
            emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS);
        }
        return true;
#endif // EMBER_AF_PLUGIN_REPORTING

    // ([attribute id:2] [type:1] [data:V])+
    case ZCL_REPORT_ATTRIBUTES_COMMAND_ID:
        if (!emberAfReportAttributesCallback(clusterId, message + msgIndex, static_cast<uint16_t>(msgLen - msgIndex)))
        {
            emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS);
        }
        return true;

    // [command id:1] [status:1]
    case ZCL_DEFAULT_RESPONSE_COMMAND_ID: {
        EmberAfStatus status;
        CommandId commandId;
        commandId = emberAfGetInt8u(message, msgIndex, msgLen);
        msgIndex++;
        status = (EmberAfStatus) emberAfGetInt8u(message, msgIndex, msgLen);

        emberAfClusterDefaultResponseWithMfgCodeCallback(cmd->apsFrame->destinationEndpoint, clusterId, commandId, status,
                                                         clientServerMask, cmd->mfgCode);
        emberAfDefaultResponseCallback(clusterId, commandId, status);
        return true;
    }

    // [discovery complete:1] ([attribute id:2] [type:1])*
    case ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID:
    case ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID: {
        bool discoveryComplete = emberAfGetInt8u(message, msgIndex, msgLen);
        msgIndex++;
        if (!emberAfDiscoverAttributesResponseCallback(clusterId, discoveryComplete, message + msgIndex,
                                                       static_cast<uint16_t>(msgLen - msgIndex),
                                                       (zclCmd == ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID)))
        {
            emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS);
        }
        return true;
    }

#ifdef EMBER_AF_SUPPORT_COMMAND_DISCOVERY
    // Command discovery takes a bit of flash because we need to add structs
    // for commands into the generated hader. Hence it's all configurable.
    case ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID:
    case ZCL_DISCOVER_COMMANDS_GENERATED_COMMAND_ID: {
        uint8_t startCommandIdentifier    = emberAfGetInt8u(message, msgIndex, msgLen);
        uint8_t maximumCommandIdentifiers = emberAfGetInt8u(message, msgIndex + 1, msgLen);
        uint16_t savedIndex;
        bool flag;

        // Ok. This is the command that matters.
        if (zclCmd == ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID)
        {
            emberAfPutInt8uInResp(ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID);
            flag = false;
        }
        else
        {
            emberAfPutInt8uInResp(ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID);
            flag = true;
        }
        savedIndex                  = appResponseLength;
        flag                        = emberAfExtractCommandIds(flag, cmd, clusterId, appResponseData + appResponseLength + 1,
                                        static_cast<uint16_t>(EMBER_AF_RESPONSE_BUFFER_LEN - appResponseLength - 1),
                                        &appResponseLength, startCommandIdentifier, maximumCommandIdentifiers);
        appResponseData[savedIndex] = (flag ? 1 : 0);
        appResponseLength++;
        emberAfSendResponse();
        return true;
    }
    case ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID: {
        bool discoveryComplete = emberAfGetInt8u(message, msgIndex, msgLen);
        msgIndex++;
        if (msgIndex <= msgLen)
        {
            printDiscoverCommandsResponse(false, // is ZCL command generated?
                                          clusterId, discoveryComplete, message + msgIndex,
                                          static_cast<uint16_t>(msgLen - msgIndex));
            if (!emberAfDiscoverCommandsReceivedResponseCallback(clusterId, cmd->mfgCode, discoveryComplete, message + msgIndex,
                                                                 static_cast<uint16_t>(msgLen - msgIndex)))
            {
                emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS);
            }
            return true;
        }
        else
        {
            return false;
        }
    }
    case ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID: {
        bool discoveryComplete = emberAfGetInt8u(message, msgIndex, msgLen);
        msgIndex++;
        if (msgIndex <= msgLen)
        {
            printDiscoverCommandsResponse(true, // is ZCL command generated?
                                          clusterId, discoveryComplete, message + msgIndex,
                                          static_cast<uint16_t>(msgLen - msgIndex));
            if (!emberAfDiscoverCommandsGeneratedResponseCallback(clusterId, cmd->mfgCode, discoveryComplete, message + msgIndex,
                                                                  static_cast<uint16_t>(msgLen - msgIndex)))
            {
                emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS);
            }
            return true;
        }
        else
        {
            return false;
        }
    }

#endif
    default:
        // MISRA requires default case.
        break;
    }

kickout:
    emberAfSendDefaultResponse(
        cmd, (cmd->mfgSpecific ? EMBER_ZCL_STATUS_UNSUP_MANUF_GENERAL_COMMAND : EMBER_ZCL_STATUS_UNSUP_GENERAL_COMMAND));
    return true;
}