/**
 *
 *    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 <app/util/af.h>
#include <app/util/util.h>

#include <app-common/zap-generated/attributes/Accessors.h>
#include <app-common/zap-generated/cluster-enums.h>
#include <app-common/zap-generated/ids/Attributes.h>
#include <app/AttributeAccessInterface.h>
#include <app/ConcreteAttributePath.h>
#include <app/ConcreteCommandPath.h>
#include <app/InteractionModelEngine.h>
#include <app/util/af-event.h>
#include <app/util/attribute-storage.h>

using namespace chip;
using namespace chip::app;
using namespace chip::app::Clusters;
using namespace chip::app::Clusters::PumpConfigurationAndControl;

namespace {

class PumpConfigurationAndControlAttrAccess : public AttributeAccessInterface
{
public:
    // Register for the Pump Configuration And Control cluster on all endpoints.
    PumpConfigurationAndControlAttrAccess() :
        AttributeAccessInterface(Optional<EndpointId>::Missing(), PumpConfigurationAndControl::Id)
    {}

    CHIP_ERROR Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder) override;
    CHIP_ERROR Write(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder) override;

private:
};

PumpConfigurationAndControlAttrAccess gAttrAccess;

// Enum for RemoteSensorType
enum class RemoteSensorType : uint8_t
{
    kNoSensor          = 0x00,
    kPressureSensor    = 0x01,
    kFlowSensor        = 0x02,
    kTemperatureSensor = 0x03,
};

static RemoteSensorType detectRemoteSensorConnected()
{
    // TODO: Detect the sensor types attached to the pump control cluster
    // this could be pressure, flow or temperature sensors.

    return RemoteSensorType::kNoSensor;
}

static void updateAttributeLinks(EndpointId endpoint)
{
    PumpControlMode controlMode;
    PumpOperationMode operationMode;
    BitMask<PumpStatus> pumpStatus;
    bool isControlModeAvailable = true;
    bool isPumpStatusAvailable  = true;

    isControlModeAvailable = emberAfContainsAttribute(endpoint, PumpConfigurationAndControl::Id, Attributes::ControlMode::Id);
    isPumpStatusAvailable  = emberAfContainsAttribute(endpoint, PumpConfigurationAndControl::Id, Attributes::PumpStatus::Id);

    // Get the current control- and operation modes
    Attributes::OperationMode::Get(endpoint, &operationMode);

    if (isControlModeAvailable)
    {
        Attributes::ControlMode::Get(endpoint, &controlMode);
    }
    else
    {
        // If controlMode attribute is not available, then use the default value
        // of the effectiveControlMode attribute as the effectiveControlMode
        // if this is not suitable, the application should override this value in
        // the post attribute change callback for the operation mode attribute
        const EmberAfAttributeMetadata * effectiveControlModeMetaData;
        effectiveControlModeMetaData = GetAttributeMetadata(
            app::ConcreteAttributePath(endpoint, PumpConfigurationAndControl::Id, Attributes::EffectiveControlMode::Id));
        controlMode = static_cast<PumpControlMode>(effectiveControlModeMetaData->defaultValue.defaultValue);
    }

    if (isPumpStatusAvailable)
    {
        Attributes::PumpStatus::Get(endpoint, &pumpStatus);
    }

    switch (operationMode)
    {
    case PumpOperationMode::kNormal: {
        // The pump runs in the control mode as per the type of the remote sensor
        // If the remote sensor is a Flow sensor the mode would be ConstantFlow
        // If the remote sensor is a Pressure sensor the mode would be ConstantPressure (not ProportionalPressure)
        // If the remote sensor is a Temperature sensor the mode would be ConstantTemperature

        // If a remote sensor is detected and the OperationMode is kNormal, then the pump is operating in the
        // control mode indicated by the repective remote senor type
        RemoteSensorType sensorType = detectRemoteSensorConnected();
        switch (sensorType)
        {
        case RemoteSensorType::kFlowSensor:
            Attributes::EffectiveControlMode::Set(endpoint, PumpControlMode::kConstantFlow);
            if (isPumpStatusAvailable)
            {
                pumpStatus.Set(PumpStatus::kRemoteFlow);
                pumpStatus.Clear(PumpStatus::kRemotePressure);
                pumpStatus.Clear(PumpStatus::kRemoteTemperature);
            }
            break;
        case RemoteSensorType::kPressureSensor:
            Attributes::EffectiveControlMode::Set(endpoint, PumpControlMode::kConstantPressure);
            if (isPumpStatusAvailable)
            {
                pumpStatus.Clear(PumpStatus::kRemoteFlow);
                pumpStatus.Set(PumpStatus::kRemotePressure);
                pumpStatus.Clear(PumpStatus::kRemoteTemperature);
            }
            break;
        case RemoteSensorType::kTemperatureSensor:
            Attributes::EffectiveControlMode::Set(endpoint, PumpControlMode::kConstantTemperature);
            if (isPumpStatusAvailable)
            {
                pumpStatus.Clear(PumpStatus::kRemoteFlow);
                pumpStatus.Clear(PumpStatus::kRemotePressure);
                pumpStatus.Set(PumpStatus::kRemoteTemperature);
            }
            break;
        case RemoteSensorType::kNoSensor:
            // The pump is controlled by a setpoint, as defined by
            // the ControlMode attribute. (N.B. The setpoint is an internal variable which MAY be
            // controlled between 0% and 100%, e.g., by means of the Level Control cluster)
            // The ControlMode can be any of the following:
            // ConstantSpeed, ConstantPressure, ProportionalPressure,
            // ConstantFlow, ConstantTemperature or Automatic. The actual ControlMode
            // which would be the EffectiveControlMode is dependant on the actual
            // physical pump application running "on-top" of this cluster server.
            Attributes::EffectiveControlMode::Set(endpoint, controlMode);
            if (isPumpStatusAvailable)
            {
                pumpStatus.Clear(PumpStatus::kRemoteFlow);
                pumpStatus.Clear(PumpStatus::kRemotePressure);
                pumpStatus.Clear(PumpStatus::kRemoteTemperature);
            }
            break;
        }
        // Set the overall effective operation mode to Normal
        Attributes::EffectiveOperationMode::Set(endpoint, PumpOperationMode::kNormal);
    }
    break;

        // The pump is controlled by the OperationMode attribute.
        // Maximum, Minimum or Local

    case PumpOperationMode::kMaximum: {
#ifdef EMBER_AF_PLUGIN_LEVEL_CONTROL
        uint8_t maxLevel;
#endif
        Attributes::EffectiveOperationMode::Set(endpoint, PumpOperationMode::kMaximum);
        Attributes::EffectiveControlMode::Set(endpoint, PumpControlMode::kConstantSpeed);
#ifdef EMBER_AF_PLUGIN_LEVEL_CONTROL
        LevelControl::Attributes::MaxLevel::Get(endpoint, &maxLevel);
        LevelControl::Attributes::CurrentLevel::Set(endpoint, maxLevel);
#endif
        if (isPumpStatusAvailable)
        {
            pumpStatus.Clear(PumpStatus::kRemoteFlow);
            pumpStatus.Clear(PumpStatus::kRemotePressure);
            pumpStatus.Clear(PumpStatus::kRemoteTemperature);
        }
    }
    break;

    case PumpOperationMode::kMinimum: {
#ifdef EMBER_AF_PLUGIN_LEVEL_CONTROL
        uint8_t minLevel;
#endif
        Attributes::EffectiveOperationMode::Set(endpoint, PumpOperationMode::kMinimum);
        Attributes::EffectiveControlMode::Set(endpoint, PumpControlMode::kConstantSpeed);
#ifdef EMBER_AF_PLUGIN_LEVEL_CONTROL
        LevelControl::Attributes::MinLevel::Get(endpoint, &minLevel);
        if (minLevel == 0)
        {
            // Bump the minimum level to 1, since the value of 0 means stop
            minLevel = 1;
        }
        LevelControl::Attributes::CurrentLevel::Set(endpoint, minLevel);
#endif
        if (isPumpStatusAvailable)
        {
            pumpStatus.Clear(PumpStatus::kRemoteFlow);
            pumpStatus.Clear(PumpStatus::kRemotePressure);
            pumpStatus.Clear(PumpStatus::kRemoteTemperature);
        }
    }
    break;

    case PumpOperationMode::kLocal: {
        // If the Application sets the OperatioMode to kLocal the application "owns" the EffectiveControlMode, which
        // it also does if the external entity sets the OperationMode to kLocal. So in any case the application
        // must set the EffectiveControlMode to something which applies to the current ControlMode in the application.
        // So to keeps things short: the application layer owns the EffetiveControlMode when OperationMode is kLocal.
        Attributes::EffectiveOperationMode::Set(endpoint, PumpOperationMode::kLocal);
        // Set the current ControlMode for now. Perhaps the application will set the EffectiveControlMode to something else.
        Attributes::EffectiveControlMode::Set(endpoint, controlMode);
        // Clear out the remote sensors from the PumpStatus flags.
        if (isPumpStatusAvailable)
        {
            pumpStatus.Clear(PumpStatus::kRemoteFlow);
            pumpStatus.Clear(PumpStatus::kRemotePressure);
            pumpStatus.Clear(PumpStatus::kRemoteTemperature);
        }
    }
    break;

    case PumpOperationMode::kUnknownEnumValue: {
        // Not expected; see check in MatterPumpConfigurationAndControlClusterServerPreAttributeChangedCallback.
        break;
    }
    }

    if (isPumpStatusAvailable)
    {
        Attributes::PumpStatus::Set(endpoint, pumpStatus);
    }
}

CHIP_ERROR PumpConfigurationAndControlAttrAccess::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder)
{
    emberAfDebugPrintln("Reading from PCC");

    VerifyOrDie(aPath.mClusterId == PumpConfigurationAndControl::Id);

    switch (aPath.mAttributeId)
    {
    default:
        break;
    }
    return CHIP_NO_ERROR;
}

CHIP_ERROR PumpConfigurationAndControlAttrAccess::Write(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder)
{
    emberAfDebugPrintln("Writing to PCC");

    VerifyOrDie(aPath.mClusterId == PumpConfigurationAndControl::Id);

    switch (aPath.mAttributeId)
    {
    default:
        break;
    }
    return CHIP_NO_ERROR;
}
} // namespace

// SDK Callbacks

template <typename T1, typename T2>
bool IsFeatureSupported(EndpointId endpoint, EmberAfStatus (*getFn1)(chip::EndpointId endpointId, T1 & value),
                        EmberAfStatus (*getFn2)(chip::EndpointId endpointId, T2 & value))
{
    EmberAfStatus status;

    T1 value1;
    T2 value2;

    status = getFn1(endpoint, value1);
    if (status == EMBER_ZCL_STATUS_SUCCESS)
    {
        if (!value1.IsNull())
        {
            status = getFn2(endpoint, value2);
            if (status == EMBER_ZCL_STATUS_SUCCESS)
            {
                if (!value2.IsNull())
                {
                    return true;
                }
            }
        }
    }

    return false;
}

template <typename T1, typename T2>
const char * FeatureSupportedDebugString(EndpointId endpoint, EmberAfStatus (*getFn1)(chip::EndpointId endpointId, T1 & value),
                                         EmberAfStatus (*getFn2)(chip::EndpointId endpointId, T2 & value))
{
    return IsFeatureSupported(endpoint, getFn1, getFn2) ? "Supported" : "Not Supported";
}

void emberAfPumpConfigurationAndControlClusterServerInitCallback(EndpointId endpoint)
{
    emberAfDebugPrintln("Initialize PCC Server Cluster [EP:%d]", endpoint);

    // Determine the internal feature set of the pump, depending on the pump
    // specific attributes available, and their values. This is a temporary
    // implementation to get a kind of "pseudo-FeatureMap" until we get a real
    // FeatureMap implementation in the PCC cluster. If an attribute is
    // present/available, then there is a possibility for the associated
    // feature being present as well. But we will have to distinguis between
    // the attributes being available and null also. At this point (init)
    // we can only examine the list of attributes available, and then detect
    // if they each have a NonNull value. Later on, when the pump application
    // has finished its init process, it might setup these attributevalues
    // to something NonNull, and then we must re-calcualte the feature set.

    emberAfDebugPrintln(
        "Constant Pressure %s",
        FeatureSupportedDebugString(endpoint, Attributes::MinConstPressure::Get, Attributes::MaxConstPressure::Get));
    emberAfDebugPrintln("PCC Server: Constant Proportional Pressure %s",
                        FeatureSupportedDebugString(endpoint, Attributes::MinCompPressure::Get, Attributes::MaxCompPressure::Get));
    emberAfDebugPrintln("PCC Server: Constant Flow %s",
                        FeatureSupportedDebugString(endpoint, Attributes::MinConstFlow::Get, Attributes::MaxConstFlow::Get));
    emberAfDebugPrintln("PCC Server: Constant Temperature %s",
                        FeatureSupportedDebugString(endpoint, Attributes::MinConstTemp::Get, Attributes::MaxConstTemp::Get));
    emberAfDebugPrintln("PCC Server: Constant Speed %s",
                        FeatureSupportedDebugString(endpoint, Attributes::MinConstSpeed::Get, Attributes::MaxConstSpeed::Get));

    if (!emberAfContainsAttribute(endpoint, PumpConfigurationAndControl::Id, Attributes::ControlMode::Id))
    {
        emberAfDebugPrintln("PCC Server: ControlMode attribute not available");
    }

    if (!emberAfContainsAttribute(endpoint, PumpConfigurationAndControl::Id, Attributes::PumpStatus::Id))
    {
        emberAfDebugPrintln("PCC Server: PumpStatus attribute not available");
    }
}

chip::Protocols::InteractionModel::Status MatterPumpConfigurationAndControlClusterServerPreAttributeChangedCallback(
    const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value)
{
    emberAfDebugPrintln("PCC Server Cluster Attribute Pre-changed [EP:%d, ID:0x%x]", attributePath.mEndpointId,
                        (unsigned int) attributePath.mAttributeId);

    Protocols::InteractionModel::Status status = Protocols::InteractionModel::Status::Success;

    switch (attributePath.mAttributeId)
    {
    case Attributes::ControlMode::Id: {
        PumpControlMode controlMode;
        NumericAttributeTraits<PumpControlMode>::StorageType tmp;
        memcpy(&tmp, value, size);
        controlMode = NumericAttributeTraits<PumpControlMode>::StorageToWorking(tmp);
        switch (controlMode)
        {
        case PumpControlMode::kConstantFlow:
            if (!IsFeatureSupported(attributePath.mEndpointId, Attributes::MinConstFlow::Get, Attributes::MaxConstFlow::Get))
            {
                status = Protocols::InteractionModel::Status::ConstraintError;
            }
            break;
        case PumpControlMode::kConstantPressure:
            if (!IsFeatureSupported(attributePath.mEndpointId, Attributes::MinConstPressure::Get,
                                    Attributes::MaxConstPressure::Get))
            {
                status = Protocols::InteractionModel::Status::ConstraintError;
            }
            break;
        case PumpControlMode::kConstantSpeed:
            if (!IsFeatureSupported(attributePath.mEndpointId, Attributes::MinConstSpeed::Get, Attributes::MaxConstSpeed::Get))
            {
                status = Protocols::InteractionModel::Status::ConstraintError;
            }
            break;
        case PumpControlMode::kConstantTemperature:
            if (!IsFeatureSupported(attributePath.mEndpointId, Attributes::MinConstTemp::Get, Attributes::MaxConstTemp::Get))
            {
                status = Protocols::InteractionModel::Status::ConstraintError;
            }
            break;
        case PumpControlMode::kProportionalPressure:
            if (!IsFeatureSupported(attributePath.mEndpointId, Attributes::MinCompPressure::Get, Attributes::MaxCompPressure::Get))
            {
                status = Protocols::InteractionModel::Status::ConstraintError;
            }
            break;
        case PumpControlMode::kAutomatic:
            status = Protocols::InteractionModel::Status::Success;
            break;
        case PumpControlMode::kUnknownEnumValue:
            status = Protocols::InteractionModel::Status::ConstraintError;
            break;
        }
    }
    break;

    case Attributes::OperationMode::Id:
        PumpOperationMode operationMode;
        NumericAttributeTraits<PumpOperationMode>::StorageType tmp;
        memcpy(&tmp, value, size);
        operationMode = NumericAttributeTraits<PumpOperationMode>::StorageToWorking(tmp);

        switch (operationMode)
        {
        case PumpOperationMode::kMinimum:
            if (!IsFeatureSupported(attributePath.mEndpointId, Attributes::MinConstSpeed::Get, Attributes::MaxConstSpeed::Get))
            {
                status = Protocols::InteractionModel::Status::ConstraintError;
            }
            break;
        case PumpOperationMode::kMaximum:
            if (!IsFeatureSupported(attributePath.mEndpointId, Attributes::MinConstSpeed::Get, Attributes::MaxConstSpeed::Get))
            {
                status = Protocols::InteractionModel::Status::ConstraintError;
            }
            break;
        case PumpOperationMode::kLocal:
        case PumpOperationMode::kNormal:
            status = Protocols::InteractionModel::Status::Success;
            break;
        case PumpOperationMode::kUnknownEnumValue:
            status = Protocols::InteractionModel::Status::ConstraintError;
            break;
        }

        break;
    default:
        status = Protocols::InteractionModel::Status::Success;
    }

    return status;
}

void MatterPumpConfigurationAndControlClusterServerAttributeChangedCallback(const app::ConcreteAttributePath & attributePath)
{
    emberAfDebugPrintln("PCC Server Cluster Attribute changed [EP:%d, ID:0x%x]", attributePath.mEndpointId,
                        (unsigned int) attributePath.mAttributeId);

    switch (attributePath.mAttributeId)
    {
    case Attributes::ControlMode::Id: {
        updateAttributeLinks(attributePath.mEndpointId);
    }
    break;
    case Attributes::OperationMode::Id: {
        updateAttributeLinks(attributePath.mEndpointId);
    }
    break;
    default:
        emberAfDebugPrintln("PCC Server: unhandled attribute ID");
    }
}

void MatterPumpConfigurationAndControlPluginServerInitCallback()
{
    emberAfDebugPrintln("Initialize PCC Plugin Server Cluster.");

    registerAttributeAccessOverride(&gAttrAccess);
}