#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 *mux_name = NULL;
static gchar *output_uri = NULL;



static gboolean
_quit(gpointer data)
{
  g_object_unref(data);
  g_main_loop_quit(mainloop);
  return FALSE;
}

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


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

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 = NULL;
  GIOChannel *ch;
  gchar **vopts;
  gchar **aopts;
  gchar **files;
  gint i;

  GOptionContext *context;
  static const GOptionEntry options[] = {
	{"input-files", '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},

	{"mux-element", 0, 0, G_OPTION_ARG_STRING, &mux_name,
	 "GstElementName for use to mux file", NULL},

	{"output-uri", 'o', 0, G_OPTION_ARG_STRING, &output_uri,
	 "Uri to output", NULL},

	{NULL}
  };

  g_type_init();
  g_thread_init(NULL);
  mainloop = g_main_loop_new(NULL, FALSE);

  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_uri == NULL)
	{
	  g_print("You need to specify output-uri.\nTry --help "
			  "for more information.\n");
	  return 1;
	}

  if (input_file == NULL)
	{
	  g_print("You need to 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);

  g_mencoder_setup_stream(coder, mux_name,
						  video_encode, vopts, video_fps,
						  video_rate, video_width, video_height,
						  audio_encode, aopts, audio_rate, output_uri);

  files = g_strsplit(input_file, ",", 0);
  for (i = 0; i < g_strv_length(files); i++)
	{
	  if (!g_mencoder_append_uri(coder, files[i]))
		{
		  g_debug("Invalid uri: %s", files[i]);
		}
	}

  g_strfreev(files);
  g_strfreev(aopts);
  g_strfreev(vopts);


  g_io_add_watch(ch, G_IO_IN, _io_channel_cb, coder);

  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_mencoder_play_stream(coder);

  g_debug("RUNNING..");
  g_main_loop_run(mainloop);
  g_debug("DONE");
  g_object_unref(coder);

  return 0;
}