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

}