#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <string.h>

#include <gst/gst.h>

#include <glib.h> 

static GMainLoop *mainloop = NULL;

static gint64 d = 0;

static gint64 gap = 10;

typedef enum {

    MY_STREAM_TYPE_AUDIO = 0,

    MY_STREAM_TYPE_VIDEO = 1

} MyStreamType;

typedef struct _StreamData StreamData;

struct _StreamData {

    GstElement *bin;

    MyStreamType type;

};

static void

_stream_decode_pad_added_cb (GstElement *decode, 

                            GstPad *pad,

                            gboolean arg1,

                            gpointer user_data)

{

    StreamData *data = (StreamData *) user_data;

    GstElement *queue;

    GstPad* sink_pad;

    GstCaps* caps = gst_pad_get_caps (pad);

    gchar *str_caps = gst_caps_to_string (caps);

    g_debug ("decode caps: [%d] [%s]", data->type, str_caps);

    switch (data->type)

    {

        case MY_STREAM_TYPE_AUDIO:

            g_debug ("Audio");

            if (strstr (str_caps, "audio") == NULL) 

                goto done;

            break;

        case MY_STREAM_TYPE_VIDEO:

            g_debug ("Video");

            if (strstr (str_caps, "video") == NULL)

                goto done;

            break;

    }

    queue = gst_bin_get_by_name (GST_BIN (data->bin), "queue");

    sink_pad = gst_element_get_pad (queue, "sink");

    if (gst_pad_link (pad, sink_pad) != GST_PAD_LINK_OK) {

        g_warning ("Failed to link decode");

    }

    gst_object_unref (queue);

    gst_object_unref (sink_pad);

    //g_free (data);

    g_debug ("Linked");

done:

    gst_caps_unref (caps);

    g_free (str_caps);

}

static GstElement*

_create_src_element (const gchar* name,

                     const gchar* uri,                 

                     MyStreamType type,

                     guint priority)

{

    StreamData *data;

    GstElement *bin;

    GstElement *src;

    GstElement *decode;

    GstElement *queue;

    GstPad *src_pad;

    GstElement *gnl_src;

    g_debug ("element from uri: %s", uri);

    bin = gst_bin_new ("bin");

    src = gst_element_make_from_uri (GST_URI_SRC, uri, "src");

    g_return_val_if_fail (src != NULL, NULL);

    decode = gst_element_factory_make ("decodebin", NULL);

    g_return_val_if_fail (decode != NULL, NULL);

    queue = gst_element_factory_make ("queue", "queue");

    g_return_val_if_fail (queue != NULL, NULL);

    gst_bin_add_many (GST_BIN (bin), src, decode, queue, NULL);

    gst_element_link (src, decode);

    data = g_new0 (StreamData, 1);

    data->bin = bin;

    data->type = type;

    g_debug ("Type : %d = %d", type, data->type);

    g_signal_connect (G_OBJECT (decode), "new-decoded-pad",

                      G_CALLBACK (_stream_decode_pad_added_cb), 

                      data);

    src_pad = gst_element_get_pad (queue, "src");

    g_return_val_if_fail (src_pad != NULL, NULL);

    gst_element_add_pad (bin,

        gst_ghost_pad_new ("src", src_pad));

    gst_object_unref (src_pad);

    gnl_src = gst_element_factory_make ("gnlsource", name);

    g_return_val_if_fail (gnl_src != NULL, NULL);

    gst_bin_add (GST_BIN (gnl_src), bin);

    g_debug ("ADDING WITH: START [%lli] DUR [%lli]", d, gap);

    if (d == 0) {

        g_object_set (G_OBJECT (gnl_src),

                        //"start", 0L,

                        "duration", 10 * GST_SECOND,

                        //"media-start", 0L,

                        //"media-duration", 10 * GST_SECOND,

                        "priority", priority,

                        NULL);

    } else {

        g_object_set (G_OBJECT (gnl_src),

                        "start", 10 * GST_SECOND,

                        "duration", 10 * GST_SECOND,

                        ///"media-start", 10 * GST_SECOND,

                        //"media-duration", 10 * GST_SECOND,

                        "priority", priority,

                        NULL);

    }

    d++;

    return gnl_src;

}

static void

_composition_pad_added_cb (GstElement *composition, 

                           GstPad *pad,

                           gpointer data)

{

    GstPad *sink_pad = gst_element_get_pad (GST_ELEMENT (data), "sink");

    g_debug ("compose pad added");

    if (gst_pad_link (pad, sink_pad) != GST_PAD_LINK_OK) {

        g_warning ("Failed to link decode");

    }

    g_debug ("Linked ok");

}

static void

_compose_add_file (GstElement *compose,

                   const gchar* e_name,

                   const gchar* uri,

                   MyStreamType type, 

                   guint priority)

{

    GstElement *src;

    src = _create_src_element (e_name, uri, type, priority);

    gst_bin_add (GST_BIN (compose), src);

}

int 

main (int argc, char** argv)

{

    GstElement* pipe;

    GstElement* gnl_compose_a;

    GstElement* gnl_compose_v;

    GstElement* asink;

    GstElement* vsink;

    GstElement* aqueue;

    GstElement* vqueue;

    g_type_init ();

    gst_init (&argc, &argv);

	mainloop = g_main_loop_new (NULL, FALSE);

    pipe = gst_pipeline_new ("test_pipeline");

    gnl_compose_a = gst_element_factory_make ("gnlcomposition", "acompose");

    g_return_val_if_fail (gnl_compose_a != NULL, 1);

    gnl_compose_v = gst_element_factory_make ("gnlcomposition", "vcompose");

    g_return_val_if_fail (gnl_compose_v != NULL, 1);

    //_compose_add_file (gnl_compose_a, "src0", argv[1], MY_STREAM_TYPE_AUDIO, 1);

    //_compose_add_file (gnl_compose_a, "src1", argv[2], MY_STREAM_TYPE_AUDIO, 1);

    d = 0;

    _compose_add_file (gnl_compose_v, "src2", argv[1], MY_STREAM_TYPE_VIDEO, 1);

    _compose_add_file (gnl_compose_v, "src3", argv[2], MY_STREAM_TYPE_VIDEO, 1);

    //aqueue = gst_element_factory_make ("queue", "aqueue");

    //asink = gst_element_factory_make ("alsasink", "asink");

    vqueue = gst_element_factory_make ("queue", "vqueue");

    vsink = gst_element_factory_make ("xvimagesink", "vsink");

    gst_bin_add_many (GST_BIN (pipe), gnl_compose_a, gnl_compose_v, 

            vqueue, vsink, 

            //aqueue, asink, 

            NULL);

    gst_element_link (vqueue, vsink);

    //gst_element_link (aqueue, asink);

    //g_signal_connect (G_OBJECT (gnl_compose_a), "pad-added",

    //                  G_CALLBACK (_composition_pad_added_cb), aqueue);

    g_signal_connect (G_OBJECT (gnl_compose_v), "pad-added",

                      G_CALLBACK (_composition_pad_added_cb), vqueue);

    //g_idle_add (_play, pipe);

    gst_element_set_state (GST_ELEMENT (pipe), GST_STATE_PLAYING);

	g_main_loop_run (mainloop);

	return 0;

}