/**
 *
 *    Copyright (c) 2024 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 "thermostat-server.h"

#include <app/GlobalAttributes.h>
#include <platform/internal/CHIPDeviceLayerInternal.h>

using namespace chip;
using namespace chip::app;
using namespace chip::app::Clusters;
using namespace chip::app::Clusters::Thermostat;
using namespace chip::app::Clusters::Thermostat::Attributes;
using namespace chip::app::Clusters::Thermostat::Structs;
using namespace chip::app::Clusters::Globals::Structs;
using namespace chip::Protocols::InteractionModel;

namespace chip {
namespace app {
namespace Clusters {
namespace Thermostat {

extern ThermostatAttrAccess gThermostatAttrAccess;

/**
 * @brief Callback that is called when the timeout for editing the presets expires.
 *
 * @param[in] systemLayer The system layer.
 * @param[in] callbackContext The context passed to the timer callback.
 */
void TimerExpiredCallback(System::Layer * systemLayer, void * callbackContext)
{
    EndpointId endpoint = static_cast<EndpointId>(reinterpret_cast<uintptr_t>(callbackContext));
    gThermostatAttrAccess.ResetAtomicWrite(endpoint);
}

namespace {

/**
 * @brief Schedules a timer for the given timeout in milliseconds.
 *
 * @param[in] endpoint The endpoint to use.
 * @param[in] timeoutMilliseconds The timeout in milliseconds.
 */
void ScheduleTimer(EndpointId endpoint, System::Clock::Milliseconds16 timeout)
{
    DeviceLayer::SystemLayer().StartTimer(timeout, TimerExpiredCallback,
                                          reinterpret_cast<void *>(static_cast<uintptr_t>(endpoint)));
}

/**
 * @brief Clears the currently scheduled timer.
 *
 * @param[in] endpoint The endpoint to use.
 */
void ClearTimer(EndpointId endpoint)
{
    DeviceLayer::SystemLayer().CancelTimer(TimerExpiredCallback, reinterpret_cast<void *>(static_cast<uintptr_t>(endpoint)));
}

/**
 * @brief Get the source scoped node id.
 *
 * @param[in] commandObj The command handler object.
 *
 * @return The scoped node id of the source node. If the scoped node id is not retreived, return ScopedNodeId().
 */
ScopedNodeId GetSourceScopedNodeId(CommandHandler * commandObj)
{
    ScopedNodeId sourceNodeId = ScopedNodeId();
    auto sessionHandle        = commandObj->GetExchangeContext()->GetSessionHandle();

    if (sessionHandle->IsSecureSession())
    {
        sourceNodeId = sessionHandle->AsSecureSession()->GetPeer();
    }
    else if (sessionHandle->IsGroupSession())
    {
        sourceNodeId = sessionHandle->AsIncomingGroupSession()->GetPeer();
    }
    return sourceNodeId;
}

/**
 * @brief Counts the number of attribute requests
 *
 * @param attributeRequests The decodable list of attribute IDs
 * @param attributeRequestCount The total number of attribute requests
 * @param requestedPresets Whether the Presets attribute was requested
 * @param requestedSchedules Whether the Schedules attribute was requested
 * @return true if the attribute list was counted
 * @return false if there was an error reading the list
 */
bool CountAttributeRequests(const DataModel::DecodableList<chip::AttributeId> attributeRequests, size_t & attributeRequestCount,
                            bool & requestedPresets, bool & requestedSchedules)
{
    attributeRequestCount = 0;
    requestedPresets      = false;
    requestedSchedules    = false;
    auto attributeIdsIter = attributeRequests.begin();
    while (attributeIdsIter.Next())
    {
        auto & attributeId = attributeIdsIter.GetValue();
        switch (attributeId)
        {
        case Presets::Id:
            requestedPresets = true;
            break;
        case Schedules::Id:
            requestedSchedules = true;
            break;
        default:
            break;
        }
        attributeRequestCount++;
    }
    return attributeIdsIter.GetStatus() == CHIP_NO_ERROR;
}

/// @brief Builds the list of attribute statuses to return from an AtomicRequest invocation
/// @param endpoint The associated endpoint for the AtomicRequest invocation
/// @param attributeRequests The list of requested attributes
/// @param attributeStatusCount The number of attribute statuses in attributeStatuses
/// @param attributeStatuses The status of each requested attribute, plus additional attributes if needed
/// @return Status::Success if the request is valid, an error status if it is not
Status BuildAttributeStatuses(const EndpointId endpoint, const DataModel::DecodableList<chip::AttributeId> attributeRequests,
                              Platform::ScopedMemoryBufferWithSize<AtomicAttributeStatusStruct::Type> & attributeStatuses)
{

    bool requestedPresets = false, requestedSchedules = false;
    size_t attributeStatusCount = 0;
    if (!CountAttributeRequests(attributeRequests, attributeStatusCount, requestedPresets, requestedSchedules))
    {
        // We errored reading the list
        return Status::InvalidCommand;
    }
    if (attributeStatusCount == 0)
    {
        // List can't be empty
        return Status::InvalidCommand;
    }
    attributeStatuses.Alloc(attributeStatusCount);
    for (size_t i = 0; i < attributeStatusCount; ++i)
    {
        attributeStatuses[i].attributeID = kInvalidAttributeId;
        attributeStatuses[i].statusCode  = 0;
    }
    auto attributeIdsIter = attributeRequests.begin();
    size_t index          = 0;
    while (attributeIdsIter.Next())
    {
        auto & attributeId = attributeIdsIter.GetValue();

        for (size_t i = 0; i < index; ++i)
        {
            auto & attributeStatus = attributeStatuses[i];
            if (attributeStatus.attributeID == attributeId)
            {
                // Double-requesting an attribute is invalid
                return Status::InvalidCommand;
            }
        }
        attributeStatuses[index].attributeID = attributeId;
        attributeStatuses[index].statusCode  = to_underlying(Status::Success);
        index++;
    }
    if (attributeIdsIter.GetStatus() != CHIP_NO_ERROR)
    {
        return Status::InvalidCommand;
    }
    for (size_t i = 0; i < index; ++i)
    {
        auto & attributeStatus = attributeStatuses[i];
        const EmberAfAttributeMetadata * metadata =
            emberAfLocateAttributeMetadata(endpoint, Thermostat::Id, attributeStatus.attributeID);

        if (metadata != nullptr)
        {
            // This is definitely an attribute we know about.
            continue;
        }

        if (IsSupportedGlobalAttributeNotInMetadata(attributeStatus.attributeID))
        {
            continue;
        }

        // This is not a valid attribute on the Thermostat cluster on the supplied endpoint
        return Status::InvalidCommand;
    }
    return Status::Success;
}

} // anonymous namespace

bool ThermostatAttrAccess::InAtomicWrite(EndpointId endpoint, Optional<AttributeId> attributeId)
{

    uint16_t ep =
        emberAfGetClusterServerEndpointIndex(endpoint, Thermostat::Id, MATTER_DM_THERMOSTAT_CLUSTER_SERVER_ENDPOINT_COUNT);

    if (ep >= ArraySize(mAtomicWriteSessions))
    {
        return false;
    }
    auto & atomicWriteSession = mAtomicWriteSessions[ep];
    if (atomicWriteSession.state != AtomicWriteState::Open)
    {
        return false;
    }
    if (!attributeId.HasValue())
    {
        return true;
    }
    for (size_t i = 0; i < atomicWriteSession.attributeIds.AllocatedSize(); ++i)
    {
        if (atomicWriteSession.attributeIds[i] == attributeId.Value())
        {
            return true;
        }
    }
    return false;
}

bool ThermostatAttrAccess::InAtomicWrite(EndpointId endpoint, const Access::SubjectDescriptor & subjectDescriptor,
                                         Optional<AttributeId> attributeId)
{
    if (!InAtomicWrite(endpoint, attributeId))
    {
        return false;
    }
    return subjectDescriptor.authMode == Access::AuthMode::kCase &&
        GetAtomicWriteOriginatorScopedNodeId(endpoint) == ScopedNodeId(subjectDescriptor.subject, subjectDescriptor.fabricIndex);
}

bool ThermostatAttrAccess::InAtomicWrite(EndpointId endpoint, CommandHandler * commandObj, Optional<AttributeId> attributeId)
{
    if (!InAtomicWrite(endpoint, attributeId))
    {
        return false;
    }
    ScopedNodeId sourceNodeId = GetSourceScopedNodeId(commandObj);
    return GetAtomicWriteOriginatorScopedNodeId(endpoint) == sourceNodeId;
}

bool ThermostatAttrAccess::InAtomicWrite(
    EndpointId endpoint, CommandHandler * commandObj,
    Platform::ScopedMemoryBufferWithSize<AtomicAttributeStatusStruct::Type> & attributeStatuses)
{
    uint16_t ep =
        emberAfGetClusterServerEndpointIndex(endpoint, Thermostat::Id, MATTER_DM_THERMOSTAT_CLUSTER_SERVER_ENDPOINT_COUNT);

    if (ep >= ArraySize(mAtomicWriteSessions))
    {
        return false;
    }
    auto & atomicWriteSession = mAtomicWriteSessions[ep];
    if (atomicWriteSession.state != AtomicWriteState::Open)
    {
        return false;
    }
    if (atomicWriteSession.attributeIds.AllocatedSize() == 0 ||
        atomicWriteSession.attributeIds.AllocatedSize() != attributeStatuses.AllocatedSize())
    {
        return false;
    }
    for (size_t i = 0; i < atomicWriteSession.attributeIds.AllocatedSize(); ++i)
    {
        bool hasAttribute = false;
        auto attributeId  = atomicWriteSession.attributeIds[i];
        for (size_t j = 0; j < attributeStatuses.AllocatedSize(); ++j)
        {
            auto & attributeStatus = attributeStatuses[j];
            if (attributeStatus.attributeID == attributeId)
            {
                hasAttribute = true;
                break;
            }
        }
        if (!hasAttribute)
        {
            return false;
        }
    }
    return true;
}

bool ThermostatAttrAccess::SetAtomicWrite(
    EndpointId endpoint, ScopedNodeId originatorNodeId, AtomicWriteState state,
    Platform::ScopedMemoryBufferWithSize<AtomicAttributeStatusStruct::Type> & attributeStatuses)
{
    uint16_t ep =
        emberAfGetClusterServerEndpointIndex(endpoint, Thermostat::Id, MATTER_DM_THERMOSTAT_CLUSTER_SERVER_ENDPOINT_COUNT);

    if (ep >= ArraySize(mAtomicWriteSessions))
    {
        return false;
    }

    auto & atomicWriteSession     = mAtomicWriteSessions[ep];
    atomicWriteSession.endpointId = endpoint;
    if (!atomicWriteSession.attributeIds.Alloc(attributeStatuses.AllocatedSize()))
    {
        atomicWriteSession.state  = AtomicWriteState::Closed;
        atomicWriteSession.nodeId = ScopedNodeId();
        return false;
    }

    atomicWriteSession.state  = state;
    atomicWriteSession.nodeId = originatorNodeId;

    for (size_t i = 0; i < attributeStatuses.AllocatedSize(); ++i)
    {
        atomicWriteSession.attributeIds[i] = attributeStatuses[i].attributeID;
    }
    return true;
}

void ThermostatAttrAccess::ResetAtomicWrite(EndpointId endpoint)
{
    auto delegate = GetDelegate(endpoint);
    if (delegate != nullptr)
    {
        delegate->ClearPendingPresetList();
    }
    ClearTimer(endpoint);
    uint16_t ep =
        emberAfGetClusterServerEndpointIndex(endpoint, Thermostat::Id, MATTER_DM_THERMOSTAT_CLUSTER_SERVER_ENDPOINT_COUNT);

    if (ep >= ArraySize(mAtomicWriteSessions))
    {
        return;
    }
    auto & atomicWriteSession     = mAtomicWriteSessions[ep];
    atomicWriteSession.state      = AtomicWriteState::Closed;
    atomicWriteSession.endpointId = endpoint;
    atomicWriteSession.nodeId     = ScopedNodeId();
    atomicWriteSession.attributeIds.Free();
}

ScopedNodeId ThermostatAttrAccess::GetAtomicWriteOriginatorScopedNodeId(const EndpointId endpoint)
{
    ScopedNodeId originatorNodeId = ScopedNodeId();
    uint16_t ep =
        emberAfGetClusterServerEndpointIndex(endpoint, Thermostat::Id, MATTER_DM_THERMOSTAT_CLUSTER_SERVER_ENDPOINT_COUNT);

    if (ep < ArraySize(mAtomicWriteSessions))
    {
        originatorNodeId = mAtomicWriteSessions[ep].nodeId;
    }
    return originatorNodeId;
}

void SendAtomicResponse(CommandHandler * commandObj, const ConcreteCommandPath & commandPath, Status status,
                        const Platform::ScopedMemoryBufferWithSize<AtomicAttributeStatusStruct::Type> & attributeStatuses,
                        Optional<uint16_t> timeout = NullOptional)
{
    Commands::AtomicResponse::Type response;
    response.statusCode = to_underlying(status);
    response.attributeStatus =
        DataModel::List<const AtomicAttributeStatusStruct::Type>(attributeStatuses.Get(), attributeStatuses.AllocatedSize());
    response.timeout = timeout;
    commandObj->AddResponse(commandPath, response);
}

void ThermostatAttrAccess::BeginAtomicWrite(CommandHandler * commandObj, const ConcreteCommandPath & commandPath,
                                            const Commands::AtomicRequest::DecodableType & commandData)
{
    EndpointId endpoint = commandPath.mEndpointId;

    auto delegate = GetDelegate(endpoint);

    if (delegate == nullptr)
    {
        ChipLogError(Zcl, "Delegate is null");
        commandObj->AddStatus(commandPath, Status::InvalidInState);
        return;
    }

    Platform::ScopedMemoryBufferWithSize<AtomicAttributeStatusStruct::Type> attributeStatuses;
    auto status = BuildAttributeStatuses(endpoint, commandData.attributeRequests, attributeStatuses);
    if (status != Status::Success)
    {
        commandObj->AddStatus(commandPath, status);
        return;
    }

    if (InAtomicWrite(endpoint, commandObj))
    {
        // This client already has an open atomic write
        commandObj->AddStatus(commandPath, Status::InvalidInState);
        return;
    }

    if (!commandData.timeout.HasValue())
    {
        commandObj->AddStatus(commandPath, Status::InvalidCommand);
        return;
    }

    auto maximumTimeout   = System::Clock::Milliseconds16(0);
    auto attributeIdsIter = commandData.attributeRequests.begin();
    while (attributeIdsIter.Next())
    {
        auto & attributeId = attributeIdsIter.GetValue();
        switch (attributeId)
        {
        case Presets::Id:
        case Schedules::Id:
            auto attributeTimeout = delegate->GetMaxAtomicWriteTimeout(attributeId);

            if (attributeTimeout.has_value())
            {
                // Add to the maximum timeout
                maximumTimeout += attributeTimeout.value();
            }
            break;
        }
    }

    status = Status::Success;
    for (size_t i = 0; i < attributeStatuses.AllocatedSize(); ++i)
    {
        // If we've gotten this far, then the client has manage permission to call AtomicRequest,
        // which is also the privilege necessary to write to the atomic attributes, so no need to do
        // the "If the client does not have sufficient privilege to write to the attribute" check
        // from the spec.
        auto & attributeStatus = attributeStatuses[i];
        auto statusCode        = Status::Success;
        switch (attributeStatus.attributeID)
        {
        case Presets::Id:
        case Schedules::Id:
            statusCode = InAtomicWrite(endpoint, MakeOptional(attributeStatus.attributeID)) ? Status::Busy : Status::Success;
            break;
        default:
            statusCode = Status::InvalidCommand;
            break;
        }
        if (statusCode != Status::Success)
        {
            status = Status::Failure;
        }
        attributeStatus.statusCode = to_underlying(statusCode);
    }

    auto timeout = std::min(System::Clock::Milliseconds16(commandData.timeout.Value()), maximumTimeout);

    if (status == Status::Success)
    {
        if (!SetAtomicWrite(endpoint, GetSourceScopedNodeId(commandObj), AtomicWriteState::Open, attributeStatuses))
        {
            for (size_t i = 0; i < attributeStatuses.AllocatedSize(); ++i)
            {
                attributeStatuses[i].statusCode = to_underlying(Status::ResourceExhausted);
            }
            status = Status::Failure;
        }
        else
        {
            // This is a valid request to open an atomic write. Tell the delegate it
            // needs to keep track of a pending preset list now.
            delegate->InitializePendingPresets();
            ScheduleTimer(endpoint, timeout);
        }
    }

    SendAtomicResponse(commandObj, commandPath, status, attributeStatuses, MakeOptional(timeout.count()));
}

void ThermostatAttrAccess::CommitAtomicWrite(CommandHandler * commandObj, const ConcreteCommandPath & commandPath,
                                             const Commands::AtomicRequest::DecodableType & commandData)
{
    EndpointId endpoint = commandPath.mEndpointId;
    auto delegate       = GetDelegate(endpoint);

    if (delegate == nullptr)
    {
        ChipLogError(Zcl, "Delegate is null");
        commandObj->AddStatus(commandPath, Status::InvalidInState);
        return;
    }

    Platform::ScopedMemoryBufferWithSize<AtomicAttributeStatusStruct::Type> attributeStatuses;
    auto status = BuildAttributeStatuses(endpoint, commandData.attributeRequests, attributeStatuses);
    if (status != Status::Success)
    {
        commandObj->AddStatus(commandPath, status);
        return;
    }

    if (!InAtomicWrite(endpoint, commandObj, attributeStatuses))
    {
        commandObj->AddStatus(commandPath, Status::InvalidInState);
        return;
    }

    status = Status::Success;
    for (size_t i = 0; i < attributeStatuses.AllocatedSize(); ++i)
    {
        auto & attributeStatus = attributeStatuses[i];
        auto statusCode        = Status::Success;
        switch (attributeStatus.attributeID)
        {
        case Presets::Id:
            statusCode = PrecommitPresets(endpoint);
            break;
        case Schedules::Id:
            statusCode = Status::Success;
            break;
        default:
            commandObj->AddStatus(commandPath, Status::InvalidInState);
            return;
        }
        attributeStatus.statusCode = to_underlying(statusCode);
        if (statusCode != Status::Success)
        {
            status = Status::Failure;
        }
    }

    if (status == Status::Success)
    {
        for (size_t i = 0; i < attributeStatuses.AllocatedSize(); ++i)
        {
            auto & attributeStatus = attributeStatuses[i];
            auto statusCode        = Status::Success;
            CHIP_ERROR err;
            switch (attributeStatus.attributeID)
            {
            case Presets::Id:
                err = delegate->CommitPendingPresets();
                if (err != CHIP_NO_ERROR)
                {
                    statusCode = Status::InvalidInState;
                }
                break;
            case Schedules::Id:
                break;
            default:
                // Not reachable, since we returned in this situation above.
                break;
            }
            attributeStatus.statusCode = to_underlying(statusCode);
            if (statusCode != Status::Success)
            {
                status = Status::Failure;
            }
        }
    }

    ResetAtomicWrite(endpoint);
    SendAtomicResponse(commandObj, commandPath, status, attributeStatuses);
}

void ThermostatAttrAccess::RollbackAtomicWrite(CommandHandler * commandObj, const ConcreteCommandPath & commandPath,
                                               const Commands::AtomicRequest::DecodableType & commandData)
{

    EndpointId endpoint = commandPath.mEndpointId;
    auto delegate       = GetDelegate(endpoint);

    if (delegate == nullptr)
    {
        ChipLogError(Zcl, "Delegate is null");
        commandObj->AddStatus(commandPath, Status::InvalidInState);
        return;
    }

    Platform::ScopedMemoryBufferWithSize<AtomicAttributeStatusStruct::Type> attributeStatuses;
    auto status = BuildAttributeStatuses(endpoint, commandData.attributeRequests, attributeStatuses);
    if (status != Status::Success)
    {
        commandObj->AddStatus(commandPath, status);
        return;
    }

    if (!InAtomicWrite(endpoint, commandObj, attributeStatuses))
    {
        // There's no open atomic write
        commandObj->AddStatus(commandPath, Status::InvalidInState);
        return;
    }

    ResetAtomicWrite(endpoint);

    for (size_t i = 0; i < attributeStatuses.AllocatedSize(); ++i)
    {
        attributeStatuses[i].statusCode = to_underlying(Status::Success);
    }

    SendAtomicResponse(commandObj, commandPath, status, attributeStatuses);
}

void MatterThermostatClusterServerShutdownCallback(EndpointId endpoint)
{
    ChipLogProgress(Zcl, "Shutting down thermostat server cluster on endpoint %d", endpoint);
    gThermostatAttrAccess.ResetAtomicWrite(endpoint);
}

bool emberAfThermostatClusterAtomicRequestCallback(CommandHandler * commandObj, const ConcreteCommandPath & commandPath,
                                                   const Clusters::Thermostat::Commands::AtomicRequest::DecodableType & commandData)
{
    auto & requestType = commandData.requestType;

    switch (requestType)
    {
    case Globals::AtomicRequestTypeEnum::kBeginWrite:
        gThermostatAttrAccess.BeginAtomicWrite(commandObj, commandPath, commandData);
        return true;
    case Globals::AtomicRequestTypeEnum::kCommitWrite:
        gThermostatAttrAccess.CommitAtomicWrite(commandObj, commandPath, commandData);
        return true;
    case Globals::AtomicRequestTypeEnum::kRollbackWrite:
        gThermostatAttrAccess.RollbackAtomicWrite(commandObj, commandPath, commandData);
        return true;
    case Globals::AtomicRequestTypeEnum::kUnknownEnumValue:
        commandObj->AddStatus(commandPath, Status::InvalidCommand);
        return true;
    }

    return false;
}

} // namespace Thermostat
} // namespace Clusters
} // namespace app
} // namespace chip

bool emberAfThermostatClusterAtomicRequestCallback(CommandHandler * commandObj, const ConcreteCommandPath & commandPath,
                                                   const Clusters::Thermostat::Commands::AtomicRequest::DecodableType & commandData)
{
    return Thermostat::emberAfThermostatClusterAtomicRequestCallback(commandObj, commandPath, commandData);
}

void MatterThermostatClusterServerShutdownCallback(EndpointId endpoint)
{
    Thermostat::MatterThermostatClusterServerShutdownCallback(endpoint);
}