#ifdef HAVE_CONFIG_H

 #include "config.h"

 #endif

 #include <sys/types.h>

 #include <sys/socket.h>

 #include <netdb.h>

 #include <netinet/in.h>

 #include <unistd.h>

 #include <glib.h>

 #include <glib/gprintf.h>

 #include <string.h>

 #include "gmyth-stream-client.h"

 #define GMYTH_STREAM_CLIENT_GET_PRIVATE(obj) \

     (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GMYTH_TYPE_STREAM_CLIENT, GMythStreamClientPrivate))

 typedef struct _GMythStreamClientPrivate GMythStreamClientPrivate;

 struct _GMythStreamClientPrivate

 {

 	GList *streams;

 	struct hostent *host;

 	gint sock;

 	gboolean connected;

    	struct sockaddr_in addr;

 };

 typedef struct _StreamData StreamData;

 struct _StreamData

 {

 	guint id;

 	guint port;

     gint s;

 };

 static void gmyth_stream_client_class_init				(GMythStreamClientClass *klass);

 static void gmyth_stream_client_init					(GMythStreamClient *object);

 static void gmyth_stream_client_dispose  				(GObject *object);

 static void gmyth_stream_client_finalize 				(GObject *object);

 static StreamData* gmtyh_stream_client_get_streamdata 	(GMythStreamClient *self,

 														 guint stream_id);

 G_DEFINE_TYPE(GMythStreamClient, gmyth_stream_client, G_TYPE_OBJECT)

 static void

 gmyth_stream_client_class_init (GMythStreamClientClass *klass)

 {

 	GObjectClass *gobject_class;

 	gobject_class = (GObjectClass *) klass;

 	g_type_class_add_private (klass, sizeof (GMythStreamClientPrivate));

 	gobject_class->dispose  = gmyth_stream_client_dispose;

 	gobject_class->finalize = gmyth_stream_client_finalize;

 }

 static void

 gmyth_stream_client_init (GMythStreamClient *self)

 {

 }

 static void

 gmyth_stream_client_dispose (GObject *object)

 {

     gmyth_stream_client_disconnect (GMYTH_STREAM_CLIENT (object));

 }

 static void

 gmyth_stream_client_finalize (GObject *object)

 {

 }

 GMythStreamClient*

 gmyth_stream_client_new ()

 {

 	return GMYTH_STREAM_CLIENT (g_object_new (GMYTH_TYPE_STREAM_CLIENT, NULL));

 }

 gboolean

 gmyth_stream_client_connect (GMythStreamClient *self, const gchar *server, guint port)

 {

 	GMythStreamClientPrivate *priv = GMYTH_STREAM_CLIENT_GET_PRIVATE (self);

 	g_return_val_if_fail (priv->connected == FALSE, TRUE);

 	priv->sock = socket (PF_INET, SOCK_STREAM, 0);

 	if (priv->sock == -1) {

 	    g_debug ("Fail to create sock");

 	    return FALSE;

 	}

 	memset(&(priv->addr), 0, sizeof(priv->addr));

 	priv->host = gethostbyname(server);

 	memcpy(&(priv->addr), *(priv->host->h_addr_list), sizeof(struct in_addr));

 	priv->addr.sin_family = AF_INET;

 	priv->addr.sin_port = htons (port);

 	if (connect (priv->sock, (struct sockaddr *) &(priv->addr), sizeof (priv->addr)) == -1) {

             g_debug ("Fail to connect with server");

 	    shutdown (priv->sock,  SHUT_RDWR);

 	    priv->sock = -1;

 	    return FALSE;

 	}

     priv->connected = TRUE;

     return TRUE;

 }

 void

 gmyth_stream_client_disconnect (GMythStreamClient *self)

 {

     GMythStreamClientPrivate *priv = GMYTH_STREAM_CLIENT_GET_PRIVATE (self);

 	g_return_if_fail (priv->connected == FALSE);

 	GList *lst = priv->streams;

 	for (; lst != NULL; lst = lst->next) {

 		StreamData *data = (StreamData *) lst->data;

 		gmyth_stream_client_close_stream (self, data->id);

 	}

 	close (priv->sock);

 	shutdown (priv->sock, SHUT_RDWR);

     priv->sock = -1;

     priv->connected = FALSE;

 }

 guint

 gmyth_stream_client_open_stream (GMythStreamClient *self,

                 const gchar* file_name,

                 const gchar* mux,

                 const gchar* vcodec,

                 guint vbitrate,

                 gdouble fps,

                 const gchar* acodec,

                 guint abitrate,

 				guint width, guint height,

 				guint port,

 				const gchar* opt)

 {

 	gchar *cmd;

 	StreamData *data = NULL;

 	GMythStreamClientPrivate *priv = GMYTH_STREAM_CLIENT_GET_PRIVATE (self);

 	g_return_val_if_fail (priv->connected == TRUE, FALSE);

 	g_return_val_if_fail (file_name != NULL, FALSE);

 	cmd = g_strdup_printf ("SETUP %s %s %s %d %f %s %d %d %d %d %s\n",

 					file_name,

 					(mux == NULL? "X" : mux),

 					(vcodec == NULL ? "X" : vcodec),

 					vbitrate,

 					fps,

 					(acodec == NULL ? "X" : acodec),

 					abitrate,

 					width, height, port,

 					(opt == NULL ? "X" : opt));

 	if (send (priv->sock, cmd, strlen (cmd), MSG_CONFIRM) == -1) {

 		g_free (cmd);

 		return -1;

 	}

 	g_free (cmd);

 	data = g_new0 (StreamData, 1);

 	data->port = port;

 	data->id = data->s = socket (PF_INET, SOCK_STREAM, 0);

 	priv->streams = g_list_append (priv->streams, data);

 	return data->id;

 }

 static gchar**

 _parse_return (int fd)

 {

 }

 gboolean

 gmyth_stream_client_play_stream (GMythStreamClient *self,

 								guint stream_id)

 {

 	GMythStreamClientPrivate *priv = GMYTH_STREAM_CLIENT_GET_PRIVATE (self);

 	StreamData *data;

 	struct sockaddr_in addr;

 	gchar **retval;

 	g_return_val_if_fail (priv->connected == TRUE, FALSE);

 	data = gmtyh_stream_client_get_streamdata (self, stream_id);

 	g_return_val_if_fail (data != NULL, FALSE);

 	if (send (priv->sock, "PLAY\n", 5, MSG_MORE) == -1) {

 		return FALSE;

 	}

 	retval = _read_message (priv->sock);

 	g_usleep (10 * G_USEC_PER_SEC);

 	memset(&addr, 0, sizeof(addr));

 	memcpy(&addr, *(priv->host->h_addr_list), sizeof(struct in_addr));

 	addr.sin_family = AF_INET;

 	addr.sin_port = htons (data->port);

 	g_debug ("request connection on port %d", data->port);

 	if (connect(data->s,(struct sockaddr*) &addr, sizeof(addr)) == -1)

 		g_warning ("Fail to connect to server");

 	return TRUE;

 }

 void

 gmyth_stream_client_pause_stream (GMythStreamClient *self,

 									guint stream_id)

 {

 	GMythStreamClientPrivate *priv = GMYTH_STREAM_CLIENT_GET_PRIVATE (self);

 	g_return_if_fail (priv->connected == TRUE);

 	if (send (priv->sock, "PAUSE\n", 6, MSG_MORE) == -1) {

 		return;

 	}

 }

 void

 gmyth_stream_client_close_stream (GMythStreamClient *self,

                     			  guint stream_id)

 {

 	GMythStreamClientPrivate *priv = GMYTH_STREAM_CLIENT_GET_PRIVATE (self);

 	g_return_if_fail (priv->connected == TRUE);

 	if (send (priv->sock, "STOP\n", 5, MSG_MORE) == -1) {

 		return;

 	}

 	//TODO: remove from streams list

 }

 static StreamData*

 gmtyh_stream_client_get_streamdata (GMythStreamClient *self,

 									guint stream_id)

 {

 	GMythStreamClientPrivate *priv = GMYTH_STREAM_CLIENT_GET_PRIVATE (self);

 	GList *lst;

 	lst = priv->streams;

 	for (; lst != NULL; lst = lst->next) {

 		StreamData *data = (StreamData *) lst->data;

 		if (data->id == stream_id) {

 			return data;

 		}

 	}

 	return NULL;

 }