#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;

}