imports.gi.versions.GLib = '2.0';
imports.gi.versions.GObject = '2.0';
imports.gi.versions.Gio = '2.0';

imports.gi.versions.Gdk = '3.0';
imports.gi.versions.Gtk = '3.0';

imports.gi.versions.Clutter = '1.0';

imports.gi.versions.Gst = '0.10';
imports.gi.versions.GstBase = '0.10';
imports.gi.versions.GstVideo = '0.10';

const Mainloop = imports.mainloop;

const GLib = imports.gi.GLib;
const GObject = imports.gi.GObject;
const Gio = imports.gi.Gio;

const Gdk = imports.gi.Gdk;
const Gtk = imports.gi.Gtk;

const Clutter = imports.gi.Clutter;

const Gst = imports.gi.Gst;
const GstBase = imports.gi.GstBase;
const GstApp = imports.gi.GstApp;
const GstVideo = imports.gi.GstVideo;

function _init() {
    Gst.init(null, null);
    Gst.debug_set_active(true);
    Gst.debug_set_default_threshold(Gst.DebugLevel.WARNING);
    Gst.debug_set_colored(false);

    let pipeline = Gst.Pipeline.new('my-pipeline');

    if (!pipeline) {
        throw new Error('could not create pipeline');
    }

    let bus = pipeline.get_bus();
    bus.connect('sync-message',
                function(bus, message) {
                    print (message);
                });
    bus.connect('message::eos',
                function() {
                    print('end of stream');
                    Mainloop.quit();
                    throw new Error('eos');
                });
    bus.connect('message::error',
                function(bus, message) {
                    let [ error, debug ] = message.parse_error();
                    printerr('error: ' + error.message);
                    printerr('debug: ' + debug);
                    throw new Error('error');
                });

    let source = Gst.ElementFactory.make('filesrc', 'file-source');

    if (!source) {
        throw new Error('could not create element of type filesrc');
    }
    source.location = ARGV[0];
    pipeline.add(source);

    let demuxer = Gst.ElementFactory.make('oggdemux', 'ogg-demuxer');

    if (!demuxer) {
        throw new Error('could not create element of type oggdemux');
    }
    pipeline.add(demuxer);

    let decoder = Gst.ElementFactory.make('vorbisdec', 'vorbis-decoder');

    if (!decoder) {
        throw new Error('could not create element of type vorbisdec');
    }
    pipeline.add(decoder);

    let converter = Gst.ElementFactory.make('audioconvert', 'converter');

    if (!converter) {
        throw new Error('could not create element of type audioconvert');
    }
    pipeline.add(converter);

    let sink = Gst.ElementFactory.make('autoaudiosink', 'audio-output');

    if (!sink) {
        throw new Error('could not create element of type autoaudiosink');
    }
    pipeline.add(sink);

    source.link(demuxer);

    demuxer.connect('pad-added',
                    function(element, pad) {
                        print('a new pad ' + pad.get_name() + ' was created');
                        let sinkPad = decoder.get_static_pad('sink');

                        pad.link(sinkPad);
                    });

    decoder.link(converter);
    converter.link(sink);

    pipeline.set_state(Gst.State.PLAYING);
    Mainloop.run('stream');

    pipline.set_state(Gst.State.NULL);
}

_init();