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