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

 	gint sock;

 	gboolean connected;

 };

 typedef struct _StreamData StreamData;

 struct _StreamData

 {

 	guint id;

 	guint port;

 };

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

 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)

 {

     	struct sockaddr_in addr;

      	struct hostent *hp;

 	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(&addr, 0, sizeof(addr));

 	hp = gethostbyname(server);

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

 	addr.sin_family = AF_INET;

 	addr.sin_port = htons (port);

 	if (connect (priv->sock, (struct sockaddr *) &addr, sizeof (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)

 {

 	gint stream_id = 0;

 	gchar *cmd;

 	StreamData *data = NULL;

 	GMythStreamClientPrivate *priv = GMYTH_STREAM_CLIENT_GET_PRIVATE (self);

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

 	if (send (priv->sock, "SETUP", 5, MSG_CONFIRM) == -1)

  	    return -1;

 	cmd = g_strdup_printf ("%s %s %s %d %f %s %d %d %d %d %s",

 	                file_name, mux, vcodec, vbitrate, fps,

 	                acodec, abitrate, width, height, port, 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->id = stream_id;

     	data->port = port;

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

 	return stream_id;

 }

 gboolean

 gmyth_stream_client_play_stream (GMythStreamClient *self,

 				                 guint stream_id)

 {

 	GMythStreamClientPrivate *priv = GMYTH_STREAM_CLIENT_GET_PRIVATE (self);

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

     	if (send (priv->sock, "PLAY", 4, MSG_MORE) == -1) {

 	        return FALSE;

     	}	

 	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", 5, 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", 4, MSG_MORE) == -1) {

         return;

     }

     //TODO: remove from streams list

 }