/*
 *   Copyright (c) 2022 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 "InteractionModel.h"

using namespace chip;
using namespace chip::app;

namespace chip {
namespace test_utils {
void BusyWaitMillis(uint16_t busyWaitForMs)
{
    auto & clock = chip::System::SystemClock();
    auto start   = clock.GetMonotonicTimestamp();
    chip::System::Clock::Milliseconds32 durationInMs(busyWaitForMs);
    while (clock.GetMonotonicTimestamp() - start < durationInMs)
    {
        // nothing to do.
    };
}
} // namespace test_utils
} // namespace chip

CHIP_ERROR InteractionModel::ReadAttribute(const char * identity, EndpointId endpointId, ClusterId clusterId,
                                           AttributeId attributeId, bool fabricFiltered, const Optional<DataVersion> & dataVersion)
{
    DeviceProxy * device = GetDevice(identity);
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INCORRECT_STATE);

    std::vector<EndpointId> endpointIds   = { endpointId };
    std::vector<ClusterId> clusterIds     = { clusterId };
    std::vector<AttributeId> attributeIds = { attributeId };

    Optional<std::vector<DataVersion>> dataVersions = Optional<std::vector<DataVersion>>();
    if (dataVersion.HasValue())
    {
        dataVersions.Value().push_back(dataVersion.Value());
    }

    InteractionModelReports::ResetOptions();
    InteractionModelReports::SetFabricFiltered(fabricFiltered);
    InteractionModelReports::SetDataVersions(dataVersions);

    return InteractionModelReports::ReadAttribute(device, endpointIds, clusterIds, attributeIds);
}

CHIP_ERROR InteractionModel::ReadEvent(const char * identity, EndpointId endpointId, ClusterId clusterId, EventId eventId,
                                       bool fabricFiltered, const Optional<EventNumber> & eventNumber)
{
    DeviceProxy * device = GetDevice(identity);
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INCORRECT_STATE);

    std::vector<EndpointId> endpointIds = { endpointId };
    std::vector<ClusterId> clusterIds   = { clusterId };
    std::vector<EventId> eventIds       = { eventId };

    InteractionModelReports::ResetOptions();
    InteractionModelReports::SetFabricFiltered(fabricFiltered);
    InteractionModelReports::SetEventNumber(eventNumber);

    return InteractionModelReports::ReadEvent(device, endpointIds, clusterIds, eventIds);
}

CHIP_ERROR InteractionModel::SubscribeAttribute(const char * identity, EndpointId endpointId, ClusterId clusterId,
                                                AttributeId attributeId, uint16_t minInterval, uint16_t maxInterval,
                                                bool fabricFiltered, const Optional<DataVersion> & dataVersion,
                                                const Optional<bool> & keepSubscriptions, const Optional<bool> & autoResubscribe)
{
    DeviceProxy * device = GetDevice(identity);
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INCORRECT_STATE);

    std::vector<EndpointId> endpointIds   = { endpointId };
    std::vector<ClusterId> clusterIds     = { clusterId };
    std::vector<AttributeId> attributeIds = { attributeId };

    Optional<std::vector<DataVersion>> dataVersions = Optional<std::vector<DataVersion>>();
    if (dataVersion.HasValue())
    {
        dataVersions.Value().push_back(dataVersion.Value());
    }

    InteractionModelReports::ResetOptions();
    InteractionModelReports::SetMinInterval(minInterval);
    InteractionModelReports::SetMaxInterval(maxInterval);
    InteractionModelReports::SetFabricFiltered(fabricFiltered);
    InteractionModelReports::SetDataVersions(dataVersions);
    InteractionModelReports::SetKeepSubscriptions(keepSubscriptions);
    InteractionModelReports::SetAutoResubscribe(autoResubscribe);

    return InteractionModelReports::SubscribeAttribute(device, endpointIds, clusterIds, attributeIds);
}

CHIP_ERROR InteractionModel::SubscribeEvent(const char * identity, EndpointId endpointId, ClusterId clusterId, EventId eventId,
                                            uint16_t minInterval, uint16_t maxInterval, bool fabricFiltered,
                                            const Optional<EventNumber> & eventNumber, const Optional<bool> & keepSubscriptions,
                                            const Optional<bool> & autoResubscribe)
{
    DeviceProxy * device = GetDevice(identity);
    VerifyOrReturnError(device != nullptr, CHIP_ERROR_INCORRECT_STATE);

    std::vector<EndpointId> endpointIds = { endpointId };
    std::vector<ClusterId> clusterIds   = { clusterId };
    std::vector<EventId> eventIds       = { eventId };

    InteractionModelReports::ResetOptions();
    SetMinInterval(minInterval);
    SetMaxInterval(maxInterval);
    SetFabricFiltered(fabricFiltered);
    SetEventNumber(eventNumber);
    SetKeepSubscriptions(keepSubscriptions);
    SetAutoResubscribe(autoResubscribe);

    return InteractionModelReports::SubscribeEvent(device, endpointIds, clusterIds, eventIds);
}

void InteractionModel::Shutdown()
{
    InteractionModelReports::Shutdown();
    InteractionModelWriter::Shutdown();
    InteractionModelCommands::Shutdown();
}

/////////// ReadClient Callback Interface /////////
void InteractionModel::OnAttributeData(const ConcreteDataAttributePath & path, TLV::TLVReader * data, const StatusIB & status)
{
    OnResponse(status, data);
}

void InteractionModel::OnEventData(const EventHeader & eventHeader, TLV::TLVReader * data, const StatusIB * status)
{
    OnResponse(status == nullptr ? StatusIB() : *status, data);
}

void InteractionModel::OnError(CHIP_ERROR error)
{
    StatusIB status(error);
    OnResponse(status, nullptr);
}

void InteractionModel::OnDone(ReadClient * aReadClient)
{
    InteractionModelReports::CleanupReadClient(aReadClient);
    ContinueOnChipMainThread(CHIP_NO_ERROR);
}

void InteractionModel::OnDeallocatePaths(chip::app::ReadPrepareParams && aReadPrepareParams)
{
    InteractionModelReports::OnDeallocatePaths(std::move(aReadPrepareParams));
}

void InteractionModel::OnSubscriptionEstablished(SubscriptionId subscriptionId)
{
    ContinueOnChipMainThread(CHIP_NO_ERROR);
}

/////////// WriteClient Callback Interface /////////
void InteractionModel::OnResponse(const WriteClient * client, const ConcreteDataAttributePath & path, StatusIB status)
{
    OnResponse(status, nullptr);
}

void InteractionModel::OnError(const WriteClient * client, CHIP_ERROR error)
{
    StatusIB status(error);
    OnResponse(status, nullptr);
}

void InteractionModel::OnDone(WriteClient * client)
{
    mWriteClient.reset();
    ContinueOnChipMainThread(CHIP_NO_ERROR);
}

/////////// CommandSender Callback Interface /////////
void InteractionModel::OnResponse(CommandSender * client, const ConcreteCommandPath & path, const StatusIB & status,
                                  TLV::TLVReader * data)
{
    OnResponse(status, data);
}

void InteractionModel::OnError(const CommandSender * client, CHIP_ERROR error)
{
    StatusIB status(error);
    OnResponse(status, nullptr);
}

void InteractionModel::OnDone(CommandSender * client)
{
    if (mCommandSender.size())
    {
        mCommandSender.front().reset();
        mCommandSender.erase(mCommandSender.begin());
    }

    // If the command is repeated N times, wait for all the responses to comes in
    // before exiting.
    if (!mCommandSender.size())
    {
        ContinueOnChipMainThread(CHIP_NO_ERROR);
    }
}

CHIP_ERROR InteractionModelConfig::GetAttributePaths(std::vector<EndpointId> endpointIds, std::vector<ClusterId> clusterIds,
                                                     std::vector<AttributeId> attributeIds,
                                                     const Optional<std::vector<DataVersion>> & dataVersions,
                                                     AttributePathsConfig & pathsConfig)
{
    const size_t endpointCount     = endpointIds.size();
    const size_t clusterCount      = clusterIds.size();
    const size_t attributeCount    = attributeIds.size();
    const size_t dataVersionsCount = dataVersions.HasValue() ? dataVersions.Value().size() : 0;

    VerifyOrReturnError(clusterCount > 0 && clusterCount <= kMaxAllowedPaths, CHIP_ERROR_INVALID_ARGUMENT);
    VerifyOrReturnError(attributeCount > 0 && attributeCount <= kMaxAllowedPaths, CHIP_ERROR_INVALID_ARGUMENT);
    VerifyOrReturnError(endpointCount > 0 && endpointCount <= kMaxAllowedPaths, CHIP_ERROR_INVALID_ARGUMENT);
    VerifyOrReturnError(dataVersionsCount <= kMaxAllowedPaths, CHIP_ERROR_INVALID_ARGUMENT);

    const bool hasSameIdsCount = (clusterCount == attributeCount) && (clusterCount == endpointCount) &&
        (dataVersionsCount == 0 || clusterCount == dataVersionsCount);

    const bool multipleClusters =
        clusterCount > 1 && attributeCount == 1 && endpointCount == 1 && (dataVersionsCount == 0 || dataVersionsCount == 1);
    const bool multipleAttributes =
        attributeCount > 1 && clusterCount == 1 && endpointCount == 1 && (dataVersionsCount == 0 || dataVersionsCount == 1);
    const bool multipleEndpoints =
        endpointCount > 1 && clusterCount == 1 && attributeCount == 1 && (dataVersionsCount == 0 || dataVersionsCount == 1);
    const bool multipleDataVersions = dataVersionsCount > 1 && clusterCount == 1 && attributeCount == 1 && endpointCount == 1;

    size_t pathsCount = 0;
    if (hasSameIdsCount)
    {
        pathsCount = clusterCount;
    }
    else if (multipleClusters)
    {
        pathsCount = clusterCount;
    }
    else if (multipleAttributes)
    {
        pathsCount = attributeCount;
    }
    else if (multipleEndpoints)
    {
        pathsCount = endpointCount;
    }
    else if (multipleDataVersions)
    {
        pathsCount = dataVersionsCount;
    }
    else
    {
        ChipLogError(chipTool,
                     "\nCommand targetting multiple paths needs to have: \n \t * One element with multiple ids (for "
                     "example 1 cluster id, 1 attribute id, 2 endpoint ids)\n\t * Or the same "
                     "number of ids (for examples 2 cluster ids, 2 attribute ids and 2 endpoint ids).\n The current command has %u "
                     "cluster ids, %u attribute ids, %u endpoint ids.",
                     static_cast<unsigned int>(clusterCount), static_cast<unsigned int>(attributeCount),
                     static_cast<unsigned int>(endpointCount));
        return CHIP_ERROR_INVALID_ARGUMENT;
    }

    pathsConfig.count               = pathsCount;
    pathsConfig.attributePathParams = std::make_unique<AttributePathParams[]>(pathsCount);
    pathsConfig.dataVersionFilter   = std::make_unique<DataVersionFilter[]>(pathsCount);

    for (size_t i = 0; i < pathsCount; i++)
    {
        ClusterId clusterId     = clusterIds.at((hasSameIdsCount || multipleClusters) ? i : 0);
        AttributeId attributeId = attributeIds.at((hasSameIdsCount || multipleAttributes) ? i : 0);
        EndpointId endpointId   = endpointIds.at((hasSameIdsCount || multipleEndpoints) ? i : 0);

        ChipLogProgress(chipTool, "\tcluster " ChipLogFormatMEI ", attribute: " ChipLogFormatMEI ", endpoint %u",
                        ChipLogValueMEI(clusterId), ChipLogValueMEI(attributeId), endpointId);

        if (clusterId != kInvalidClusterId)
        {
            pathsConfig.attributePathParams[i].mClusterId = clusterId;
        }

        if (attributeId != kInvalidAttributeId)
        {
            pathsConfig.attributePathParams[i].mAttributeId = attributeId;
        }

        if (endpointId != kInvalidEndpointId)
        {
            pathsConfig.attributePathParams[i].mEndpointId = endpointId;
        }

        if (dataVersions.HasValue())
        {
            DataVersion dataVersion = dataVersions.Value().at((hasSameIdsCount || multipleDataVersions) ? i : 0);
            pathsConfig.dataVersionFilter[i].mEndpointId = endpointId;
            pathsConfig.dataVersionFilter[i].mClusterId  = clusterId;
            pathsConfig.dataVersionFilter[i].mDataVersion.SetValue(dataVersion);
        }
    }

    return CHIP_NO_ERROR;
}

CHIP_ERROR InteractionModelReports::ReportAttribute(DeviceProxy * device, std::vector<EndpointId> endpointIds,
                                                    std::vector<ClusterId> clusterIds, std::vector<AttributeId> attributeIds,
                                                    ReadClient::InteractionType interactionType)
{
    ChipLogProgress(chipTool,
                    "Sending %sAttribute to:", interactionType == ReadClient::InteractionType::Subscribe ? "Subscribe" : "Read");

    InteractionModelConfig::AttributePathsConfig pathsConfig;
    ReturnErrorOnFailure(
        InteractionModelConfig::GetAttributePaths(endpointIds, clusterIds, attributeIds, mDataVersions, pathsConfig));

    ReadPrepareParams params(device->GetSecureSession().Value());
    params.mpEventPathParamsList        = nullptr;
    params.mEventPathParamsListSize     = 0;
    params.mpAttributePathParamsList    = pathsConfig.attributePathParams.get();
    params.mAttributePathParamsListSize = pathsConfig.count;

    if (mFabricFiltered.HasValue())
    {
        params.mIsFabricFiltered = mFabricFiltered.Value();
    }

    if (mDataVersions.HasValue())
    {
        params.mpDataVersionFilterList    = pathsConfig.dataVersionFilter.get();
        params.mDataVersionFilterListSize = pathsConfig.count;
    }

    if (interactionType == ReadClient::InteractionType::Subscribe)
    {
        params.mMinIntervalFloorSeconds   = mMinInterval;
        params.mMaxIntervalCeilingSeconds = mMaxInterval;
        if (mKeepSubscriptions.HasValue())
        {
            params.mKeepSubscriptions = mKeepSubscriptions.Value();
        }
        params.mIsPeerLIT = mIsPeerLIT;
    }

    auto client = std::make_unique<ReadClient>(InteractionModelEngine::GetInstance(), device->GetExchangeManager(),
                                               mBufferedReadAdapter, interactionType);
    if (interactionType == ReadClient::InteractionType::Read)
    {
        ReturnErrorOnFailure(client->SendRequest(params));
    }
    else if (mAutoResubscribe.ValueOr(false))
    {
        pathsConfig.attributePathParams.release();
        if (mDataVersions.HasValue())
        {
            pathsConfig.dataVersionFilter.release();
        }
        ReturnErrorOnFailure(client->SendAutoResubscribeRequest(std::move(params)));
    }
    else
    {
        // We want to allow certain kinds of spec-invalid subscriptions so we
        // can test how the server reacts to them.
        ReturnErrorOnFailure(client->SendSubscribeRequestWithoutValidation(params));
    }
    mReadClients.push_back(std::move(client));
    return CHIP_NO_ERROR;
}

CHIP_ERROR InteractionModelReports::ReportEvent(DeviceProxy * device, std::vector<EndpointId> endpointIds,
                                                std::vector<ClusterId> clusterIds, std::vector<EventId> eventIds,
                                                chip::app::ReadClient::InteractionType interactionType)
{
    const size_t clusterCount  = clusterIds.size();
    const size_t eventCount    = eventIds.size();
    const size_t endpointCount = endpointIds.size();
    const size_t isUrgentCount = mIsUrgents.HasValue() ? mIsUrgents.Value().size() : 0;

    VerifyOrReturnError(clusterCount > 0 && clusterCount <= kMaxAllowedPaths, CHIP_ERROR_INVALID_ARGUMENT);
    VerifyOrReturnError(eventCount > 0 && eventCount <= kMaxAllowedPaths, CHIP_ERROR_INVALID_ARGUMENT);
    VerifyOrReturnError(endpointCount > 0 && endpointCount <= kMaxAllowedPaths, CHIP_ERROR_INVALID_ARGUMENT);
    VerifyOrReturnError(isUrgentCount <= kMaxAllowedPaths, CHIP_ERROR_INVALID_ARGUMENT);

    const bool hasSameIdsCount   = (clusterCount == eventCount) && (clusterCount == endpointCount);
    const bool multipleClusters  = clusterCount > 1 && eventCount == 1 && endpointCount == 1;
    const bool multipleEvents    = eventCount > 1 && clusterCount == 1 && endpointCount == 1;
    const bool multipleEndpoints = endpointCount > 1 && clusterCount == 1 && eventCount == 1;

    size_t pathsCount = 0;
    if (hasSameIdsCount)
    {
        pathsCount = clusterCount;
    }
    else if (multipleClusters)
    {
        pathsCount = clusterCount;
    }
    else if (multipleEvents)
    {
        pathsCount = eventCount;
    }
    else if (multipleEndpoints)
    {
        pathsCount = endpointCount;
    }
    else
    {
        ChipLogError(chipTool,
                     "\n%sEvent command targetting multiple paths needs to have: \n \t * One element with multiple ids (for "
                     "example 1 cluster id, 1 event id, 2 endpoint ids)\n\t * Or the same "
                     "number of ids (for examples 2 cluster ids, 2 event ids and 2 endpoint ids).\n The current command has %u "
                     "cluster ids, %u event ids, %u endpoint ids.",
                     interactionType == ReadClient::InteractionType::Subscribe ? "Subscribe" : "Read",
                     static_cast<unsigned int>(clusterCount), static_cast<unsigned int>(eventCount),
                     static_cast<unsigned int>(endpointCount));
        return CHIP_ERROR_INVALID_ARGUMENT;
    }

    auto eventPathParams = std::make_unique<EventPathParams[]>(pathsCount);

    ChipLogProgress(chipTool,
                    "Sending %sEvent to:", interactionType == ReadClient::InteractionType::Subscribe ? "Subscribe" : "Read");
    for (size_t i = 0; i < pathsCount; i++)
    {
        ClusterId clusterId   = clusterIds.at((hasSameIdsCount || multipleClusters) ? i : 0);
        EventId eventId       = eventIds.at((hasSameIdsCount || multipleEvents) ? i : 0);
        EndpointId endpointId = endpointIds.at((hasSameIdsCount || multipleEndpoints) ? i : 0);

        ChipLogProgress(chipTool, "\tcluster " ChipLogFormatMEI ", event: " ChipLogFormatMEI ", endpoint %u",
                        ChipLogValueMEI(clusterId), ChipLogValueMEI(eventId), endpointId);
        if (clusterId != kInvalidClusterId)
        {
            eventPathParams[i].mClusterId = clusterId;
        }

        if (eventId != kInvalidEventId)
        {
            eventPathParams[i].mEventId = eventId;
        }

        if (endpointId != kInvalidEndpointId)
        {
            eventPathParams[i].mEndpointId = endpointId;
        }

        if (mIsUrgents.HasValue() && mIsUrgents.Value().size() > i)
        {
            eventPathParams[i].mIsUrgentEvent = mIsUrgents.Value().at(i);
        }
    }

    ReadPrepareParams params(device->GetSecureSession().Value());
    params.mpEventPathParamsList        = eventPathParams.get();
    params.mEventPathParamsListSize     = pathsCount;
    params.mEventNumber                 = mEventNumber;
    params.mpAttributePathParamsList    = nullptr;
    params.mAttributePathParamsListSize = 0;

    if (mFabricFiltered.HasValue())
    {
        params.mIsFabricFiltered = mFabricFiltered.Value();
    }

    if (interactionType == ReadClient::InteractionType::Subscribe)
    {
        params.mMinIntervalFloorSeconds   = mMinInterval;
        params.mMaxIntervalCeilingSeconds = mMaxInterval;
        if (mKeepSubscriptions.HasValue())
        {
            params.mKeepSubscriptions = mKeepSubscriptions.Value();
        }
        params.mIsPeerLIT = mIsPeerLIT;
    }

    auto client = std::make_unique<ReadClient>(InteractionModelEngine::GetInstance(), device->GetExchangeManager(),
                                               mBufferedReadAdapter, interactionType);
    if (mAutoResubscribe.ValueOr(false))
    {
        eventPathParams.release();
        ReturnErrorOnFailure(client->SendAutoResubscribeRequest(std::move(params)));
    }
    else
    {
        ReturnErrorOnFailure(client->SendRequest(params));
    }
    mReadClients.push_back(std::move(client));
    return CHIP_NO_ERROR;
}

void InteractionModelReports::CleanupReadClient(ReadClient * aReadClient)
{
    mReadClients.erase(
        std::remove_if(mReadClients.begin(), mReadClients.end(), [aReadClient](auto & item) { return item.get() == aReadClient; }),
        mReadClients.end());
}

CHIP_ERROR InteractionModelReports::ReportNone(chip::DeviceProxy * device, chip::app::ReadClient::InteractionType interactionType)
{
    AttributePathParams attributePathParams[kMaxAllowedPaths];
    EventPathParams eventPathParams[kMaxAllowedPaths];

    ReadPrepareParams params(device->GetSecureSession().Value());
    params.mpEventPathParamsList        = eventPathParams;
    params.mEventPathParamsListSize     = 0;
    params.mEventNumber                 = mEventNumber;
    params.mpAttributePathParamsList    = attributePathParams;
    params.mAttributePathParamsListSize = 0;

    if (mFabricFiltered.HasValue())
    {
        params.mIsFabricFiltered = mFabricFiltered.Value();
    }

    if (interactionType == ReadClient::InteractionType::Subscribe)
    {
        params.mMinIntervalFloorSeconds   = mMinInterval;
        params.mMaxIntervalCeilingSeconds = mMaxInterval;
        if (mKeepSubscriptions.HasValue())
        {
            params.mKeepSubscriptions = mKeepSubscriptions.Value();
        }
    }

    auto client = std::make_unique<ReadClient>(InteractionModelEngine::GetInstance(), device->GetExchangeManager(),
                                               mBufferedReadAdapter, interactionType);
    ReturnErrorOnFailure(client->SendRequest(params));
    mReadClients.push_back(std::move(client));
    return CHIP_NO_ERROR;
}

CHIP_ERROR InteractionModelReports::ReportAll(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds,
                                              std::vector<chip::ClusterId> clusterIds, std::vector<chip::AttributeId> attributeIds,
                                              std::vector<chip::EventId> eventIds,
                                              chip::app::ReadClient::InteractionType interactionType)
{
    const size_t endpointCount  = endpointIds.size();
    const size_t clusterCount   = clusterIds.size();
    const size_t attributeCount = attributeIds.size();
    const size_t eventCount     = eventIds.size();

    // TODO Add data version supports
    // TODO Add isUrgents supports

    VerifyOrReturnError(endpointCount > 0 && endpointCount <= kMaxAllowedPaths, CHIP_ERROR_INVALID_ARGUMENT);
    VerifyOrReturnError(clusterCount > 0 && clusterCount <= kMaxAllowedPaths, CHIP_ERROR_INVALID_ARGUMENT);
    VerifyOrReturnError(attributeCount > 0 && attributeCount <= kMaxAllowedPaths, CHIP_ERROR_INVALID_ARGUMENT);
    VerifyOrReturnError(eventCount > 0 && eventCount <= kMaxAllowedPaths, CHIP_ERROR_INVALID_ARGUMENT);

    const bool hasSameIdsCount = (clusterCount == (attributeCount + eventCount)) && (clusterCount == endpointCount);
    if (!hasSameIdsCount)
    {
        ChipLogError(chipTool,
                     "\nCommand targetting a combination of attribute and event paths needs to have has many clusters and "
                     "endpoints than the number of attribute and events combined.\n"
                     "For example if there are 2 attributes and 1 event, the command expects 3 clusters and 3 endpoints.\n"
                     "Clusters and endpoints ids will be consumed first to populate the attribute paths of the request, and then "
                     "to populate the event paths of the request.\n\n"
                     "For example the following arguments:\n"
                     "\tcluster-ids: 6,6,0X28\n"
                     "\tendpoint-ids: 1,1,0\n"
                     "\tattribute-ids: 0,0x4001\n"
                     "\tevent-ids: 0\n"
                     "\n"
                     "will create the following paths:\n"
                     "\t{cluster: 6, endpoint: 1, attribute: 0}\n"
                     "\t{cluster: 6, endpoint: 1, attribute: 0x4001}\n"
                     "\t{cluster: 0x28, endpoint: 0, event: 0}\n");
        return CHIP_ERROR_INVALID_ARGUMENT;
    }

    AttributePathParams attributePathParams[kMaxAllowedPaths];
    EventPathParams eventPathParams[kMaxAllowedPaths];

    size_t attributeIndex = 0;
    size_t eventIndex     = 0;
    size_t pathsCount     = clusterCount;
    for (size_t i = 0; i < pathsCount; i++)
    {
        auto clusterId  = clusterIds.at(i);
        auto endpointId = endpointIds.at(i);

        if (attributeIndex < attributeIds.size())
        {
            auto attributeId = attributeIds.at(attributeIndex);

            if (endpointId != kInvalidEndpointId)
            {
                attributePathParams[attributeIndex].mEndpointId = endpointId;
            }

            if (clusterId != kInvalidClusterId)
            {
                attributePathParams[attributeIndex].mClusterId = clusterId;
            }

            if (attributeId != kInvalidAttributeId)
            {
                attributePathParams[attributeIndex].mAttributeId = attributeId;
            }

            attributeIndex++;
        }
        else if (eventIndex < eventIds.size())
        {
            auto eventId = eventIds.at(eventIndex);

            if (endpointId != kInvalidEndpointId)
            {
                eventPathParams[eventIndex].mEndpointId = endpointId;
            }

            if (clusterId != kInvalidClusterId)
            {
                eventPathParams[eventIndex].mClusterId = clusterId;
            }

            if (eventId != kInvalidEventId)
            {
                eventPathParams[eventIndex].mEventId = eventId;
            }

            eventIndex++;
        }
    }

    ReadPrepareParams params(device->GetSecureSession().Value());
    params.mpEventPathParamsList        = eventPathParams;
    params.mEventPathParamsListSize     = eventCount;
    params.mEventNumber                 = mEventNumber;
    params.mpAttributePathParamsList    = attributePathParams;
    params.mAttributePathParamsListSize = attributeCount;

    if (mFabricFiltered.HasValue())
    {
        params.mIsFabricFiltered = mFabricFiltered.Value();
    }

    if (interactionType == ReadClient::InteractionType::Subscribe)
    {
        params.mMinIntervalFloorSeconds   = mMinInterval;
        params.mMaxIntervalCeilingSeconds = mMaxInterval;
        if (mKeepSubscriptions.HasValue())
        {
            params.mKeepSubscriptions = mKeepSubscriptions.Value();
        }
        params.mIsPeerLIT = mIsPeerLIT;
    }

    auto client = std::make_unique<ReadClient>(InteractionModelEngine::GetInstance(), device->GetExchangeManager(),
                                               mBufferedReadAdapter, interactionType);
    ReturnErrorOnFailure(client->SendRequest(params));
    mReadClients.push_back(std::move(client));
    return CHIP_NO_ERROR;
}

void InteractionModelReports::OnDeallocatePaths(chip::app::ReadPrepareParams && aReadPrepareParams)
{
    if (aReadPrepareParams.mpAttributePathParamsList != nullptr)
    {
        delete[] aReadPrepareParams.mpAttributePathParamsList;
    }

    if (aReadPrepareParams.mpDataVersionFilterList != nullptr)
    {
        delete[] aReadPrepareParams.mpDataVersionFilterList;
    }

    if (aReadPrepareParams.mpEventPathParamsList != nullptr)
    {
        delete[] aReadPrepareParams.mpEventPathParamsList;
    }
}