#include <adtffiltersdk/adtf_filtersdk.h>
#include <adtfsystemsdk/services/kernel_intf.h>
#include <adtfsystemsdk/testing/test_system.h>
#include <adtftesting/adtf_testing.h>
#include <iomanip>

namespace helpers
{
    tResult AddExistingObjectToFilterGraph(adtf::ucom::iobject_ptr<adtf::streaming::cFilterGraph>& graph, char const* name, adtf::ucom::iobject_ptr<adtf::streaming::INamedGraphObject>& object, int init_order)
    {
        RETURN_IF_FAILED(object->SetName(name));
        return graph->AddNamedGraphObject(object, init_order);
    }

    tResult AddNewObjectToFilterGraph(adtf::ucom::iobject_ptr<adtf::streaming::cFilterGraph>& graph, char const* name, char const* cid, int init_order)
    {
        adtf::ucom::object_ptr<adtf::streaming::INamedGraphObject> object;
        RETURN_IF_FAILED(_runtime->CreateInstance(cid, object));
        return AddExistingObjectToFilterGraph(graph, name, object, init_order);
    }

    std::string ToTimeString(tTimeStamp const tm)
    {
        const int64_t ms_total = tm / 1000;
        const int64_t ms = ms_total % 1000;
        const int64_t s_total = ms_total / 1000;
        const int64_t s = s_total % 60;
        const int64_t m_total = s_total / 60;
        const int64_t m = m_total % 60;
        const int64_t h_total = m_total / 60;
        const int64_t h = h_total % 24;
        std::stringstream msg;
        msg << "[" << std::setw(2) << std::setfill('0') << h;
        msg << ":" << std::setw(2) << std::setfill('0') << m;
        msg << ":" << std::setw(2) << std::setfill('0') << s;
        msg << "." << std::setw(3) << std::setfill('0') << ms;
        msg << "]";
        return msg.str();
    }
}

class SenderFilter : public adtf::filter::cFilter
{
public:
    ADTF_CLASS_ID_NAME(SenderFilter,
        "senderfilter.test.cid",
        "SenderFilter");

    SenderFilter()
    {
        adtf::ucom::object_ptr<adtf::streaming::IStreamType> pType = adtf::ucom::make_object_ptr<adtf::streaming::stream_type_plain<tInt16>>();
        writer = CreateOutputPin("output", pType);
    }

    tResult Init(cFilterLevelmachine::tInitStage eStage) override
    {
        RETURN_IF_FAILED(adtf::filter::cFilter::Init(eStage));

        switch (eStage)
        {
        case cFilterLevelmachine::tInitStage::StageNormal:
        {
            adtf::ucom::object_ptr<adtf::streaming::IStreamType> pType = adtf::ucom::make_object_ptr<adtf::streaming::stream_type_plain<tInt32>>();
            writer->SetType(pType);
            break;
        }
        default:
            break;
        }
        return ERR_NOERROR;
    }

    template<typename T>
    tResult SendSample(tTimeStamp tmSample, T value)
    {
        adtf::ucom::object_ptr<adtf::streaming::IStreamType> pType = adtf::ucom::make_object_ptr<adtf::streaming::stream_type_plain<tInt64>>();
        RETURN_IF_FAILED(writer->SetType(pType));
        adtf::streaming::output_sample_data<T> oOutputData(tmSample);
        oOutputData = value;
        std::stringstream msg;
        msg << helpers::ToTimeString(tmSample) << " " << __FUNCTION__ << "(" << value << ")";
        LOG_INFO(msg.str().c_str());
        RETURN_IF_FAILED(writer->Write(oOutputData.Release()));
        return writer->ManualTrigger();
    }

private:
    adtf::streaming::ISampleWriter* writer = nullptr;
};

class ReceiverFilter : public adtf::filter::cFilter
{
public:
    ADTF_CLASS_ID_NAME(ReceiverFilter,
        "receiverfilter.test.cid",
        "ReceiverFilter");

    ReceiverFilter()
    {
        reader = CreateInputPin("input");
    }

    tResult AcceptType(adtf::streaming::ISampleReader* pReader,
        const adtf::ucom::ant::iobject_ptr<const adtf::streaming::IStreamType>& pType) override
    {
        ++acceptTypeCallCount;
        return ERR_NOERROR;
    }

    tResult ProcessInput(adtf::base::flash::tNanoSeconds tmTrigger,
        adtf::streaming::flash::ISampleReader* pReader) override
    {
        ++receivedSampleCount;
        return ERR_NOERROR;
    }

private:
    adtf::streaming::ISampleReader* reader = nullptr;

public:
    int acceptTypeCallCount = 0;
    int receivedSampleCount = 0;
};

struct MyTestSystem: adtf::system::testing::cTestSystem
{
    MyTestSystem()
    {
        LoadPlugin("default_core_objects.adtfplugin");
        LoadPlugin("adtf_kernel.adtfplugin");
        CreateService(CID_ADTF_KERNEL,
            "kernel",
            adtf::base::tADTFRunLevel::RL_System);
        LoadPlugin("adtf_clock.adtfplugin");
        CreateService(CID_ADTF_REFERENCE_CLOCK,
            "reference_clock",
            adtf::base::tADTFRunLevel::RL_System);
        _runtime->SetRunLevel(adtf::base::tADTFRunLevel::RL_Session);
    }

    ~MyTestSystem()
    {
        _runtime->SetRunLevel(adtf::base::tADTFRunLevel::RL_Shutdown);
    }
};

TEST_CASE_METHOD(MyTestSystem, "Connect")
{
    adtf::ucom::object_ptr<SenderFilter> sender = adtf::ucom::make_object_ptr<SenderFilter>();
    adtf::ucom::object_ptr<ReceiverFilter> receiver = adtf::ucom::make_object_ptr<ReceiverFilter>();

    adtf::ucom::object_ptr<adtf::streaming::cFilterGraph> graph(adtf::ucom::make_object_ptr<adtf::streaming::cFilterGraph>());
    REQUIRE_OK(helpers::AddExistingObjectToFilterGraph(graph, "Sender", adtf::ucom::ucom_object_ptr_cast<adtf::streaming::INamedGraphObject>(sender), 0));
    REQUIRE_OK(helpers::AddExistingObjectToFilterGraph(graph, "Receiver", adtf::ucom::ucom_object_ptr_cast<adtf::streaming::INamedGraphObject>(receiver), 1));
    REQUIRE_OK(helpers::AddNewObjectToFilterGraph(graph, "Stream", "default_sample_stream.streaming.adtf.cid", 2));
    REQUIRE_OK(graph->AddConnection("SendToStream", "Sender", "output", "Stream", "", 0, true));
    REQUIRE_OK(graph->AddConnection("SendToReceiver", "Stream", "", "Receiver", "input", 0, true));
    REQUIRE_OK(graph->SetState(adtf::streaming::IFilterGraph::tFilterGraphState::State_Constructed));
    REQUIRE_OK(graph->SetState(adtf::streaming::IFilterGraph::tFilterGraphState::State_Initialized));
    REQUIRE_OK(graph->SetState(adtf::streaming::IFilterGraph::tFilterGraphState::State_Ready));
    REQUIRE_OK(_runtime->SetRunLevel(adtf::base::tADTFRunLevel::RL_FilterGraph));

    REQUIRE_OK(graph->SetState(adtf::streaming::IFilterGraph::tFilterGraphState::State_Running));
    REQUIRE_OK(_runtime->SetRunLevel(adtf::base::tADTFRunLevel::RL_Running));

    REQUIRE(0 == receiver->receivedSampleCount);

    sender->SendSample(0, int64_t(42));

    REQUIRE(0 == receiver->acceptTypeCallCount);
    REQUIRE(1 == receiver->receivedSampleCount);
}