/*
 *   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.
 *
 */

#pragma once

#include <app/BufferedReadCallback.h>
#include <app/ChunkedWriteCallback.h>
#include <app/CommandSender.h>
#include <app/DeviceProxy.h>
#include <app/InteractionModelEngine.h>
#include <app/ReadClient.h>
#include <app/WriteClient.h>
#include <lib/support/CodeUtils.h>
#include <lib/support/UnitTestUtils.h>

constexpr uint8_t kMaxAllowedPaths = 10;

class InteractionModelConfig
{
public:
    struct AttributePathsConfig
    {
        size_t count = 0;
        std::unique_ptr<chip::app::AttributePathParams[]> attributePathParams;
        std::unique_ptr<chip::app::DataVersionFilter[]> dataVersionFilter;
    };

    static CHIP_ERROR GetAttributePaths(std::vector<chip::EndpointId> endpointIds, std::vector<chip::ClusterId> clusterIds,
                                        std::vector<chip::AttributeId> attributeIds,
                                        const chip::Optional<std::vector<chip::DataVersion>> & dataVersions,
                                        AttributePathsConfig & pathsConfig);
};

class InteractionModelReports
{
public:
    InteractionModelReports(chip::app::ReadClient::Callback * callback) : mBufferedReadAdapter(*callback) {}

protected:
    CHIP_ERROR ReadAttribute(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds,
                             std::vector<chip::ClusterId> clusterIds, std::vector<chip::AttributeId> attributeIds,
                             const chip::Optional<bool> & fabricFiltered                         = chip::Optional<bool>(true),
                             const chip::Optional<std::vector<chip::DataVersion>> & dataVersions = chip::NullOptional)
    {
        return ReportAttribute(device, endpointIds, clusterIds, attributeIds, chip::app::ReadClient::InteractionType::Read, 0, 0,
                               fabricFiltered, dataVersions, chip::NullOptional, chip::NullOptional);
    }

    CHIP_ERROR SubscribeAttribute(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds,
                                  std::vector<chip::ClusterId> clusterIds, std::vector<chip::AttributeId> attributeIds,
                                  uint16_t minInterval, uint16_t maxInterval, const chip::Optional<bool> & fabricFiltered,
                                  const chip::Optional<std::vector<chip::DataVersion>> & dataVersions,
                                  const chip::Optional<bool> & keepSubscriptions, const chip::Optional<bool> & autoResubscribe)
    {
        return ReportAttribute(device, endpointIds, clusterIds, attributeIds, chip::app::ReadClient::InteractionType::Subscribe,
                               minInterval, maxInterval, fabricFiltered, dataVersions, keepSubscriptions, autoResubscribe);
    }

    CHIP_ERROR ReportAttribute(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds,
                               std::vector<chip::ClusterId> clusterIds, std::vector<chip::AttributeId> attributeIds,
                               chip::app::ReadClient::InteractionType interactionType, uint16_t minInterval, uint16_t maxInterval,
                               const chip::Optional<bool> & fabricFiltered,
                               const chip::Optional<std::vector<chip::DataVersion>> & dataVersions,
                               const chip::Optional<bool> & keepSubscriptions, const chip::Optional<bool> & autoResubscribe);

    CHIP_ERROR ReadEvent(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds,
                         std::vector<chip::ClusterId> clusterIds, std::vector<chip::EventId> eventIds,
                         const chip::Optional<bool> & fabricFiltered           = chip::Optional<bool>(true),
                         const chip::Optional<chip::EventNumber> & eventNumber = chip::NullOptional)
    {
        return ReportEvent(device, endpointIds, clusterIds, eventIds, chip::app::ReadClient::InteractionType::Read, 0, 0,
                           fabricFiltered, eventNumber, chip::NullOptional, chip::NullOptional, chip::NullOptional);
    }

    CHIP_ERROR SubscribeEvent(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds,
                              std::vector<chip::ClusterId> clusterIds, std::vector<chip::EventId> eventIds, uint16_t minInterval,
                              uint16_t maxInterval, const chip::Optional<bool> & fabricFiltered,
                              const chip::Optional<chip::EventNumber> & eventNumber, const chip::Optional<bool> & keepSubscriptions,
                              const chip::Optional<std::vector<bool>> & isUrgents, const chip::Optional<bool> & autoResubscribe)
    {
        return ReportEvent(device, endpointIds, clusterIds, eventIds, chip::app::ReadClient::InteractionType::Subscribe,
                           minInterval, maxInterval, fabricFiltered, eventNumber, keepSubscriptions, isUrgents, autoResubscribe);
    }

    CHIP_ERROR ReportEvent(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds,
                           std::vector<chip::ClusterId> clusterIds, std::vector<chip::EventId> eventIds,
                           chip::app::ReadClient::InteractionType interactionType, uint16_t minInterval, uint16_t maxInterval,
                           const chip::Optional<bool> & fabricFiltered, const chip::Optional<chip::EventNumber> & eventNumber,
                           const chip::Optional<bool> & keepSubscriptions, const chip::Optional<std::vector<bool>> & isUrgents,
                           const chip::Optional<bool> & autoResubscribe);

    CHIP_ERROR ReadAll(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds,
                       std::vector<chip::ClusterId> clusterIds, std::vector<chip::AttributeId> attributeIds,
                       std::vector<chip::EventId> eventIds,
                       const chip::Optional<bool> & fabricFiltered                         = chip::Optional<bool>(true),
                       const chip::Optional<std::vector<chip::DataVersion>> & dataVersions = chip::NullOptional,
                       const chip::Optional<chip::EventNumber> & eventNumber               = chip::NullOptional)
    {
        return ReportAll(device, endpointIds, clusterIds, attributeIds, eventIds, chip::app::ReadClient::InteractionType::Read, 0,
                         0, fabricFiltered, dataVersions, eventNumber);
    }

    CHIP_ERROR SubscribeAll(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds,
                            std::vector<chip::ClusterId> clusterIds, std::vector<chip::AttributeId> attributeIds,
                            std::vector<chip::EventId> eventIds, uint16_t minInterval = 0, uint16_t maxInterval = 0,
                            const chip::Optional<bool> & fabricFiltered           = chip::Optional<bool>(true),
                            const chip::Optional<chip::EventNumber> & eventNumber = chip::NullOptional,
                            const chip::Optional<bool> & keepSubscriptions        = chip::NullOptional)
    {
        return ReportAll(device, endpointIds, clusterIds, attributeIds, eventIds, chip::app::ReadClient::InteractionType::Subscribe,
                         minInterval, maxInterval, fabricFiltered, chip::NullOptional, eventNumber, keepSubscriptions);
    }

    CHIP_ERROR 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,
                         uint16_t minInterval = 0, uint16_t maxInterval = 0,
                         const chip::Optional<bool> & fabricFiltered                         = chip::Optional<bool>(true),
                         const chip::Optional<std::vector<chip::DataVersion>> & dataVersions = chip::NullOptional,
                         const chip::Optional<chip::EventNumber> & eventNumber               = chip::NullOptional,
                         const chip::Optional<bool> & keepSubscriptions                      = chip::NullOptional);

    void OnDeallocatePaths(chip::app::ReadPrepareParams && aReadPrepareParams);

    void Shutdown() { mReadClients.clear(); }

    void CleanupReadClient(chip::app::ReadClient * aReadClient);

    std::vector<std::unique_ptr<chip::app::ReadClient>> mReadClients;
    chip::app::BufferedReadCallback mBufferedReadAdapter;
};

class InteractionModelCommands
{
public:
    InteractionModelCommands(chip::app::CommandSender::Callback * callback) : mCallback(callback) {}

protected:
    template <class T>
    CHIP_ERROR SendCommand(chip::DeviceProxy * device, chip::EndpointId endpointId, chip::ClusterId clusterId,
                           chip::CommandId commandId, const T & value,
                           const chip::Optional<uint16_t> & timedInteractionTimeoutMs = chip::NullOptional,
                           const chip::Optional<bool> & suppressResponse              = chip::NullOptional,
                           const chip::Optional<uint16_t> & repeatCount               = chip::NullOptional,
                           const chip::Optional<uint16_t> & repeatDelayInMs           = chip::NullOptional)
    {
        uint16_t repeat = repeatCount.ValueOr(1);
        while (repeat--)
        {

            chip::app::CommandPathParams commandPath = { endpointId, clusterId, commandId,
                                                         (chip::app::CommandPathFlags::kEndpointIdValid) };
            auto commandSender = std::make_unique<chip::app::CommandSender>(mCallback, device->GetExchangeManager(),
                                                                            timedInteractionTimeoutMs.HasValue());
            VerifyOrReturnError(commandSender != nullptr, CHIP_ERROR_NO_MEMORY);

            ReturnErrorOnFailure(commandSender->AddRequestDataNoTimedCheck(commandPath, value, timedInteractionTimeoutMs,
                                                                           suppressResponse.ValueOr(false)));
            ReturnErrorOnFailure(commandSender->SendCommandRequest(device->GetSecureSession().Value()));
            mCommandSender.push_back(std::move(commandSender));

            if (repeatDelayInMs.HasValue())
            {
                chip::test_utils::SleepMillis(repeatDelayInMs.Value());
            }
        }
        return CHIP_NO_ERROR;
    }

    template <class T>
    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex, chip::ClusterId clusterId,
                                chip::CommandId commandId, const T & value)
    {
        chip::app::CommandPathParams commandPath = { groupId, clusterId, commandId, (chip::app::CommandPathFlags::kGroupIdValid) };

        chip::Messaging::ExchangeManager * exchangeManager = chip::app::InteractionModelEngine::GetInstance()->GetExchangeManager();
        VerifyOrReturnError(exchangeManager != nullptr, CHIP_ERROR_INCORRECT_STATE);

        chip::app::CommandSender commandSender(mCallback, exchangeManager);
        ReturnErrorOnFailure(commandSender.AddRequestDataNoTimedCheck(commandPath, value, chip::NullOptional));

        chip::Transport::OutgoingGroupSession session(groupId, fabricIndex);
        return commandSender.SendGroupCommandRequest(chip::SessionHandle(session));
    }

    void Shutdown()
    {
        for (auto & commandSender : mCommandSender)
        {
            commandSender.reset();
        }
        mCommandSender.clear();
    }

    std::vector<std::unique_ptr<chip::app::CommandSender>> mCommandSender;
    chip::app::CommandSender::Callback * mCallback;
};

class InteractionModelWriter
{
public:
    InteractionModelWriter(chip::app::WriteClient::Callback * callback) : mChunkedWriteCallback(callback) {}

protected:
    template <class T>
    CHIP_ERROR WriteAttribute(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds,
                              std::vector<chip::ClusterId> clusterIds, std::vector<chip::AttributeId> attributeIds,
                              const std::vector<T> & values,
                              const chip::Optional<uint16_t> & timedInteractionTimeoutMs          = chip::NullOptional,
                              const chip::Optional<bool> & suppressResponse                       = chip::NullOptional,
                              const chip::Optional<std::vector<chip::DataVersion>> & dataVersions = chip::NullOptional,
                              const chip::Optional<uint16_t> & repeatCount                        = chip::NullOptional,
                              const chip::Optional<uint16_t> & repeatDelayInMs                    = chip::NullOptional)
    {
        InteractionModelConfig::AttributePathsConfig pathsConfig;
        ReturnErrorOnFailure(
            InteractionModelConfig::GetAttributePaths(endpointIds, clusterIds, attributeIds, dataVersions, pathsConfig));

        VerifyOrReturnError(pathsConfig.count == values.size() || values.size() == 1, CHIP_ERROR_INVALID_ARGUMENT);

        uint16_t repeat = repeatCount.ValueOr(1);
        while (repeat--)
        {

            mWriteClient = std::make_unique<chip::app::WriteClient>(device->GetExchangeManager(), &mChunkedWriteCallback,
                                                                    timedInteractionTimeoutMs, suppressResponse.ValueOr(false));
            VerifyOrReturnError(mWriteClient != nullptr, CHIP_ERROR_NO_MEMORY);

            for (uint8_t i = 0; i < pathsConfig.count; i++)
            {
                auto & path        = pathsConfig.attributePathParams[i];
                auto & dataVersion = pathsConfig.dataVersionFilter[i].mDataVersion;
                const T & value    = i >= values.size() ? values.at(0) : values.at(i);
                ReturnErrorOnFailure(EncodeAttribute<T>(path, dataVersion, value));
            }

            ReturnErrorOnFailure(mWriteClient->SendWriteRequest(device->GetSecureSession().Value()));

            if (repeatDelayInMs.HasValue())
            {
                chip::test_utils::SleepMillis(repeatDelayInMs.Value());
            }
        }

        return CHIP_NO_ERROR;
    }

    template <class T>
    CHIP_ERROR WriteAttribute(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds,
                              std::vector<chip::ClusterId> clusterIds, std::vector<chip::AttributeId> attributeIds, const T & value,
                              const chip::Optional<uint16_t> & timedInteractionTimeoutMs          = chip::NullOptional,
                              const chip::Optional<bool> & suppressResponse                       = chip::NullOptional,
                              const chip::Optional<std::vector<chip::DataVersion>> & dataVersions = chip::NullOptional,
                              const chip::Optional<uint16_t> & repeatCount                        = chip::NullOptional,
                              const chip::Optional<uint16_t> & repeatDelayInMs                    = chip::NullOptional)
    {
        std::vector<T> values = { value };
        return WriteAttribute(device, endpointIds, clusterIds, attributeIds, values, timedInteractionTimeoutMs, suppressResponse,
                              dataVersions, repeatCount, repeatDelayInMs);
    }

    template <class T>
    CHIP_ERROR WriteGroupAttribute(chip::GroupId groupId, chip::FabricIndex fabricIndex, chip::ClusterId clusterId,
                                   chip::AttributeId attributeId, const std::vector<T> & value,
                                   const chip::Optional<chip::DataVersion> & dataVersion = chip::NullOptional)
    {
        return CHIP_ERROR_NOT_IMPLEMENTED;
    }

    template <class T>
    CHIP_ERROR WriteGroupAttribute(chip::GroupId groupId, chip::FabricIndex fabricIndex, chip::ClusterId clusterId,
                                   chip::AttributeId attributeId, const T & value,
                                   const chip::Optional<chip::DataVersion> & dataVersion = chip::NullOptional)
    {
        chip::app::AttributePathParams attributePathParams;

        if (clusterId != chip::kInvalidClusterId)
        {
            attributePathParams.mClusterId = clusterId;
        }

        if (attributeId != chip::kInvalidAttributeId)
        {
            attributePathParams.mAttributeId = attributeId;
        }

        chip::Messaging::ExchangeManager * exchangeManager = chip::app::InteractionModelEngine::GetInstance()->GetExchangeManager();
        VerifyOrReturnError(exchangeManager != nullptr, CHIP_ERROR_INCORRECT_STATE);

        chip::app::WriteClient writeClient(exchangeManager, &mChunkedWriteCallback, chip::NullOptional);
        ReturnErrorOnFailure(writeClient.EncodeAttribute(attributePathParams, value, dataVersion));

        chip::Transport::OutgoingGroupSession session(groupId, fabricIndex);
        return writeClient.SendWriteRequest(chip::SessionHandle(session));
    }

    void Shutdown() { mWriteClient.reset(); }

    std::unique_ptr<chip::app::WriteClient> mWriteClient;
    chip::app::ChunkedWriteCallback mChunkedWriteCallback;

private:
    template <typename T>
    CHIP_ERROR EncodeAttribute(const chip::app::AttributePathParams & path, const chip::Optional<chip::DataVersion> & dataVersion,
                               T value, typename std::enable_if<!std::is_pointer<T>::value>::type * = 0)
    {
        return mWriteClient->EncodeAttribute(path, value, dataVersion);
    }

    template <typename T>
    CHIP_ERROR EncodeAttribute(const chip::app::AttributePathParams & path, const chip::Optional<chip::DataVersion> & dataVersion,
                               T value, typename std::enable_if<std::is_pointer<T>::value>::type * = 0)
    {
        return mWriteClient->EncodeAttribute(path, *value, dataVersion);
    }
};

class InteractionModel : public InteractionModelReports,
                         public InteractionModelCommands,
                         public InteractionModelWriter,
                         public chip::app::ReadClient::Callback,
                         public chip::app::WriteClient::Callback,
                         public chip::app::CommandSender::Callback
{
public:
    InteractionModel() : InteractionModelReports(this), InteractionModelCommands(this), InteractionModelWriter(this){};
    virtual ~InteractionModel(){};

    virtual void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) = 0;
    virtual CHIP_ERROR ContinueOnChipMainThread(CHIP_ERROR err)                              = 0;
    virtual chip::DeviceProxy * GetDevice(const char * identity)                             = 0;

    CHIP_ERROR ReadAttribute(const char * identity, chip::EndpointId endpointId, chip::ClusterId clusterId,
                             chip::AttributeId attributeId, bool fabricFiltered = true,
                             const chip::Optional<chip::DataVersion> & dataVersion = chip::NullOptional);

    CHIP_ERROR SubscribeAttribute(const char * identity, chip::EndpointId endpointId, chip::ClusterId clusterId,
                                  chip::AttributeId attributeId, uint16_t minInterval, uint16_t maxInterval, bool fabricFiltered,
                                  const chip::Optional<chip::DataVersion> & dataVersion,
                                  const chip::Optional<bool> & keepSubscriptions, const chip::Optional<bool> & autoResubscribe);

    CHIP_ERROR ReadEvent(const char * identity, chip::EndpointId endpointId, chip::ClusterId clusterId, chip::EventId eventId,
                         bool fabricFiltered = true, const chip::Optional<chip::EventNumber> & eventNumber = chip::NullOptional);

    CHIP_ERROR SubscribeEvent(const char * identity, chip::EndpointId endpointId, chip::ClusterId clusterId, chip::EventId eventId,
                              uint16_t minInterval, uint16_t maxInterval, bool fabricFiltered,
                              const chip::Optional<chip::EventNumber> & eventNumber, const chip::Optional<bool> & keepSubscriptions,
                              const chip::Optional<bool> & autoResubscribe);

    CHIP_ERROR WaitForReport() { return CHIP_NO_ERROR; }

    template <class T>
    CHIP_ERROR WriteAttribute(const char * identity, chip::EndpointId endpointId, chip::ClusterId clusterId,
                              chip::AttributeId attributeId, const T & value,
                              const chip::Optional<uint16_t> & timedInteractionTimeoutMs = chip::NullOptional,
                              const chip::Optional<bool> & suppressResponse              = chip::NullOptional,
                              const chip::Optional<chip::DataVersion> & dataVersion      = chip::NullOptional)
    {
        chip::DeviceProxy * device = GetDevice(identity);
        VerifyOrReturnError(device != nullptr, CHIP_ERROR_INCORRECT_STATE);

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

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

        return InteractionModelWriter::WriteAttribute(device, endpointIds, clusterIds, attributeIds, value,
                                                      timedInteractionTimeoutMs, suppressResponse, optionalDataVersions);
    }

    template <class T>
    CHIP_ERROR WriteGroupAttribute(const char * identity, chip::GroupId groupId, chip::ClusterId clusterId,
                                   chip::AttributeId attributeId, const T & value,
                                   const chip::Optional<chip::DataVersion> & dataVersion = chip::NullOptional)
    {
        chip::DeviceProxy * device = GetDevice(identity);
        VerifyOrReturnError(device != nullptr, CHIP_ERROR_INCORRECT_STATE);

        chip::FabricIndex fabricIndex = device->GetSecureSession().Value()->GetFabricIndex();
        return InteractionModelWriter::WriteGroupAttribute(groupId, fabricIndex, clusterId, attributeId, value, dataVersion);
    }

    template <class T>
    CHIP_ERROR SendCommand(const char * identity, chip::EndpointId endpointId, chip::ClusterId clusterId, chip::CommandId commandId,
                           const T & value, chip::Optional<uint16_t> timedInteractionTimeoutMs = chip::NullOptional,
                           const chip::Optional<bool> & suppressResponse = chip::NullOptional)
    {
        chip::DeviceProxy * device = GetDevice(identity);
        VerifyOrReturnError(device != nullptr, CHIP_ERROR_INCORRECT_STATE);

        return InteractionModelCommands::SendCommand(device, endpointId, clusterId, commandId, value, timedInteractionTimeoutMs,
                                                     suppressResponse);
    }

    template <class T>
    CHIP_ERROR SendGroupCommand(const char * identity, chip::GroupId groupId, chip::ClusterId clusterId, chip::CommandId commandId,
                                const T & value)
    {
        chip::DeviceProxy * device = GetDevice(identity);
        VerifyOrReturnError(device != nullptr, CHIP_ERROR_INCORRECT_STATE);

        chip::FabricIndex fabricIndex = device->GetSecureSession().Value()->GetFabricIndex();
        return InteractionModelCommands::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, value);
    }

    void Shutdown();

    /////////// ReadClient Callback Interface /////////
    void OnAttributeData(const chip::app::ConcreteDataAttributePath & path, chip::TLV::TLVReader * data,
                         const chip::app::StatusIB & status) override;
    void OnEventData(const chip::app::EventHeader & eventHeader, chip::TLV::TLVReader * data,
                     const chip::app::StatusIB * status) override;
    void OnError(CHIP_ERROR error) override;
    void OnDone(chip::app::ReadClient * aReadClient) override;
    void OnSubscriptionEstablished(chip::SubscriptionId subscriptionId) override;
    void OnDeallocatePaths(chip::app::ReadPrepareParams && aReadPrepareParams) override;
    /////////// WriteClient Callback Interface /////////
    void OnResponse(const chip::app::WriteClient * client, const chip::app::ConcreteDataAttributePath & path,
                    chip::app::StatusIB status) override;
    void OnError(const chip::app::WriteClient * client, CHIP_ERROR error) override;
    void OnDone(chip::app::WriteClient * client) override;

    /////////// CommandSender Callback Interface /////////
    void OnResponse(chip::app::CommandSender * client, const chip::app::ConcreteCommandPath & path,
                    const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override;
    void OnError(const chip::app::CommandSender * client, CHIP_ERROR error) override;
    void OnDone(chip::app::CommandSender * client) override;
};