/**

 *

 *    Copyright (c) 2023 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 "SmokeCoAlarmCluster.h"

#include <app/server-cluster/AttributeListBuilder.h>

#include <clusters/SmokeCoAlarm/Metadata.h>

using namespace chip::app::Clusters::SmokeCoAlarm;

using namespace chip::app::Clusters::SmokeCoAlarm::Attributes;

using chip::Protocols::InteractionModel::Status;

namespace chip {

namespace app {

namespace Clusters {

SmokeCoAlarmCluster::SmokeCoAlarmCluster(EndpointId endpointId) : SmokeCoAlarmCluster(endpointId, Config{}) {}

SmokeCoAlarmCluster::SmokeCoAlarmCluster(EndpointId endpointId, const Config & config) :

    DefaultServerCluster({ endpointId, Id }), mConfig(config), mInoperativeWhenUnmounted(config.inoperativeWhenUnmounted)

{}

bool SmokeCoAlarmCluster::SetSmokeState(AlarmStateEnum newSmokeState)

{

    VerifyOrReturnValue(SupportsSmokeAlarm(), false);

    if (!SetAttributeValue(mSmokeState, newSmokeState, SmokeState::Id))

    {

        return true;

    }

    if (mContext != nullptr && (newSmokeState == AlarmStateEnum::kWarning || newSmokeState == AlarmStateEnum::kCritical))

    {

        Events::SmokeAlarm::Type event{ newSmokeState };

        mContext->interactionContext.eventsGenerator.GenerateEvent(event, mPath.mEndpointId);

    }

    if (newSmokeState == AlarmStateEnum::kCritical)

    {

        SetDeviceMuted(MuteStateEnum::kNotMuted);

    }

    return true;

}

bool SmokeCoAlarmCluster::SetCOState(AlarmStateEnum newCOState)

{

    VerifyOrReturnValue(SupportsCOAlarm(), false);

    if (!SetAttributeValue(mCOState, newCOState, COState::Id))

    {

        return true;

    }

    if (mContext != nullptr && (newCOState == AlarmStateEnum::kWarning || newCOState == AlarmStateEnum::kCritical))

    {

        Events::COAlarm::Type event{ newCOState };

        mContext->interactionContext.eventsGenerator.GenerateEvent(event, mPath.mEndpointId);

    }

    if (newCOState == AlarmStateEnum::kCritical)

    {

        SetDeviceMuted(MuteStateEnum::kNotMuted);

    }

    return true;

}

void SmokeCoAlarmCluster::SetBatteryAlert(AlarmStateEnum newBatteryAlert)

{

    if (!SetAttributeValue(mBatteryAlert, newBatteryAlert, BatteryAlert::Id))

    {

        return;

    }

    if (mContext != nullptr && (newBatteryAlert == AlarmStateEnum::kWarning || newBatteryAlert == AlarmStateEnum::kCritical))

    {

        Events::LowBattery::Type event{ newBatteryAlert };

        mContext->interactionContext.eventsGenerator.GenerateEvent(event, mPath.mEndpointId);

    }

    if (newBatteryAlert == AlarmStateEnum::kCritical)

    {

        SetDeviceMuted(MuteStateEnum::kNotMuted);

    }

}

bool SmokeCoAlarmCluster::SetDeviceMuted(MuteStateEnum newDeviceMuted)

{

    VerifyOrReturnValue(mConfig.optionalAttribs.IsSet(DeviceMuted::Id), false);

    if (mDeviceMuted == newDeviceMuted)

    {

        return true;

    }

    if (newDeviceMuted == MuteStateEnum::kMuted)

    {

        // Cannot mute while any alarm is in Critical state.

        // All alarm state members are always present and default to kNormal

        VerifyOrReturnValue(mSmokeState != AlarmStateEnum::kCritical, false);

        VerifyOrReturnValue(mCOState != AlarmStateEnum::kCritical, false);

        VerifyOrReturnValue(mBatteryAlert != AlarmStateEnum::kCritical, false);

        VerifyOrReturnValue(mInterconnectSmokeAlarm != AlarmStateEnum::kCritical, false);

        VerifyOrReturnValue(mInterconnectCOAlarm != AlarmStateEnum::kCritical, false);

    }

    SetAttributeValue(mDeviceMuted, newDeviceMuted, DeviceMuted::Id);

    if (mContext != nullptr)

    {

        if (newDeviceMuted == MuteStateEnum::kMuted)

        {

            Events::AlarmMuted::Type event{};

            mContext->interactionContext.eventsGenerator.GenerateEvent(event, mPath.mEndpointId);

        }

        else if (newDeviceMuted == MuteStateEnum::kNotMuted)

        {

            Events::MuteEnded::Type event{};

            mContext->interactionContext.eventsGenerator.GenerateEvent(event, mPath.mEndpointId);

        }

    }

    return true;

}

void SmokeCoAlarmCluster::SetTestInProgress(bool newTestInProgress)

{

    if (!SetAttributeValue(mTestInProgress, newTestInProgress, TestInProgress::Id))

    {

        return;

    }

    if (!newTestInProgress && mContext != nullptr)

    {

        Events::SelfTestComplete::Type event{};

        mContext->interactionContext.eventsGenerator.GenerateEvent(event, mPath.mEndpointId);

    }

}

void SmokeCoAlarmCluster::SetHardwareFaultAlert(bool newHardwareFaultAlert)

{

    if (!SetAttributeValue(mHardwareFaultAlert, newHardwareFaultAlert, HardwareFaultAlert::Id))

    {

        return;

    }

    if (newHardwareFaultAlert && mContext != nullptr)

    {

        Events::HardwareFault::Type event{};

        mContext->interactionContext.eventsGenerator.GenerateEvent(event, mPath.mEndpointId);

    }

}

void SmokeCoAlarmCluster::SetEndOfServiceAlert(EndOfServiceEnum newEndOfServiceAlert)

{

    if (!SetAttributeValue(mEndOfServiceAlert, newEndOfServiceAlert, EndOfServiceAlert::Id))

    {

        return;

    }

    if (newEndOfServiceAlert == EndOfServiceEnum::kExpired && mContext != nullptr)

    {

        Events::EndOfService::Type event{};

        mContext->interactionContext.eventsGenerator.GenerateEvent(event, mPath.mEndpointId);

    }

}

bool SmokeCoAlarmCluster::SetInterconnectSmokeAlarm(AlarmStateEnum newInterconnectSmokeAlarm)

{

    VerifyOrReturnValue(mConfig.optionalAttribs.IsSet(InterconnectSmokeAlarm::Id), false);

    if (!SetAttributeValue(mInterconnectSmokeAlarm, newInterconnectSmokeAlarm, InterconnectSmokeAlarm::Id))

    {

        return true;

    }

    if (mContext != nullptr &&

        (newInterconnectSmokeAlarm == AlarmStateEnum::kWarning || newInterconnectSmokeAlarm == AlarmStateEnum::kCritical))

    {

        Events::InterconnectSmokeAlarm::Type event{ newInterconnectSmokeAlarm };

        mContext->interactionContext.eventsGenerator.GenerateEvent(event, mPath.mEndpointId);

    }

    if (newInterconnectSmokeAlarm == AlarmStateEnum::kCritical)

    {

        SetDeviceMuted(MuteStateEnum::kNotMuted);

    }

    return true;

}

bool SmokeCoAlarmCluster::SetInterconnectCOAlarm(AlarmStateEnum newInterconnectCOAlarm)

{

    VerifyOrReturnValue(mConfig.optionalAttribs.IsSet(InterconnectCOAlarm::Id), false);

    if (!SetAttributeValue(mInterconnectCOAlarm, newInterconnectCOAlarm, InterconnectCOAlarm::Id))

    {

        return true;

    }

    if (mContext != nullptr &&

        (newInterconnectCOAlarm == AlarmStateEnum::kWarning || newInterconnectCOAlarm == AlarmStateEnum::kCritical))

    {

        Events::InterconnectCOAlarm::Type event{ newInterconnectCOAlarm };

        mContext->interactionContext.eventsGenerator.GenerateEvent(event, mPath.mEndpointId);

    }

    if (newInterconnectCOAlarm == AlarmStateEnum::kCritical)

    {

        SetDeviceMuted(MuteStateEnum::kNotMuted);

    }

    return true;

}

void SmokeCoAlarmCluster::SetContaminationState(ContaminationStateEnum newContaminationState)

{

    VerifyOrReturn(SupportsSmokeAlarm());

    SetAttributeValue(mContaminationState, newContaminationState, ContaminationState::Id);

}

void SmokeCoAlarmCluster::SetSmokeSensitivityLevel(SensitivityEnum newSmokeSensitivityLevel)

{

    VerifyOrReturn(SupportsSmokeAlarm());

    SetAttributeValue(mSmokeSensitivityLevel, newSmokeSensitivityLevel, SmokeSensitivityLevel::Id);

    if (mDelegate != nullptr)

    {

        mDelegate->OnSmokeSensitivityLevelChanged(newSmokeSensitivityLevel);

    }

}

void SmokeCoAlarmCluster::SetExpiryDate(uint32_t newExpiryDate)

{

    VerifyOrReturn(mConfig.optionalAttribs.IsSet(ExpiryDate::Id));

    SetAttributeValue(mExpiryDate, newExpiryDate, ExpiryDate::Id);

}

bool SmokeCoAlarmCluster::SetUnmountedState(bool isUnmounted)

{

    VerifyOrReturnValue(mConfig.optionalAttribs.IsSet(Unmounted::Id), false);

    if (!SetAttributeValue(mUnmounted, isUnmounted, Unmounted::Id))

    {

        return true;

    }

    if (mInoperativeWhenUnmounted)

    {

        if (isUnmounted)

        {

            SetExpressedState(ExpressedStateEnum::kInoperative);

        }

        else if (mExpressedState == ExpressedStateEnum::kInoperative)

        {

            SetExpressedState(ExpressedStateEnum::kNormal);

        }

    }

    return true;

}

void SmokeCoAlarmCluster::SetExpressedStateByPriority(const std::array<ExpressedStateEnum, kPriorityOrderLength> & priorityOrder)

{

    for (ExpressedStateEnum priority : priorityOrder)

    {

        AlarmStateEnum alarmState          = AlarmStateEnum::kNormal;

        EndOfServiceEnum endOfServiceState = EndOfServiceEnum::kNormal;

        bool active                        = false;

        bool unmounted                     = false;

        switch (priority)

        {

        case ExpressedStateEnum::kSmokeAlarm:

            alarmState = GetSmokeState();

            break;

        case ExpressedStateEnum::kCOAlarm:

            alarmState = GetCOState();

            break;

        case ExpressedStateEnum::kBatteryAlert:

            alarmState = GetBatteryAlert();

            break;

        case ExpressedStateEnum::kTesting:

            active = GetTestInProgress();

            break;

        case ExpressedStateEnum::kHardwareFault:

            active = GetHardwareFaultAlert();

            break;

        case ExpressedStateEnum::kEndOfService:

            endOfServiceState = GetEndOfServiceAlert();

            break;

        case ExpressedStateEnum::kInterconnectSmoke:

            alarmState = GetInterconnectSmokeAlarm();

            break;

        case ExpressedStateEnum::kInterconnectCO:

            alarmState = GetInterconnectCOAlarm();

            break;

        case ExpressedStateEnum::kInoperative:

            unmounted = GetUnmountedState();

            break;

        default:

            break;

        }

        if ((alarmState != AlarmStateEnum::kNormal) || (endOfServiceState != EndOfServiceEnum::kNormal) || active || unmounted)

        {

            SetExpressedState(priority);

            return;

        }

    }

    SetExpressedState(ExpressedStateEnum::kNormal);

}

bool SmokeCoAlarmCluster::RequestSelfTest()

{

    if (mExpressedState == ExpressedStateEnum::kSmokeAlarm || mExpressedState == ExpressedStateEnum::kCOAlarm ||

        mExpressedState == ExpressedStateEnum::kTesting || mExpressedState == ExpressedStateEnum::kInterconnectSmoke ||

        mExpressedState == ExpressedStateEnum::kInterconnectCO)

    {

        return false;

    }

    SetTestInProgress(true);

    SetExpressedState(ExpressedStateEnum::kTesting);

    if (mDelegate != nullptr)

    {

        mDelegate->OnSelfTestRequested();

    }

    return true;

}

DataModel::ActionReturnStatus SmokeCoAlarmCluster::ReadAttribute(const DataModel::ReadAttributeRequest & request,

                                                                 AttributeValueEncoder & encoder)

{

    switch (request.path.mAttributeId)

    {

    case ClusterRevision::Id:

        return encoder.Encode(SmokeCoAlarm::kRevision);

    case FeatureMap::Id:

        return encoder.Encode(mConfig.featureMap);

    case ExpressedState::Id:

        return encoder.Encode(mExpressedState);

    case SmokeState::Id:

        return encoder.Encode(mSmokeState);

    case COState::Id:

        return encoder.Encode(mCOState);

    case BatteryAlert::Id:

        return encoder.Encode(mBatteryAlert);

    case DeviceMuted::Id:

        return encoder.Encode(mDeviceMuted);

    case TestInProgress::Id:

        return encoder.Encode(mTestInProgress);

    case HardwareFaultAlert::Id:

        return encoder.Encode(mHardwareFaultAlert);

    case EndOfServiceAlert::Id:

        return encoder.Encode(mEndOfServiceAlert);

    case InterconnectSmokeAlarm::Id:

        return encoder.Encode(mInterconnectSmokeAlarm);

    case InterconnectCOAlarm::Id:

        return encoder.Encode(mInterconnectCOAlarm);

    case ContaminationState::Id:

        return encoder.Encode(mContaminationState);

    case SmokeSensitivityLevel::Id:

        return encoder.Encode(mSmokeSensitivityLevel);

    case ExpiryDate::Id:

        return encoder.Encode(mExpiryDate);

    case Unmounted::Id:

        return encoder.Encode(mUnmounted);

    default:

        return Status::UnsupportedAttribute;

    }

}

DataModel::ActionReturnStatus SmokeCoAlarmCluster::WriteAttribute(const DataModel::WriteAttributeRequest & request,

                                                                  AttributeValueDecoder & decoder)

{

    if (request.path.mAttributeId != SmokeSensitivityLevel::Id)

    {

        return Status::UnsupportedWrite;

    }

    SensitivityEnum value;

    ReturnErrorOnFailure(decoder.Decode(value));

    SetSmokeSensitivityLevel(value);

    return Status::Success;

}

CHIP_ERROR SmokeCoAlarmCluster::Attributes(const ConcreteClusterPath & path,

                                           ReadOnlyBufferBuilder<DataModel::AttributeEntry> & builder)

{

    AttributeListBuilder listBuilder(builder);

    const AttributeListBuilder::OptionalAttributeEntry optionalAttributes[] = {

        { mConfig.featureMap.Has(Feature::kSmokeAlarm), SmokeState::kMetadataEntry },

        { mConfig.featureMap.Has(Feature::kCoAlarm), COState::kMetadataEntry },

        { mConfig.optionalAttribs.IsSet(DeviceMuted::Id), DeviceMuted::kMetadataEntry },

        { mConfig.optionalAttribs.IsSet(InterconnectSmokeAlarm::Id), InterconnectSmokeAlarm::kMetadataEntry },

        { mConfig.optionalAttribs.IsSet(InterconnectCOAlarm::Id), InterconnectCOAlarm::kMetadataEntry },

        { mConfig.featureMap.Has(Feature::kSmokeAlarm), ContaminationState::kMetadataEntry },

        { mConfig.featureMap.Has(Feature::kSmokeAlarm), SmokeSensitivityLevel::kMetadataEntry },

        { mConfig.optionalAttribs.IsSet(ExpiryDate::Id), ExpiryDate::kMetadataEntry },

        { mConfig.optionalAttribs.IsSet(Unmounted::Id), Unmounted::kMetadataEntry },

    };

    return listBuilder.Append(Span(kMandatoryMetadata), Span(optionalAttributes));

}

std::optional<DataModel::ActionReturnStatus> SmokeCoAlarmCluster::InvokeCommand(const DataModel::InvokeRequest & request,

                                                                                chip::TLV::TLVReader & input_arguments,

                                                                                CommandHandler * handler)

{

    switch (request.path.mCommandId)

    {

    case Commands::SelfTestRequest::Id:

        return HandleRemoteSelfTestRequest();

    default:

        return Status::UnsupportedCommand;

    }

}

CHIP_ERROR SmokeCoAlarmCluster::AcceptedCommands(const ConcreteClusterPath & path,

                                                 ReadOnlyBufferBuilder<DataModel::AcceptedCommandEntry> & builder)

{

    return builder.AppendElements({ Commands::SelfTestRequest::kMetadataEntry });

}

void SmokeCoAlarmCluster::SetExpressedState(ExpressedStateEnum newExpressedState)

{

    if (!SetAttributeValue(mExpressedState, newExpressedState, ExpressedState::Id))

    {

        return;

    }

    if (newExpressedState == ExpressedStateEnum::kNormal && mContext != nullptr)

    {

        Events::AllClear::Type event{};

        mContext->interactionContext.eventsGenerator.GenerateEvent(event, mPath.mEndpointId);

    }

    if (mDelegate != nullptr)

    {

        mDelegate->OnExpressedStateChanged(newExpressedState);

    }

}

Status SmokeCoAlarmCluster::HandleRemoteSelfTestRequest()

{

    if (mExpressedState == ExpressedStateEnum::kSmokeAlarm || mExpressedState == ExpressedStateEnum::kCOAlarm ||

        mExpressedState == ExpressedStateEnum::kTesting || mExpressedState == ExpressedStateEnum::kInterconnectSmoke ||

        mExpressedState == ExpressedStateEnum::kInterconnectCO)

    {

        return Status::Busy;

    }

    SetTestInProgress(true);

    SetExpressedState(ExpressedStateEnum::kTesting);

    if (mDelegate != nullptr)

    {

        mDelegate->OnSelfTestRequested();

    }

    return Status::Success;

}

} // namespace Clusters

} // namespace app

} // namespace chip