/**
 *
 *    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.
 */

#include "chip-zcl-zpro-codec.h"
#include <assert.h>
#include <inttypes.h>
#include <stdio.h>
#include <string.h>

#include <support/BufBound.h>
#include <support/SafeInt.h>
#include <support/logging/CHIPLogging.h>

#define CHECK_FRAME_LENGTH(value, name)                                                                                            \
    if (value == 0)                                                                                                                \
    {                                                                                                                              \
        ChipLogError(Zcl, "Error encoding APS Frame: %s", name);                                                                   \
        return 0;                                                                                                                  \
    }

using namespace chip;
extern "C" {

static uint16_t doEncodeApsFrame(BufBound & buf, uint16_t profileID, uint16_t clusterId, uint8_t sourceEndpoint,
                                 uint8_t destinationEndpoint, EmberApsOption options, uint16_t groupId, uint8_t sequence,
                                 uint8_t radius, bool isMeasuring)
{

    uint8_t control_byte = 0;
    buf.Put(control_byte); // Put in a control byte
    buf.PutLE16(profileID);
    buf.PutLE16(clusterId);
    buf.Put(sourceEndpoint);
    buf.Put(destinationEndpoint);
    buf.PutLE(options, sizeof(EmberApsOption));
    buf.PutLE16(groupId);
    buf.Put(sequence);
    buf.Put(radius);

    size_t result = 0;
    if (isMeasuring)
    {
        result = buf.Written();
        ChipLogProgress(Zcl, "Measured APS frame size %d", result);
    }
    else
    {
        result = buf.Fit() ? buf.Written() : 0;
        CHECK_FRAME_LENGTH(result, "Buffer too small");
        ChipLogProgress(Zcl, "Successfully encoded %d bytes", result);
    }
    if (!CanCastTo<uint16_t>(result))
    {
        ChipLogProgress(Zcl, "Can't fit our measured size in uint16_t");
        result = 0;
    }

    return static_cast<uint16_t>(result);
}

uint16_t encodeApsFrame(uint8_t * buffer, uint16_t buf_length, EmberApsFrame * apsFrame)
{
    BufBound buf = BufBound(buffer, buf_length);
    return doEncodeApsFrame(buf, apsFrame->profileId, apsFrame->clusterId, apsFrame->sourceEndpoint, apsFrame->destinationEndpoint,
                            apsFrame->options, apsFrame->groupId, apsFrame->sequence, apsFrame->radius, !buffer);
}

uint16_t _encodeCommand(BufBound & buf, uint8_t destination_endpoint, uint16_t cluster_id, uint8_t command, uint8_t frame_control)
{
    CHECK_FRAME_LENGTH(buf.Size(), "Buffer is empty");

    uint8_t seq_num         = 1;     // Transaction sequence number.  Just pick something.
    uint8_t source_endpoint = 1;     // Pick source endpoint as 1 for now.
    uint16_t profile_id     = 65535; // Profile is 65535 because that matches our simple generated code, but we
                                     // should sort out the profile situation.

    if (doEncodeApsFrame(buf, profile_id, cluster_id, source_endpoint, destination_endpoint, 0, 0, 0, 0, false))
    {
        buf.Put(frame_control);
        buf.Put(seq_num);
        buf.Put(command);
    }

    return buf.Fit() && CanCastTo<uint16_t>(buf.Written()) ? static_cast<uint16_t>(buf.Written()) : 0;
}

uint16_t _encodeClusterSpecificCommand(BufBound & buf, uint8_t destination_endpoint, uint16_t cluster_id, uint8_t command)
{
    // This is a cluster-specific command so low two bits are 0b01.  The command
    // is standard, so does not need a manufacturer code, and we're sending
    // client to server, so all the remaining bits are 0.
    uint8_t frame_control = 0x01;

    return _encodeCommand(buf, destination_endpoint, cluster_id, command, frame_control);
}

uint16_t _encodeGlobalCommand(BufBound & buf, uint8_t destination_endpoint, uint16_t cluster_id, uint8_t command)
{
    // This is a global command, so the low bits are 0b00.  The command is
    // standard, so does not need a manufacturer code, and we're sending client
    // to server, so all the remaining bits are 0.
    uint8_t frame_control = 0x00;

    return _encodeCommand(buf, destination_endpoint, cluster_id, command, frame_control);
}

uint16_t encodeReadAttributesCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint, uint16_t cluster_id,
                                     uint16_t * attr_ids, uint16_t attr_id_count)
{
    BufBound buf = BufBound(buffer, buf_length);
    if (_encodeGlobalCommand(buf, destination_endpoint, cluster_id, 0x00))
    {
        for (uint16_t i = 0; i < attr_id_count; ++i)
        {
            uint16_t attr_id = attr_ids[i];
            buf.PutLE16(attr_id);
        }
    }

    return buf.Fit() && CanCastTo<uint16_t>(buf.Written()) ? static_cast<uint16_t>(buf.Written()) : 0;
}

#define READ_ATTRIBUTES(name, cluster_id)                                                                                          \
    uint16_t attr_id_count = sizeof(attr_ids) / sizeof(attr_ids[0]);                                                               \
    uint16_t result = encodeReadAttributesCommand(buffer, buf_length, destination_endpoint, cluster_id, attr_ids, attr_id_count);  \
    if (result == 0)                                                                                                               \
    {                                                                                                                              \
        ChipLogError(Zcl, "Error encoding %s command", name);                                                                      \
        return 0;                                                                                                                  \
    }                                                                                                                              \
    return result;

#define COMMAND_HEADER(name, cluster_id, command_id)                                                                               \
    BufBound buf    = BufBound(buffer, buf_length);                                                                                \
    uint16_t result = _encodeClusterSpecificCommand(buf, destination_endpoint, cluster_id, command_id);                            \
    if (result == 0)                                                                                                               \
    {                                                                                                                              \
        ChipLogError(Zcl, "Error encoding %s command", name);                                                                      \
        return 0;                                                                                                                  \
    }

#define COMMAND_FOOTER(name)                                                                                                       \
    result = buf.Fit() && CanCastTo<uint16_t>(buf.Written()) ? static_cast<uint16_t>(buf.Written()) : 0;                           \
    if (result == 0)                                                                                                               \
    {                                                                                                                              \
        ChipLogError(Zcl, "Error encoding %s command", name);                                                                      \
        return 0;                                                                                                                  \
    }                                                                                                                              \
    return result;

#define COMMAND(name, cluster_id, command_id)                                                                                      \
    COMMAND_HEADER(name, cluster_id, command_id);                                                                                  \
    COMMAND_FOOTER(name);

#define ONOFF_CLUSTER_ID 0x0006
#define IDENTIFY_CLUSTER_ID 0x0003
#define TEMP_MEASUREMENT_CLUSTER_ID 0x0402
#define COLORCONTROL_CLUSTER_ID 0x0300

/*
 * On/Off Cluster commands
 */

uint16_t encodeOffCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint)
{
    COMMAND("Off", ONOFF_CLUSTER_ID, 0x00);
};

uint16_t encodeOnCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint)
{
    COMMAND("On", ONOFF_CLUSTER_ID, 0x01);
}

uint16_t encodeToggleCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint)
{
    COMMAND("Toggle", ONOFF_CLUSTER_ID, 0x02);
}

uint16_t encodeReadOnOffCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint)
{
    uint16_t attr_ids[] = { 0x0000 }; /* OnOff attribute */
    READ_ATTRIBUTES("ReadOnOff", ONOFF_CLUSTER_ID);
}

/*
 * Identify Cluster commands
 */

uint16_t encodeIdentifyCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint, uint16_t duration)
{
    COMMAND_HEADER("Identify", IDENTIFY_CLUSTER_ID, 0x00);
    buf.PutLE16(duration);
    COMMAND_FOOTER("Identify");
}

uint16_t encodeIdentifyQueryCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint)
{
    COMMAND("IdentifyQuery", IDENTIFY_CLUSTER_ID, 0x01);
}

/*
 * Temperature Measurement Cluster commands
 */
uint16_t encodeReadCurrentTemperatureCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint)
{
    uint16_t attr_ids[] = { 0x0000 }; /* Current Temperature attribute */
    READ_ATTRIBUTES("ReadCurrentTemperature", TEMP_MEASUREMENT_CLUSTER_ID);
}

/*
 * Color Control Cluster commands
 */

uint16_t encodeMoveToHueCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint, uint8_t hue, uint8_t direction,
                                uint16_t transitionTime, uint8_t optionMask, uint8_t optionOverride)
{
    COMMAND_HEADER("MoveToHue", COLORCONTROL_CLUSTER_ID, 0x00);
    buf.Put(hue);
    buf.Put(direction);
    buf.PutLE16(transitionTime);
    buf.Put(optionMask);
    buf.Put(optionOverride);
    COMMAND_FOOTER("MoveToHue");
}

uint16_t encodeMoveHueCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint, uint8_t moveMode, uint8_t rate,
                              uint8_t optionMask, uint8_t optionOverride)
{
    COMMAND_HEADER("MoveHue", COLORCONTROL_CLUSTER_ID, 0x01);
    buf.Put(moveMode);
    buf.Put(rate);
    buf.Put(optionMask);
    buf.Put(optionOverride);
    COMMAND_FOOTER("MoveHue");
}

uint16_t encodeStepHueCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint, uint8_t stepMode,
                              uint8_t stepSize, uint16_t transitionTime, uint8_t optionMask, uint8_t optionOverride)
{
    COMMAND_HEADER("StepHue", COLORCONTROL_CLUSTER_ID, 0x02);
    buf.Put(stepMode);
    buf.Put(stepSize);
    buf.PutLE16(transitionTime);
    buf.Put(optionMask);
    buf.Put(optionOverride);
    COMMAND_FOOTER("StepHue");
}

uint16_t encodeMoveToSaturationCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint, uint8_t saturation,
                                       uint16_t transitionTime, uint8_t optionMask, uint8_t optionOverride)
{
    COMMAND_HEADER("MoveToSaturation", COLORCONTROL_CLUSTER_ID, 0x03);
    buf.Put(saturation);
    buf.PutLE16(transitionTime);
    buf.Put(optionMask);
    buf.Put(optionOverride);
    COMMAND_FOOTER("MoveToSaturation");
}

uint16_t encodeMoveSaturationCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint, uint8_t moveMode,
                                     uint8_t rate, uint8_t optionMask, uint8_t optionOverride)
{
    COMMAND_HEADER("MoveSaturation", COLORCONTROL_CLUSTER_ID, 0x04);
    buf.Put(moveMode);
    buf.Put(rate);
    buf.Put(optionMask);
    buf.Put(optionOverride);
    COMMAND_FOOTER("MoveSaturation");
}

uint16_t encodeStepSaturationCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint, uint8_t stepMode,
                                     uint8_t stepSize, uint16_t transitionTime, uint8_t optionMask, uint8_t optionOverride)
{
    COMMAND_HEADER("StepSaturation", COLORCONTROL_CLUSTER_ID, 0x05);
    buf.Put(stepMode);
    buf.Put(stepSize);
    buf.PutLE16(transitionTime);
    buf.Put(optionMask);
    buf.Put(optionOverride);
    COMMAND_FOOTER("StepSaturation");
}

uint16_t encodeMoveToHueSaturationCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint, uint8_t hue,
                                          uint8_t saturation, uint16_t transitionTime, uint8_t optionMask, uint8_t optionOverride)
{
    COMMAND_HEADER("MoveToHueSaturation", COLORCONTROL_CLUSTER_ID, 0x06);
    buf.Put(hue);
    buf.Put(saturation);
    buf.PutLE16(transitionTime);
    buf.Put(optionMask);
    buf.Put(optionOverride);
    COMMAND_FOOTER("MoveToHueSaturation");
}

uint16_t encodeMoveToColorCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint, uint16_t colorX,
                                  uint16_t colorY, uint16_t transitionTime, uint8_t optionMask, uint8_t optionOverride)
{
    COMMAND_HEADER("MoveToColor", COLORCONTROL_CLUSTER_ID, 0x07);
    buf.PutLE16(colorX);
    buf.PutLE16(colorY);
    buf.PutLE16(transitionTime);
    buf.Put(optionMask);
    buf.Put(optionOverride);
    COMMAND_FOOTER("MoveToColor");
}

uint16_t encodeMoveColorCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint, uint16_t rateX, uint16_t rateY,
                                uint8_t optionMask, uint8_t optionOverride)
{
    COMMAND_HEADER("MoveColor", COLORCONTROL_CLUSTER_ID, 0x08);
    buf.PutLE16(rateX);
    buf.PutLE16(rateY);
    buf.Put(optionMask);
    buf.Put(optionOverride);
    COMMAND_FOOTER("MoveColor");
}

uint16_t encodeStepColorCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint, uint16_t stepX, uint16_t stepY,
                                uint16_t transitionTime, uint8_t optionMask, uint8_t optionOverride)
{
    COMMAND_HEADER("StepColor", COLORCONTROL_CLUSTER_ID, 0x09);
    buf.PutLE16(stepX);
    buf.PutLE16(stepY);
    buf.PutLE16(transitionTime);
    buf.Put(optionMask);
    buf.Put(optionOverride);
    COMMAND_FOOTER("StepColor");
}

uint16_t encodeMoveToColorTemperatureCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint,
                                             uint16_t colorTemperature, uint16_t transitionTime, uint8_t optionMask,
                                             uint8_t optionOverride)
{
    COMMAND_HEADER("MoveToColorTemperature", COLORCONTROL_CLUSTER_ID, 0x0A);
    buf.PutLE16(colorTemperature);
    buf.PutLE16(transitionTime);
    buf.Put(optionMask);
    buf.Put(optionOverride);
    COMMAND_FOOTER("MoveToColorTemperature");
}

uint16_t encodeMoveColorTemperatureCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint, uint8_t moveMode,
                                           uint16_t rate, uint16_t colorTemperatureMin, uint16_t colorTemperatureMax,
                                           uint8_t optionMask, uint8_t optionOverride)
{
    COMMAND_HEADER("MoveColorTemperature", COLORCONTROL_CLUSTER_ID, 0x4B);
    buf.Put(moveMode);
    buf.PutLE16(rate);
    buf.PutLE16(colorTemperatureMin);
    buf.PutLE16(colorTemperatureMax);
    buf.Put(optionMask);
    buf.Put(optionOverride);
    COMMAND_FOOTER("MoveColorTemperature");
}

uint16_t encodeStepColorTemperatureCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint, uint8_t stepMode,
                                           uint16_t stepSize, uint16_t transitionTime, uint16_t colorTemperatureMin,
                                           uint16_t colorTemperatureMax, uint8_t optionMask, uint8_t optionOverride)
{
    COMMAND_HEADER("StepColorTemperature", COLORCONTROL_CLUSTER_ID, 0x4C);
    buf.Put(stepMode);
    buf.PutLE16(stepSize);
    buf.PutLE16(transitionTime);
    buf.PutLE16(colorTemperatureMin);
    buf.PutLE16(colorTemperatureMax);
    buf.Put(optionMask);
    buf.Put(optionOverride);
    COMMAND_FOOTER("StepColorTemperature");
}

uint16_t encodeStopMoveStepCommand(uint8_t * buffer, uint16_t buf_length, uint8_t destination_endpoint, uint8_t optionMask,
                                   uint8_t optionOverride)
{
    COMMAND_HEADER("StopMoveStep", COLORCONTROL_CLUSTER_ID, 0x47);
    buf.Put(optionMask);
    buf.Put(optionOverride);
    COMMAND_FOOTER("StopMoveStep");
}

} // extern "C"