/*

  * @author Artur Duque de Souza <souza.artur@indt.org.br>

  *

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU Lesser General Public License as published by

  * the Free Software Foundation; either version 2 of the License, or

  * (at your option) any later version.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  m * You should have received a copy of the GNU Lesser General Public License

  * along with this program; if not, write to the Free Software

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  */

 #ifdef HAVE_CONFIG_H

 #include <config.h>

 #endif

 #include <sys/socket.h>         /* for socket(), connect(), send(), and

                                  * recv() */

 #include <arpa/inet.h>          /* for sockaddr_in and inet_addr() */

 #include <stdlib.h>             /* for atoi() and exit() */

 #include <string.h>             /* for memset() */

 #include <unistd.h>             /* for close() */

 #include <errno.h>

 #include <glib.h>

 #include <glib/gprintf.h>

 #include <glib/gstdio.h>

 #include <gmyth-stream-client.h>

 #include <libgnomevfs/gnome-vfs-module.h>

 #include <libgnomevfs/gnome-vfs-utils.h>

 #define BUFFER_SIZE 4096

 typedef struct {

     gint            port;

     gchar          *hostname;

     GMythStreamClient *stream;

     gint            fd;

 } gmsHandle;

 typedef struct {

     gchar          *file_name;

     gchar          *mux;

     gchar          *vcodec;

     guint           vbitrate;

     gdouble         fps;

     gchar          *acodec;

     guint           abitrate;

     guint           width;

     guint           height;

     guint           port;

     gchar          *opt;

 } UriArgs;

 static gmsHandle *gmsHandle_new(GnomeVFSURI * uri);

 static          GnomeVFSResult

 do_open(GnomeVFSMethod * method,

         GnomeVFSMethodHandle ** method_handle,

         GnomeVFSURI * uri,

         GnomeVFSOpenMode mode, GnomeVFSContext * context);

 static          GnomeVFSResult

 do_read(GnomeVFSMethod * method,

         GnomeVFSMethodHandle * method_handle,

         gpointer buffer,

         GnomeVFSFileSize bytes,

         GnomeVFSFileSize * bytes_read, GnomeVFSContext * context);

 static          GnomeVFSResult

 do_close(GnomeVFSMethod * method,

          GnomeVFSMethodHandle * method_handle, GnomeVFSContext * context);

 static          GnomeVFSResult

 do_get_file_info(GnomeVFSMethod * method,

                  GnomeVFSURI * uri,

                  GnomeVFSFileInfo * file_info,

                  GnomeVFSFileInfoOptions options,

                  GnomeVFSContext * context);

 static          GnomeVFSResult

 do_get_file_info_from_handle(GnomeVFSMethod * method,

                              GnomeVFSMethodHandle * method_handle,

                              GnomeVFSFileInfo * file_info,

                              GnomeVFSFileInfoOptions options,

                              GnomeVFSContext * context);

 static          gboolean

 do_is_local(GnomeVFSMethod * method, const GnomeVFSURI * uri);

 static gmsHandle *

 gmsHandle_new(GnomeVFSURI * uri)

 {

     gmsHandle      *handler = (gmsHandle *) g_malloc0(sizeof(gmsHandle));

     handler->hostname = (gchar *) gnome_vfs_uri_get_host_name(uri);

     handler->port = gnome_vfs_uri_get_host_port(uri);

     handler->stream = gmyth_stream_client_new();

     return handler;

 }

 static GnomeVFSMethod method = {

     sizeof(GnomeVFSMethod),

     do_open,                    /* open */

     NULL,                       /* create */

     do_close,                   /* close */

     do_read,                    /* read */

     NULL,                       /* write */

     NULL,                       /* seek */

     NULL,                       /* tell */

     NULL,                       /* truncate_handle */

     NULL,                       /* open_directory */

     NULL,                       /* close_directory */

     NULL,                       /* read_directory */

     do_get_file_info,           /* get_file_info */

     do_get_file_info_from_handle,   /* get_file_info_from_handle */

     do_is_local,                /* is_local */

     NULL,                       /* make_directory */

     NULL,                       /* remove_directory */

     NULL,                       /* move */

     NULL,                       /* unlink */

     NULL,                       /* check_same_fs */

     NULL,                       /* set_file_info */

     NULL,                       /* truncate */

     NULL,                       /* find_directory */

     NULL,                       /* create_symbolic_link */

     NULL,                       /* monitor_add */

     NULL,                       /* monitor_cancel */

     NULL                        /* file_control */

 };

 GnomeVFSMethod *

 vfs_module_init(const char *method_name, const char *args)

 {

     return &method;

 }

 void

 vfs_module_shutdown(GnomeVFSMethod * method)

 {

     return;

 }

 char           *

 _parse_opt(char *opt)

 {

     char          **list = g_strsplit(opt, "opt=", 2);

     char          **opts = g_strsplit(list[1], "+", 32);

     char           *value = "";

     char           *aux;

     gint            i = 0;

     for (aux = opts[0]; aux != NULL; aux = opts[++i])

         value = g_strdup_printf("%s %s", value, aux);

     g_free(aux);

     g_strfreev(list);

     g_strfreev(opts);

     return value;

 }

 static UriArgs *

 _uri_parse_args(const GnomeVFSURI * uri)

 {

     gchar          *file = gnome_vfs_unescape_string(uri->text, NULL);

     gchar         **list = g_strsplit(file, "\'", 3);

     gchar         **prefix = g_strsplit_set(list[0], "/=", 3);

     gchar         **lst = g_strsplit(list[2], "?", 0);

     UriArgs        *info = g_new0(UriArgs, 1);

     gint            i = 1;

     gchar         **prop = NULL;

     prop = g_strsplit_set(lst[0], "/=", 3);

     info->file_name = g_strdup_printf("%s://%s", prefix[1], list[1]);

     // g_debug("FILENAME: [%s]", info->file_name);

     g_strfreev(prop);

     gchar          *walk;

     for (walk = lst[1]; walk != NULL; walk = lst[++i]) {

         prop = g_strsplit(walk, "=", 2);

         if (g_strv_length(prop) == 2) {

             if (strcmp(prop[0], "mux") == 0) {

                 info->mux = g_strdup(prop[1]);

             } else if (strcmp(prop[0], "vcodec") == 0) {

                 info->vcodec = g_strdup(prop[1]);

             } else if (strcmp(prop[0], "vbitrate") == 0) {

                 info->vbitrate = atoi(prop[1]);

             } else if (strcmp(prop[0], "fps") == 0) {

                 info->fps = g_strtod(prop[1], NULL);

             } else if (strcmp(prop[0], "acodec") == 0) {

                 info->acodec = g_strdup(prop[1]);

             } else if (strcmp(prop[0], "abitrate") == 0) {

                 info->abitrate = atoi(prop[1]);

             } else if (strcmp(prop[0], "width") == 0) {

                 info->width = atoi(prop[1]);

             } else if (strcmp(prop[0], "height") == 0) {

                 info->height = atoi(prop[1]);

             } else if (strcmp(prop[0], "opt") == 0) {

                 info->opt = g_strdup(_parse_opt(walk));

             }

         }

         g_strfreev(prop);

     }

     g_free(file);

     g_strfreev(list);

     g_strfreev(prefix);

     g_strfreev(lst);

     return info;

 }

 static          GnomeVFSResult

 do_open(GnomeVFSMethod * method,

         GnomeVFSMethodHandle ** method_handle,

         GnomeVFSURI * uri,

         GnomeVFSOpenMode mode, GnomeVFSContext * context)

 {

     gmsHandle      *handle = gmsHandle_new(uri);

     UriArgs        *args;

     if (!gmyth_stream_client_connect(handle->stream,

                                      gnome_vfs_uri_get_host_name(uri),

                                      gnome_vfs_uri_get_host_port(uri))) {

         return GNOME_VFS_ERROR_HOST_NOT_FOUND;

     }

     args = _uri_parse_args(uri);

     gint            ret = gmyth_stream_client_open_stream(handle->stream,

                                                           args->file_name,

                                                           args->mux,

                                                           args->vcodec,

                                                           args->vbitrate,

                                                           args->fps,

                                                           args->acodec,

                                                           args->abitrate,

                                                           args->width,

                                                           args->height,

                                                           args->opt);

     g_free(args);

     if (ret == -1) {

         gmyth_stream_client_disconnect(handle->stream);

         return GNOME_VFS_ERROR_HOST_NOT_FOUND;

     }

     handle->fd = gmyth_stream_client_play_stream(handle->stream);

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

         gmyth_stream_client_disconnect(handle->stream);

         return GNOME_VFS_ERROR_HOST_NOT_FOUND;

     }

     *method_handle = (GnomeVFSMethodHandle *) handle;

     return GNOME_VFS_OK;

 }

 static          GnomeVFSResult

 do_read(GnomeVFSMethod * method,

         GnomeVFSMethodHandle * method_handle,

         gpointer buffer,

         GnomeVFSFileSize bytes,

         GnomeVFSFileSize * bytes_read, GnomeVFSContext * context)

 {

     gint64          total_read = 0;

     gmsHandle      *handle = (gmsHandle *) method_handle;

     // g_debug("waiting something");

     total_read = recv(handle->fd, buffer, BUFFER_SIZE, 0);

     // g_debug("COULD READ: %d bytes", total_read);

     *bytes_read = (GnomeVFSFileSize) total_read;

     // if (total_read < 0) g_debug("ERROR!!!!!!!!!!!!!!!!");

     if (total_read < 0)

         return GNOME_VFS_ERROR_INTERNAL;

     else

         return GNOME_VFS_OK;

 }

 static          GnomeVFSResult

 do_close(GnomeVFSMethod * method,

          GnomeVFSMethodHandle * method_handle, GnomeVFSContext * context)

 {

     gmsHandle      *handle = (gmsHandle *) method_handle;

     g_debug("close close close");

     gmyth_stream_client_close_stream(handle->stream);

     gmyth_stream_client_disconnect(handle->stream);

     g_free(handle);

     return GNOME_VFS_OK;

 }

 static          GnomeVFSResult

 do_get_file_info(GnomeVFSMethod * method,

                  GnomeVFSURI * uri,

                  GnomeVFSFileInfo * file_info,

                  GnomeVFSFileInfoOptions options,

                  GnomeVFSContext * context)

 {

     file_info->valid_fields = GNOME_VFS_FILE_INFO_FIELDS_TYPE |

         GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS;

     file_info->type = GNOME_VFS_FILE_TYPE_SOCKET;

     file_info->permissions = GNOME_VFS_PERM_USER_READ |

         GNOME_VFS_PERM_OTHER_READ | GNOME_VFS_PERM_GROUP_READ;

     return GNOME_VFS_OK;

 }

 static          GnomeVFSResult

 do_get_file_info_from_handle(GnomeVFSMethod * method,

                              GnomeVFSMethodHandle * method_handle,

                              GnomeVFSFileInfo * file_info,

                              GnomeVFSFileInfoOptions options,

                              GnomeVFSContext * context)

 {

     file_info->valid_fields = GNOME_VFS_FILE_INFO_FIELDS_TYPE |

         GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS;

     file_info->type = GNOME_VFS_FILE_TYPE_SOCKET;

     file_info->permissions = GNOME_VFS_PERM_USER_READ |

         GNOME_VFS_PERM_OTHER_READ | GNOME_VFS_PERM_GROUP_READ;

     return GNOME_VFS_OK;

 }

 static          gboolean

 do_is_local(GnomeVFSMethod * method, const GnomeVFSURI * uri)

 {

     return FALSE;

 }