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