#pragma once

#include <tuple>
#include <utility>
#include <memory>
#include "IComplexCommandCreator.h"
#include "ComplexCommandCreateMultidata.h"
#include "TypesIndexSeparator.h"
#include "VariadicTypesContainerSwapper.h"

namespace Incart::Usb
{

template<typename TCommand, size_t DynamicDataSize, typename... TData>
class ComplexMultidataCommandCreator final : public IComplexCommandCreator
{
private:
    using DataParts = Common::TwoPartsTypesSeparator<DynamicDataSize, std::tuple, TData...>;
    using DynamicTypesTuple = typename DataParts::firstPartType;
    using ConstTypesTuple = typename DataParts::secondPartType;
    using CommandDataType = typename Common::VariadicTypesContainerSwapper<DynamicTypesTuple, ComplexCommandCreateMultidata<>>::destType;

    ConstTypesTuple m_constantData;

public:
    template<typename... TConstantData>
    ComplexMultidataCommandCreator(TConstantData... args_) : m_constantData(std::forward<TConstantData>(args_)...)
    {
    }

    std::shared_ptr<ComplexCommand> create(std::shared_ptr<IComplexCommandCreateData> data_) override
    {
        std::shared_ptr<CommandDataType> commandData = std::dynamic_pointer_cast<CommandDataType>(data_);
        auto dynamicData = commandData->data;
        auto constantData = m_constantData;
        std::tuple<TData...> catTuple = std::tuple_cat(dynamicData, std::move(constantData));
        return createCommand(catTuple, std::index_sequence_for<TData...>{});
    }

private:
    template<size_t... Indices>
    std::shared_ptr<ComplexCommand> createCommand(std::tuple<TData...> data_, std::index_sequence<Indices...>)
    {
        return std::make_shared<TCommand>(std::get<Indices>(data_)...);
    }
};

} // namespace Incart::Usb