/*
 *
 *    Copyright (c) 2024 Project CHIP Authors
 *    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.
 */
#include "electrical-power-measurement-server.h"

#include <protocols/interaction_model/StatusCode.h>

#include <app/AttributeAccessInterface.h>
#include <app/AttributeAccessInterfaceRegistry.h>
#include <app/EventLogging.h>
#include <app/reporting/reporting.h>
#include <app/util/attribute-storage.h>

using namespace chip;
using namespace chip::app;
using namespace chip::app::DataModel;
using namespace chip::app::Clusters;
using namespace chip::app::Clusters::ElectricalPowerMeasurement;
using namespace chip::app::Clusters::ElectricalPowerMeasurement::Attributes;
using namespace chip::app::Clusters::ElectricalPowerMeasurement::Structs;

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

namespace chip {
namespace app {
namespace Clusters {
namespace ElectricalPowerMeasurement {

CHIP_ERROR Instance::Init()
{
    VerifyOrReturnError(AttributeAccessInterfaceRegistry::Instance().Register(this), CHIP_ERROR_INCORRECT_STATE);
    return CHIP_NO_ERROR;
}

void Instance::Shutdown()
{
    AttributeAccessInterfaceRegistry::Instance().Unregister(this);
}

bool Instance::HasFeature(Feature aFeature) const
{
    return mFeature.Has(aFeature);
}

bool Instance::SupportsOptAttr(OptionalAttributes aOptionalAttrs) const
{
    return mOptionalAttrs.Has(aOptionalAttrs);
}

// AttributeAccessInterface
CHIP_ERROR Instance::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder)
{
    switch (aPath.mAttributeId)
    {
    case FeatureMap::Id:
        ReturnErrorOnFailure(aEncoder.Encode(mFeature));
        break;
    case PowerMode::Id:
        ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetPowerMode()));
        break;
    case NumberOfMeasurementTypes::Id:
        ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetNumberOfMeasurementTypes()));
        break;
    case Accuracy::Id:
        ReturnErrorOnFailure(
            aEncoder.EncodeList([this](const auto & encoder) -> CHIP_ERROR { return this->EncodeAccuracy(encoder); }));
        break;
    case Ranges::Id:
        if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeRanges))
        {
            return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
        }
        ReturnErrorOnFailure(
            aEncoder.EncodeList([this](const auto & encoder) -> CHIP_ERROR { return this->EncodeRanges(encoder); }));
        break;
    case Voltage::Id:
        if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeVoltage))
        {
            return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
        }
        ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetVoltage()));
        break;
    case ActiveCurrent::Id:
        if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeActiveCurrent))
        {
            return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
        }
        ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetActiveCurrent()));
        break;
    case ReactiveCurrent::Id:
        if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeReactiveCurrent))
        {
            return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
        }
        VerifyOrReturnError(
            HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE,
            ChipLogError(Zcl, "Electrical Power Measurement: can not get ReactiveCurrent, feature is not supported"));
        ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetReactiveCurrent()));
        break;
    case ApparentCurrent::Id:
        if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeApparentCurrent))
        {
            return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
        }
        VerifyOrReturnError(
            HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE,
            ChipLogError(Zcl, "Electrical Power Measurement: can not get ApparentCurrent, feature is not supported"));
        ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetApparentCurrent()));
        break;
    case ActivePower::Id:
        ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetActivePower()));
        break;
    case ReactivePower::Id:
        if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeReactivePower))
        {
            return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
        }
        VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent),
                            CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE,
                            ChipLogError(Zcl, "Electrical Power Measurement: can not get ReactivePower, feature is not supported"));
        ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetReactivePower()));
        break;
    case ApparentPower::Id:
        if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeApparentPower))
        {
            return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
        }
        VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent),
                            CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE,
                            ChipLogError(Zcl, "Electrical Power Measurement: can not get ApparentPower, feature is not supported"));
        ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetApparentPower()));
        break;
    case RMSVoltage::Id:
        if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeRMSVoltage))
        {
            return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
        }
        VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent),
                            CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE,
                            ChipLogError(Zcl, "Electrical Power Measurement: can not get RMSVoltage, feature is not supported"));
        ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetRMSVoltage()));
        break;
    case RMSCurrent::Id:
        if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeRMSCurrent))
        {
            return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
        }
        VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent),
                            CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE,
                            ChipLogError(Zcl, "Electrical Power Measurement: can not get RMSCurrent, feature is not supported"));
        ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetRMSCurrent()));
        break;
    case RMSPower::Id:
        if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeRMSPower))
        {
            return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
        }
        VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent),
                            CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE,
                            ChipLogError(Zcl, "Electrical Power Measurement: can not get RMSPower, feature is not supported"));
        ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetRMSPower()));
        break;
    case Frequency::Id:
        if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeFrequency))
        {
            return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
        }
        VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent),
                            CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE,
                            ChipLogError(Zcl, "Electrical Power Measurement: can not get Frequency, feature is not supported"));
        ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetFrequency()));
        break;
    case HarmonicCurrents::Id:
        VerifyOrReturnError(
            HasFeature(ElectricalPowerMeasurement::Feature::kHarmonics), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE,
            ChipLogError(Zcl, "Electrical Power Measurement: can not get HarmonicCurrents, feature is not supported"));
        ReturnErrorOnFailure(
            aEncoder.EncodeList([this](const auto & encoder) -> CHIP_ERROR { return this->EncodeHarmonicCurrents(encoder); }));
        break;
    case HarmonicPhases::Id:
        VerifyOrReturnError(
            HasFeature(ElectricalPowerMeasurement::Feature::kPowerQuality), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE,
            ChipLogError(Zcl, "Electrical Power Measurement: can not get HarmonicPhases, feature is not supported"));
        ReturnErrorOnFailure(
            aEncoder.EncodeList([this](const auto & encoder) -> CHIP_ERROR { return this->EncodeHarmonicPhases(encoder); }));
        break;
    case PowerFactor::Id:
        if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributePowerFactor))
        {
            return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
        }
        VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent),
                            CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE,
                            ChipLogError(Zcl, "Electrical Power Measurement: can not get PowerFactor, feature is not supported"));
        ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetPowerFactor()));
        break;
    case NeutralCurrent::Id:
        if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeNeutralCurrent))
        {
            return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
        }
        VerifyOrReturnError(
            HasFeature(ElectricalPowerMeasurement::Feature::kPolyphasePower), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE,
            ChipLogError(Zcl, "Electrical Power Measurement: can not get NeutralCurrent, feature is not supported"));
        ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetNeutralCurrent()));
        break;
    }
    return CHIP_NO_ERROR;
}

CHIP_ERROR Instance::EncodeAccuracy(const AttributeValueEncoder::ListEncodeHelper & encoder)
{
    CHIP_ERROR err = CHIP_NO_ERROR;

    ReturnErrorOnFailure(mDelegate.StartAccuracyRead());
    for (uint8_t i = 0; true; i++)
    {
        Structs::MeasurementAccuracyStruct::Type accuracy;

        err = mDelegate.GetAccuracyByIndex(i, accuracy);
        if (err == CHIP_ERROR_PROVIDER_LIST_EXHAUSTED)
        {
            // Convert end of list to CHIP_NO_ERROR
            err = CHIP_NO_ERROR;
            goto exit;
        }

        // Check if another error occurred before trying to encode
        SuccessOrExit(err);

        err = encoder.Encode(accuracy);
        SuccessOrExit(err);
    }

exit:
    // Tell the delegate the read is complete
    mDelegate.EndAccuracyRead();
    return err;
}

CHIP_ERROR Instance::EncodeRanges(const AttributeValueEncoder::ListEncodeHelper & encoder)
{
    CHIP_ERROR err = CHIP_NO_ERROR;

    ReturnErrorOnFailure(mDelegate.StartRangesRead());
    for (uint8_t i = 0; true; i++)
    {
        Structs::MeasurementRangeStruct::Type range;

        err = mDelegate.GetRangeByIndex(i, range);
        if (err == CHIP_ERROR_PROVIDER_LIST_EXHAUSTED)
        {
            // Convert end of list to CHIP_NO_ERROR
            err = CHIP_NO_ERROR;
            goto exit;
        }

        // Check if another error occurred before trying to encode
        SuccessOrExit(err);

        err = encoder.Encode(range);
        SuccessOrExit(err);
    }

exit:
    // Tell the delegate the read is complete
    err = mDelegate.EndRangesRead();
    return err;
}

CHIP_ERROR Instance::EncodeHarmonicCurrents(const AttributeValueEncoder::ListEncodeHelper & encoder)
{
    CHIP_ERROR err = CHIP_NO_ERROR;

    ReturnErrorOnFailure(mDelegate.StartHarmonicCurrentsRead());
    for (uint8_t i = 0; true; i++)
    {
        Structs::HarmonicMeasurementStruct::Type current;

        err = mDelegate.GetHarmonicCurrentsByIndex(i, current);
        if (err == CHIP_ERROR_PROVIDER_LIST_EXHAUSTED)
        {
            // Convert end of list to CHIP_NO_ERROR
            err = CHIP_NO_ERROR;
            goto exit;
        }
        // Check if another error occurred before trying to encode
        SuccessOrExit(err);

        err = encoder.Encode(current);
        SuccessOrExit(err);
    }

exit:
    // Tell the delegate the read is complete
    err = mDelegate.EndHarmonicCurrentsRead();
    return err;
}

CHIP_ERROR Instance::EncodeHarmonicPhases(const AttributeValueEncoder::ListEncodeHelper & encoder)
{
    CHIP_ERROR err = CHIP_NO_ERROR;

    ReturnErrorOnFailure(mDelegate.StartHarmonicPhasesRead());
    for (uint8_t i = 0; true; i++)
    {
        Structs::HarmonicMeasurementStruct::Type phase;

        err = mDelegate.GetHarmonicPhasesByIndex(i, phase);
        if (err == CHIP_ERROR_PROVIDER_LIST_EXHAUSTED)
        {
            // Convert end of list to CHIP_NO_ERROR
            err = CHIP_NO_ERROR;
            goto exit;
        }
        // Check if another error occurred before trying to encode
        SuccessOrExit(err);

        err = encoder.Encode(phase);
        SuccessOrExit(err);
    }

exit:
    // Tell the delegate the read is complete
    err = mDelegate.EndHarmonicPhasesRead();
    return err;
}

} // namespace ElectricalPowerMeasurement
} // namespace Clusters
} // namespace app
} // namespace chip