#ifdef HAVE_CONFIG_H

 #include "config.h"

 #endif

 #include <sys/types.h>

 #include <sys/socket.h>

 #include <arpa/inet.h>

 #include <netdb.h>

 #include <netinet/in.h>

 #include <unistd.h>

 #include <glib.h>

 #include <glib/gprintf.h>

 #include <string.h>

 #include <stdlib.h>

 #include "gmyth-stream-client.h"

 #define BUFFER_SIZE 1024

 #define GMYTH_STREAM_CLIENT_GET_PRIVATE(obj) \

     (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GMYTH_TYPE_STREAM_CLIENT,\

  GMythStreamClientPrivate))

 typedef struct _sock _socket;

 struct _sock

 {

     gint fd;

     struct sockaddr_in addr;

 };

 typedef struct _GMythStreamClientPrivate GMythStreamClientPrivate;

 struct _GMythStreamClientPrivate

 {

     const gchar *host;

     _socket* sock;

     _socket* sock_stream;

     gboolean connected;

 };

 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 _socket*

 create_socket (const gchar* hostname, gint port)

 {

     _socket* sock = (_socket*)g_malloc(sizeof(_socket));

     sock->fd = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);

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

         g_debug ("Fail to create sock");

         g_free(sock);

         return NULL;

     }

     sock->addr.sin_family = AF_INET;

     sock->addr.sin_addr.s_addr = inet_addr(hostname);

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

     if (connect (sock->fd, (struct sockaddr *) &(sock->addr), \

                  sizeof (sock->addr)) == -1) {

         g_debug ("Fail to connect with server");

         g_free(sock);

         return NULL;

     }

     return sock;

 }

 static gint

 read_message (int socket)

 {

     gint64 total_read = 0;

     gint result = -1;

     gchar buffer[BUFFER_SIZE];

     gchar** response;

     total_read = recv(socket, buffer, BUFFER_SIZE, 0);

     if (total_read > 0) {

         response = g_strsplit_set(buffer, " +\n", 8);

         if ( g_ascii_strcasecmp(response[0], "OK") == 0 ) {

             int payload = atoi(response[1]);

             if (payload == 0)

                 result = 0;

             else if (payload == 1) {

                 total_read = recv(socket, buffer, BUFFER_SIZE, 0);

                 response = g_strsplit_set(buffer, "+\n", 8);

                 result = atoi(response[1]);

             }

         }

         g_strfreev(response);

     }

     return result;

 }

 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)

 {

     GMythStreamClientPrivate *priv = GMYTH_STREAM_CLIENT_GET_PRIVATE (self);

     priv->sock = NULL;

     priv->sock_stream = NULL;

 }

 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->host = server;

     priv->sock = create_socket (server, port);

     if (priv->sock == NULL) 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 == TRUE);

     close (priv->sock->fd);

     //shutdown (priv->sock->fd, SHUT_RDWR);

     priv->sock->fd = -1;

     priv->connected = FALSE;

 }

 gint

 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,

                                  const gchar* opt)

 {

     gchar *cmd;

     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 %s\n",

                            file_name,

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

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

                            vbitrate,

                            fps,

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

                            abitrate,

                            width, height,

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

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

         g_free (cmd);

         return -1;

     }

     g_free (cmd);

     read_message(priv->sock->fd);

     return 0;

 }

 gint

 gmyth_stream_client_play_stream (GMythStreamClient *self)

 {

     GMythStreamClientPrivate *priv = GMYTH_STREAM_CLIENT_GET_PRIVATE (self);

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

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

         return -1;

     }

     gint port = read_message(priv->sock->fd);

     priv->sock_stream = create_socket(priv->host, port);

     return priv->sock_stream->fd;

 }

 void

 gmyth_stream_client_close_stream (GMythStreamClient *self)

 {

     GMythStreamClientPrivate *priv = GMYTH_STREAM_CLIENT_GET_PRIVATE (self);

     g_return_if_fail (priv->connected == TRUE);

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

         return;

     }

     read_message(priv->sock->fd);

     close(priv->sock_stream->fd);

     g_free(priv->sock_stream);

     priv->sock_stream = NULL;

 }