#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#include <gst/gst.h>
#include <glib.h> 

#include "gmencoder.h"

#define FILE_OUT  1

static GMainLoop *mainloop = NULL;
/* Options */
static gchar*   input_file      = NULL;
static gchar*   video_encode    = NULL;
static gchar*   video_opts      = NULL;
static gdouble  video_fps       = 0.0;
static gint     video_rate      = 0;
static gint     video_width     = 0;
static gint     video_height    = 0;
static gchar*   audio_encode    = NULL;
static gchar*   audio_opts      = NULL;
static double   audio_rate      = 0.0;
static gchar*   output_element  = NULL;
static gchar*   output_opts     = NULL;

static void
_mencoder_ready_cb (GMencoder *mencoder, gpointer data)
{
    g_mencoder_play_stream (mencoder);
}

static void
_mencoder_eos_cb (GMencoder *mencoder, gpointer data)
{
    g_print ("EOS\n");
    g_main_loop_quit ((GMainLoop *) data);
}

static void
_mencoder_error_cb (GMencoder *mencoder, const gchar* msg, gpointer data)
{
    g_print ("Error: %s\n", msg);
    g_main_loop_quit ((GMainLoop *) data);
}

static gboolean
_io_channel_cb (GIOChannel *ch,
                GIOCondition condition,
                gpointer data)
{
    GString *cmd = g_string_new ("");
    g_io_channel_read_line_string (ch, cmd, NULL, NULL);

    if (strcmp (cmd->str, "PLAY\n") == 0) {
        g_mencoder_play_stream (G_MENCODER (data));
    } else if (strcmp (cmd->str, "PAUSE\n") == 0) {
        g_mencoder_pause_stream (G_MENCODER (data));
    } else if (strcmp (cmd->str, "STOP\n") == 0) {
        g_mencoder_close_stream (G_MENCODER (data));
    } else if (strcmp (cmd->str, "QUIT\n") == 0) {
        g_mencoder_close_stream (G_MENCODER (data));
        g_main_loop_quit (mainloop);
    }
    g_string_free (cmd, TRUE);
    return TRUE;
}

int 
main (int argc, char** argv)
{
    GMencoder *coder;
    GIOChannel *ch;
    gchar **oopts;
    gchar **vopts;
    gchar **aopts;

    GOptionContext *context;
    static const GOptionEntry options []  = {
        {"input-file",    'i', 0, G_OPTION_ARG_STRING,          &input_file,    "Input File", NULL},
        {"video-encode",    0, 0, G_OPTION_ARG_STRING,          &video_encode,  "GstElementName for used to video encode", NULL},
        {"video-opts",      0, 0, G_OPTION_ARG_STRING,          &video_opts,    "Properties to set on video element", NULL},
        {"video-fps",       0, 0, G_OPTION_ARG_DOUBLE,          &video_fps,     "Video FPS", NULL},
        {"video-rate",      0, 0, G_OPTION_ARG_INT,             &video_rate,    "Video rate", NULL},
        {"video-width",     0, 0, G_OPTION_ARG_INT,             &video_width,   "Video width", NULL},
        {"video-height",    0, 0, G_OPTION_ARG_INT,             &video_height,  "Video height", NULL},
        {"audio-encode",    0, 0, G_OPTION_ARG_STRING,          &audio_encode,  "GstElementName for use to audio encode", NULL},
        {"audio-opts",      0, 0, G_OPTION_ARG_STRING,          &audio_opts,    "Properties to set on audio element", NULL},
        {"audio-rate",      0, 0, G_OPTION_ARG_INT,             &audio_rate,    "Audio rate", NULL},
        {"output-element",  0, 0, G_OPTION_ARG_STRING,          &output_element,"GstElementName for use to output", NULL},
        {"output-opts",     0, 0, G_OPTION_ARG_STRING,          &output_opts,   "Properties to set on output element", NULL},
        { NULL }
    };

	g_type_init ();
    g_thread_init (NULL);

	//g_set_prgname ("gmemcoder");
    context = g_option_context_new (NULL);
    g_option_context_set_help_enabled (context, TRUE);
    g_option_context_add_main_entries (context, options, NULL);
    g_option_context_add_group (context, gst_init_get_option_group ());
    g_option_context_parse (context, &argc, &argv, NULL);

	gst_init (&argc, &argv);

    if (output_element == NULL) {
        g_print ("You need specify output-element name.\nTry --help for more information.\n");
        return 1; 
    }

    if (input_file == NULL) {
        g_print ("You need specify input file\nTry --help for more information.\n");
    }

    coder = g_mencoder_new ();
    ch = g_io_channel_unix_new (0);

    aopts = g_strsplit (audio_opts, ",", 0);
    vopts = g_strsplit (video_opts, ",", 0);
    oopts = g_strsplit (output_opts, ",", 0);

    g_mencoder_setup_stream (coder, 
            input_file, 
            video_encode, vopts, video_fps, video_rate, video_width, video_height,
            audio_encode, aopts, audio_rate, 
            output_element, oopts);

    g_strfreev (aopts);
    g_strfreev (vopts);
    g_strfreev (oopts);

	mainloop = g_main_loop_new (NULL, FALSE);
    g_io_add_watch (ch, G_IO_IN, _io_channel_cb, coder);    


    g_signal_connect (G_OBJECT (coder),
                        "ready",
                        G_CALLBACK (_mencoder_ready_cb),
                        NULL);

    g_signal_connect (G_OBJECT (coder),
                        "eos",
                        G_CALLBACK (_mencoder_eos_cb),
                        mainloop);

    g_signal_connect (G_OBJECT (coder),
                        "error",
                        G_CALLBACK (_mencoder_error_cb),
                        mainloop);

	g_main_loop_run (mainloop);

	return 0;
}