#ifdef USE_GSTREAMER

#include "FrameSource/GStreamer/GStreamerCameraFrameSourceImpl.hpp"

#include <gst/app/gstappsink.h>

#include <sstream>

namespace nvidiaio
{

GStreamerCameraFrameSourceImpl::GStreamerCameraFrameSourceImpl(uint cameraIdx_) :
    GStreamerBaseFrameSourceImpl(nvxio::FrameSource::CAMERA_SOURCE, "GstreamerCameraFrameSource"),
    cameraIdx(cameraIdx_)
{
}

bool GStreamerCameraFrameSourceImpl::setConfiguration(const Parameters& params)
{
    NVXIO_ASSERT(end);

    configuration.frameHeight = params.frameHeight;
    configuration.frameWidth = params.frameWidth;
    configuration.fps = params.fps;

    NVXIO_ASSERT((params.format == NVXCU_DF_IMAGE_NV12) ||
                 (params.format == NVXCU_DF_IMAGE_U8) ||
                 (params.format == NVXCU_DF_IMAGE_RGB) ||
                 (params.format == NVXCU_DF_IMAGE_RGBX)||
                 (params.format == NVXCU_DF_IMAGE_NONE));

    configuration.format = params.format;

    return true;
}


bool GStreamerCameraFrameSourceImpl::InitializeGstPipeLine()
{
	std::cout<< "camera index "<< cameraIdx<<std::endl;
    GstStateChangeReturn status;
    end = true;


//**********************************************************************
//		ON-BOARD CAMERA VIA NVCAMERASRC
//**********************************************************************
if (cameraIdx==0)
	{

	GError* err = NULL;

	std::ostringstream ss;

	    // if initial values for FrameSource::Parameters are not
	    // specified, let's set them manually to prevent very huge images
	    if (configuration.frameWidth == (vx_uint32)-1)
		configuration.frameWidth = 1920;
	    if (configuration.frameHeight == (vx_uint32)-1)
		configuration.frameHeight = 1080;
	    if (configuration.fps == (vx_uint32)-1)
		configuration.fps = 30;

	ss << "nvcamerasrc ! video/x-raw(memory:NVMM), width=(int)" << configuration.frameWidth << ", height=(int)" << configuration.frameHeight << ", format=(string)NV12, framerate=(fraction)" << configuration.fps << "/1 ! nvvidconv ! "; //'video/x-raw(memory:NVMM), width=(int)1920, height=(int)1080, format=(string)I420, framerate=(fraction)30/1' ! ";
	ss << "video/x-raw ! appsink name=sink";

	std::string mLaunchStr = ss.str();

	//gstreamer command display
	//std::cout<<mLaunchStr<<std::endl;

	// launch pipeline
	GstElement * mPipeline = gst_parse_launch(mLaunchStr.c_str(), &err);

	if( err != NULL )
	{
		NVXIO_PRINT("gstreamer decoder failed to create pipeline");
		std::cout<<"gstreamer decoder failed to create pipeline" <<std::endl;
		NVXIO_PRINT(" %s ", err->message);
		g_error_free(err);
		FinalizeGstPipeLine();
		return false;
	}

	pipeline = GST_PIPELINE(mPipeline);

	if( !pipeline )
	{
		NVXIO_PRINT("gstreamer failed to cast GstElement into GstPipeline");
		std::cout<<"gstreamer failed to cast GstElement into GstPipeline" <<std::endl;
		FinalizeGstPipeLine();
		return false;
	}	

	// retrieve pipeline bus
	/*GstBus**/ bus = gst_pipeline_get_bus(pipeline);

	if( !bus )
	{
		NVXIO_PRINT("gstreamer failed to retrieve GstBus from pipeline");
		std::cout<<"gstreamer failed to retrieve GstBus from pipeline" <<std::endl;
		FinalizeGstPipeLine();
		return false;
	}

	// get the appsrc
	sink = gst_bin_get_by_name(GST_BIN(pipeline), "sink");
	GstAppSink* appsinkElement = GST_APP_SINK(sink);

	if( !appsinkElement || !sink)
	{
	NVXIO_PRINT("gstreamer failed to retrieve AppSink element from pipeline");
	std::cout<<"gstreamer failed to retrieve AppSink element from pipeline" <<std::endl;
		FinalizeGstPipeLine();
		return false;
	}

	    //set buffer  
	    gst_app_sink_set_max_buffers (GST_APP_SINK(sink), 1);
	    gst_app_sink_set_drop (GST_APP_SINK(sink), true);

	    // do not emit signals: all calls will be synchronous and blocking
	    gst_app_sink_set_emit_signals (GST_APP_SINK(sink), 0);


	// Force pipeline to play video as fast as possible, ignoring system clock
	    gst_pipeline_use_clock(pipeline, nullptr);

	    status = gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_PLAYING);
	    handleGStreamerMessages();

	    if (status == GST_STATE_CHANGE_ASYNC)
	    {
		// wait for status update
		status = gst_element_get_state(GST_ELEMENT(pipeline), nullptr, nullptr, GST_CLOCK_TIME_NONE);
	    }
	    if (status == GST_STATE_CHANGE_FAILURE)
	    {
		NVXIO_PRINT("GStreamer: unable to start playback");
		std::cout<<"GStreamer: unable to start playback" <<std::endl;
		FinalizeGstPipeLine();
		FinalizeGstPipeLine();
		return false;
	    }

	     //GST_DEBUG_BIN_TO_DOT_FILE(GST_BIN(pipeline), GST_DEBUG_GRAPH_SHOW_ALL, "pipeline");


	    configuration.format=NVXCU_DF_IMAGE_NV12;

/*
	    std::cout<<"frameWidth	"<<configuration.frameWidth<<std::endl;
	    std::cout<<"frameHeight	"<<configuration.frameHeight<<std::endl;
	    std::cout<< "sink "<< sink<<std::endl;
      	    std::cout<< "bus "<< bus<<std::endl;
            std::cout<< "pipeline "<< pipeline<<std::endl;
*/

	end = false;
	
	return true;

	}

//**********************************************************************
//		OTHER CAMERA VIA V4L2
//**********************************************************************
std::cout<< "camera index "<< cameraIdx<<std::endl;
if (cameraIdx!=0)
	{
    	    pipeline = GST_PIPELINE(gst_pipeline_new(nullptr));
    	    if (!pipeline)
    	    {
    	       NVXIO_PRINT("Cannot create Gstreamer pipeline");
    	       return false;
   	    }

	    // create v4l2src
	    GstElement * v4l2src = gst_element_factory_make("v4l2src", nullptr);
	    if (!v4l2src)
	    {
		NVXIO_PRINT("Cannot create v4l2src");
		FinalizeGstPipeLine();

		return false;
	    }

	    std::ostringstream cameraDev;
	    cameraDev << "/dev/video" << cameraIdx;
	    g_object_set(G_OBJECT(v4l2src), "device", cameraDev.str().c_str(), nullptr);

	    gst_bin_add(GST_BIN(pipeline), v4l2src);

	    // create color convert element
	    GstElement * color = gst_element_factory_make(COLOR_ELEM, nullptr);
	    if (!color)
	    {
		NVXIO_PRINT("Cannot create %s element", COLOR_ELEM);
		FinalizeGstPipeLine();

		return false;
	    }

	    gst_bin_add(GST_BIN(pipeline), color);

	    // create appsink element
	    sink = gst_element_factory_make("appsink", nullptr);
	    if (!sink)
	    {
		NVXIO_PRINT("Cannot create appsink element");
		FinalizeGstPipeLine();

		return false;
	    }

	#if FULL_GST_VERSION >= VERSION_NUM(1,7,2)
	    g_object_set(GST_ELEMENT(sink), "wait-on-eos", FALSE, nullptr);
	#endif

	    gst_bin_add(GST_BIN(pipeline), sink);

	    // if initial values for FrameSource::Parameters are not
	    // specified, let's set them manually to prevent very huge images
	    if (configuration.frameWidth == (vx_uint32)-1)
		configuration.frameWidth = 1920;
	    if (configuration.frameHeight == (vx_uint32)-1)
		configuration.frameHeight = 1080;
	    if (configuration.fps == (vx_uint32)-1)
		configuration.fps = 30;

	#if GST_VERSION_MAJOR == 0
	    std::unique_ptr<GstCaps, GStreamerObjectDeleter> caps_v42lsrc(
		gst_caps_new_simple ("video/x-raw-rgb",
		                     "width", GST_TYPE_INT_RANGE, 1, (int)configuration.frameWidth,
		                     "height", GST_TYPE_INT_RANGE, 1, (int)configuration.frameHeight,
		                     "framerate", GST_TYPE_FRACTION, (int)configuration.fps,
		                     nullptr));
	#else
	    std::ostringstream stream;
	    stream << "video/x-raw, format=(string){RGB}, width=[1," << configuration.frameWidth <<
		      "], height=[1," << configuration.frameHeight << "], framerate=" << configuration.fps << "/1;";

	    std::unique_ptr<GstCaps, GStreamerObjectDeleter> caps_v42lsrc(gst_caps_from_string(stream.str().c_str()));
	#endif

	    if (!caps_v42lsrc)
	    {
		NVXIO_PRINT("Failed to create caps");
		FinalizeGstPipeLine();

		return false;
	    }

	    // link elements
	    if (!gst_element_link_filtered(v4l2src, color, caps_v42lsrc.get()))
	    {
		NVXIO_PRINT("GStreamer: cannot link v4l2src -> color using caps");
		FinalizeGstPipeLine();

		return false;
	    }

	    // link elements
	    if (!gst_element_link(color, sink))
	    {
		NVXIO_PRINT("GStreamer: cannot link color -> appsink");
		FinalizeGstPipeLine();

		return false;
	    }

	    gst_app_sink_set_max_buffers (GST_APP_SINK(sink), 1);
	    gst_app_sink_set_drop (GST_APP_SINK(sink), true);

	    // do not emit signals: all calls will be synchronous and blocking
	    gst_app_sink_set_emit_signals (GST_APP_SINK(sink), 0);

	#if GST_VERSION_MAJOR == 0
	    std::unique_ptr<GstCaps, GStreamerObjectDeleter> caps_appsink;

	    if (configuration.format == NVXCU_DF_IMAGE_U8)
	    {
		caps_appsink.reset(gst_caps_new_simple("video/x-raw-gray",
		                                       "bpp",        G_TYPE_INT, 8,
		                                       nullptr));
	    }
	    else if (configuration.format == NVXCU_DF_IMAGE_RGB)
	    {
		caps_appsink.reset(gst_caps_new_simple("video/x-raw-rgb",
		                                       "bpp",        G_TYPE_INT, 24,
		                                       "red_mask",   G_TYPE_INT, 0xFF0000,
		                                       "green_mask", G_TYPE_INT, 0x00FF00,
		                                       "blue_mask",  G_TYPE_INT, 0x0000FF,
		                                       nullptr));
	    }
	    else if (configuration.format == NVXCU_DF_IMAGE_RGBX ||
		     configuration.format == NVXCU_DF_IMAGE_NONE)
	    {
		caps_appsink.reset(gst_caps_new_simple("video/x-raw-rgb",
		                                       "depth",      G_TYPE_INT, 32,
		                                       "bpp",        G_TYPE_INT, 32,
		                                       "endianness", G_TYPE_INT, 4321,
		                                       "red_mask",   G_TYPE_INT, 0xFF000000,
		                                       "green_mask", G_TYPE_INT, 0x00FF0000,
		                                       "blue_mask",  G_TYPE_INT, 0x0000FF00,
		                                       "alpha_mask", G_TYPE_INT, 0x000000FF,
		                                       nullptr));
	    }
	    else if (configuration.format == NVXCU_DF_IMAGE_NV12)
	    {
		caps_appsink.reset(gst_caps_new_simple("video/x-raw-yuv",
		                                       "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('N', 'V', '1', '2'),
		                                       nullptr));
	    }
	    else
		NVXIO_THROW_EXCEPTION("Unsupported image format");
	#else
	    std::string caps_string("video/x-raw, format=(string){");
	    if (configuration.format == NVXCU_DF_IMAGE_U8)
		caps_string += "GRAY8";
	    else if (configuration.format == NVXCU_DF_IMAGE_RGB)
		caps_string += "RGB";
	    else if (configuration.format == NVXCU_DF_IMAGE_RGBX ||
		     configuration.format == NVXCU_DF_IMAGE_NONE)
		caps_string += "RGBA";
	    else if (configuration.format == NVXCU_DF_IMAGE_NV12)
		caps_string += "NV12";
	    else
		NVXIO_THROW_EXCEPTION("Unsupported image format");

	    caps_string += "};";

	    std::unique_ptr<GstCaps, GStreamerObjectDeleter> caps_appsink(
		    gst_caps_from_string(caps_string.c_str()));
	#endif
	    gst_app_sink_set_caps(GST_APP_SINK(sink), caps_appsink.get());

	// Force pipeline to play video as fast as possible, ignoring system clock
	    gst_pipeline_use_clock(pipeline, nullptr);

	    status = gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_PLAYING);
	    handleGStreamerMessages();

	    if (status == GST_STATE_CHANGE_ASYNC)
	    {
		// wait for status update
		status = gst_element_get_state(GST_ELEMENT(pipeline), nullptr, nullptr, GST_CLOCK_TIME_NONE);
	    }
	    if (status == GST_STATE_CHANGE_FAILURE)
	    {
		NVXIO_PRINT("GStreamer: unable to start playback");
		FinalizeGstPipeLine();

		return false;
	    }

	    // GST_DEBUG_BIN_TO_DOT_FILE(GST_BIN(pipeline), GST_DEBUG_GRAPH_SHOW_ALL, "pipeline");

	    // explicitly set params to -1 to ensure
	    // their update in the updateConfiguration() function
	    configuration.frameWidth = (uint32_t)-1;
	    configuration.frameHeight = (uint32_t)-1;
	    configuration.fps = (uint32_t)-1;

	    if (!updateConfiguration(sink, color, configuration))
	    {
		FinalizeGstPipeLine();
		return false;
	    }

	    end = false;

	    return true;
	}
    std::cout<< "camera index "<< cameraIdx<<std::endl;
}

} // namespace nvidiaio

#endif // USE_GSTREAMER