/*

 * @author Hallyson Melo <hallyson.melo@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.

 *

 * 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 <string.h>

#include <glib.h>

#include <glib/gprintf.h>

#include <glib/gstdio.h>

#include <math.h>

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

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

#include <gmyth/gmyth_file.h>

#include <gmyth/gmyth_file_transfer.h>

#include <gmyth/gmyth_file_local.h>

#include <gmyth/gmyth_livetv.h>

#include <gmyth/gmyth_uri.h>

#include <gmyth/gmyth_recorder.h>

#include <gmyth/gmyth_backendinfo.h>

#include <gmyth/gmyth_util.h>

#include <gmyth/gmyth_remote_util.h>

#include <gmyth/gmyth_tvchain.h>

#include <gmyth/gmyth_programinfo.h>

#define GST_MYTHTV_ID_NUM               1

#define MYTHTV_VERSION_DEFAULT          30

#define MYTHTV_TRANSFER_MAX_WAITS       100

/*

 * internal GnomeVFS plug-in buffer size ( 120 Kbytes ) 

 */

#define MYTHTV_BUFFER_SIZE                          80*1024

/*

 * internally sized GnomeVFS plug-in buffer ( 4 Kbytes ) 

 */

#define MYTHTV_MAX_VFS_BUFFER_SIZE                  4096

/*

 * maximum number of bytes to be requested to the MythTV backend ( 64

 * Kbytes ) 

 */

#define MYTHTV_MAX_REQUEST_SIZE                     64*1024

typedef struct {

    GMythFile      *file;

    GMythLiveTV    *livetv;

    GMythBackendInfo *backend_info;

    GMythURI       *gmyth_uri;

    GMythRecorder  *live_recorder;

    gboolean        started;

    gint64          offset;

    gboolean        is_livetv;  /* it is, or not a Live TV content

                                 * transfer */

    gboolean        is_local_file;  /* tell if the file is local to the

                                     * current content transfer */

    gchar          *channel_name;

    gint            mythtv_version;

    gboolean        configured;

} MythtvHandle;

static GnomeVFSResult do_read(GnomeVFSMethod * method,

                              GnomeVFSMethodHandle * method_handle,

                              gpointer buffer,

                              GnomeVFSFileSize num_bytes,

                              GnomeVFSFileSize * bytes_read,

                              GnomeVFSContext * context);

static GnomeVFSResult myth_connection_start(MythtvHandle * method_handle);

static void     myth_destroy_handle(MythtvHandle * method_handle);

static GnomeVFSResult myth_handle_new(GnomeVFSURI * uri,

                                      MythtvHandle ** method_handle);

static GnomeVFSResult myth_get_file_info(MythtvHandle * myth_handle,

                                         GnomeVFSURI * uri,

                                         GnomeVFSFileInfo * info);

static          GnomeVFSResult

myth_handle_new(GnomeVFSURI * uri, MythtvHandle ** method_handle)

{

    gchar          *tmp_str1;

    gchar          *tmp_str2;

    _GNOME_VFS_METHOD_PARAM_CHECK(*method_handle == NULL);

    if (gnome_vfs_uri_get_host_name(uri) == NULL) {

        return GNOME_VFS_ERROR_INVALID_HOST_NAME;

    }

    *method_handle = g_new0(MythtvHandle, 1);

    (*method_handle)->mythtv_version = MYTHTV_VERSION_DEFAULT;

    (*method_handle)->is_livetv = FALSE;

    (*method_handle)->is_local_file = FALSE;

    tmp_str1 = gnome_vfs_uri_to_string(uri, GNOME_VFS_URI_HIDE_NONE);

    tmp_str2 = gnome_vfs_unescape_string(tmp_str1, "");

    gchar          *tmp_str3 = strstr(tmp_str2, ".nuv.avi");

    if (tmp_str3 != NULL) {

        tmp_str3[4] = '\0';

    }

    (*method_handle)->backend_info =

        gmyth_backend_info_new_with_uri(tmp_str2);

    (*method_handle)->gmyth_uri = gmyth_uri_new_with_value(tmp_str2);

    g_free(tmp_str1);

    g_free(tmp_str2);

    return GNOME_VFS_OK;

}

static void

myth_destroy_handle(MythtvHandle * method_handle)

{

    // TODO: abort if in tranfer state

    if (method_handle->backend_info != NULL) {

        g_object_unref(method_handle->backend_info);

        method_handle->backend_info = NULL;

    }

    if (method_handle->channel_name != NULL) {

        g_free(method_handle->channel_name);

        method_handle->channel_name = NULL;

    }

    if (method_handle->livetv != NULL) {

        g_object_unref(method_handle->livetv);

        method_handle->livetv = NULL;

    }

    if (method_handle->file != NULL) {

        g_object_unref(method_handle->file);

        method_handle->file = NULL;

    }

    if (method_handle->gmyth_uri != NULL) {

        g_object_unref(method_handle->gmyth_uri);

        method_handle->gmyth_uri = NULL;

    }

    g_free(method_handle);

}

static          GnomeVFSResult

myth_get_file_info(MythtvHandle * myth_handle,

                   GnomeVFSURI * uri, GnomeVFSFileInfo * info)

{

    GMythURI       *gmyth_uri;

    GMythBackendInfo *backend_info;

    gboolean        is_livetv;

    gboolean        is_local;

    _GNOME_VFS_METHOD_PARAM_CHECK(info != NULL);

    g_debug("%s - %d", __FUNCTION__, __LINE__);

    if (myth_handle == NULL) {

        gchar          *tmp_str1;

        gchar          *tmp_str2;

        tmp_str1 = gnome_vfs_uri_to_string(uri, GNOME_VFS_URI_HIDE_NONE);

        tmp_str2 = gnome_vfs_unescape_string(tmp_str1, "");

        backend_info = gmyth_backend_info_new_with_uri(tmp_str2);

        gmyth_uri = gmyth_uri_new_with_value(tmp_str2);

        g_free(tmp_str1);

        g_free(tmp_str2);

    } else {

        backend_info = g_object_ref(myth_handle->backend_info);

        gmyth_uri = g_object_ref(myth_handle->gmyth_uri);

    }

    info->valid_fields = 0;

    info->valid_fields = GNOME_VFS_FILE_INFO_FIELDS_TYPE |

        GNOME_VFS_FILE_INFO_FIELDS_MIME_TYPE |

        GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS;

    info->type = GNOME_VFS_FILE_TYPE_REGULAR;

    /*

     * fixme: get from file extension? 

     */

    info->mime_type = g_strdup("video/x-nuv");

    info->permissions = GNOME_VFS_PERM_USER_READ |

        GNOME_VFS_PERM_OTHER_READ | GNOME_VFS_PERM_GROUP_READ;

    info->name = g_strdup(gmyth_uri_get_path(gmyth_uri));

    /*

     * file size for remote files 

     */

    is_livetv = gmyth_uri_is_livetv(gmyth_uri);

    if (is_livetv == FALSE) {

        GMythFile      *file = NULL;

        gboolean        ret = FALSE;

        /*

         * Verifies if the file exists 

         */

        if (!gmyth_util_file_exists(backend_info,

                                    gmyth_uri_get_path(gmyth_uri))) {

            g_object_unref(file);

            g_object_unref(backend_info);

            g_debug("NOT FOUND %s/%d", __FUNCTION__, __LINE__);

            return GNOME_VFS_ERROR_NOT_FOUND;

        }

        is_local = gmyth_uri_is_local_file(gmyth_uri);

        if (is_local == TRUE) {

            file = GMYTH_FILE(gmyth_file_local_new(backend_info));

            ret = gmyth_file_local_open(GMYTH_FILE_LOCAL(file));

        } else {

            file = GMYTH_FILE(gmyth_file_transfer_new(backend_info));

            ret = gmyth_file_transfer_open(GMYTH_FILE_TRANSFER(file),

                                           gmyth_uri_get_path(gmyth_uri));

        }

        if (!ret) {

            g_object_unref(file);

            g_object_unref(backend_info);

            g_debug("NOT FOUND %s/%d", __FUNCTION__, __LINE__);

            return GNOME_VFS_ERROR_NOT_FOUND;

        }

        info->size = gmyth_file_get_filesize(file);

        info->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_SIZE;

        g_object_unref(file);

    }

    g_object_unref(backend_info);

    g_object_unref(gmyth_uri);

    return GNOME_VFS_OK;

}

static          GnomeVFSResult

myth_connection_start(MythtvHandle * method_handle)

{

    GnomeVFSResult  result = GNOME_VFS_OK;

    _GNOME_VFS_METHOD_PARAM_CHECK(method_handle != NULL);

    _GNOME_VFS_METHOD_PARAM_CHECK(method_handle->backend_info != NULL);

    /*

     * Connect to the backend 

     */

    if ((method_handle->is_livetv =

         gmyth_uri_is_livetv(method_handle->gmyth_uri)) == TRUE) {

        method_handle->livetv =

            gmyth_livetv_new(method_handle->backend_info);

        method_handle->channel_name =

            gmyth_uri_get_channel_name(method_handle->gmyth_uri);

        if (method_handle->channel_name != NULL) {

            if (gmyth_livetv_channel_name_setup(method_handle->livetv,

                                                method_handle->

                                                channel_name) == FALSE) {

                result = GNOME_VFS_ERROR_INVALID_URI;

                goto error;

            }

        } else if (gmyth_livetv_setup(method_handle->livetv) == FALSE) {

            result = GNOME_VFS_ERROR_INVALID_URI;

            goto error;

        }

        method_handle->file =

            GMYTH_FILE(gmyth_livetv_create_file_transfer

                       (method_handle->livetv));

        if (method_handle->file == NULL) {

            result = GNOME_VFS_ERROR_INVALID_URI;

            g_debug("MythTV FileTransfer is NULL!\n");

            goto error;

        }

        if (!gmyth_file_transfer_open

            (GMYTH_FILE_TRANSFER(method_handle->file),

             method_handle->livetv->uri !=

             NULL ? gmyth_uri_get_path(method_handle->livetv->

                                       uri) : method_handle->livetv->

             proginfo->pathname->str)) {

            g_debug("Couldn't open MythTV FileTransfer is NULL!\n");

            result = GNOME_VFS_ERROR_NOT_OPEN;

            goto error;

        }

    } else {

        gboolean        ret = TRUE;

        /*

         * Verifies if the file exists 

         */

        if (!gmyth_util_file_exists(method_handle->backend_info,

                                    gmyth_uri_get_path(method_handle->

                                                       gmyth_uri))) {

            g_debug("NOT FOUND %s/%d", __FUNCTION__, __LINE__);

            goto error;

        }

        if ((method_handle->is_local_file =

             gmyth_uri_is_local_file(method_handle->gmyth_uri)) == TRUE) {

            method_handle->file =

                GMYTH_FILE(gmyth_file_local_new

                           (method_handle->backend_info));

            ret =

                gmyth_file_local_open(GMYTH_FILE_LOCAL

                                      (method_handle->file));

        } else {

            method_handle->file =

                GMYTH_FILE(gmyth_file_transfer_new

                           (method_handle->backend_info));

            ret =

                gmyth_file_transfer_open(GMYTH_FILE_TRANSFER

                                         (method_handle->file),

                                         gmyth_uri_get_path(method_handle->

                                                            gmyth_uri));

        }

        /*

         * sets the Playback monitor connection 

         */

        if (!ret) {

            g_debug("NOT FOUND %s/%d", __FUNCTION__, __LINE__);

            result = GNOME_VFS_ERROR_NOT_FOUND;

            goto error;

        }

    }                           /* if - LiveTV or not? */

    method_handle->configured = TRUE;

    if (method_handle->file == NULL) {

        result = GNOME_VFS_ERROR_NOT_OPEN;

    }

  error:

    return result;

}

static          GnomeVFSResult

do_open(GnomeVFSMethod * method,

        GnomeVFSMethodHandle ** method_handle,

        GnomeVFSURI * uri, GnomeVFSOpenMode mode,

        GnomeVFSContext * context)

{

    MythtvHandle   *myth_handle = NULL;

    GnomeVFSResult  result = GNOME_VFS_OK;

    _GNOME_VFS_METHOD_PARAM_CHECK(method_handle != NULL);

    _GNOME_VFS_METHOD_PARAM_CHECK(uri != NULL);

    if (mode & GNOME_VFS_OPEN_WRITE) {

        return GNOME_VFS_ERROR_INVALID_OPEN_MODE;

    }

    result = myth_handle_new(uri, &myth_handle);

    if (result != GNOME_VFS_OK)

        return result;

    result = myth_connection_start(myth_handle);

    if (result != GNOME_VFS_OK) {

        myth_destroy_handle(myth_handle);

        myth_handle = NULL;

        return result;

    }

    *method_handle = (GnomeVFSMethodHandle *) myth_handle;

    return result;

}

static          GnomeVFSResult

do_create(GnomeVFSMethod * method,

          GnomeVFSMethodHandle ** method_handle,

          GnomeVFSURI * uri,

          GnomeVFSOpenMode mode,

          gboolean exclusive, guint perm, GnomeVFSContext * context)

{

    return GNOME_VFS_ERROR_NOT_SUPPORTED;

}

static          GnomeVFSResult

do_close(GnomeVFSMethod * method,

         GnomeVFSMethodHandle * method_handle, GnomeVFSContext * context)

{

    MythtvHandle   *myth_handle = (MythtvHandle *) method_handle;

    myth_destroy_handle(myth_handle);

    return GNOME_VFS_OK;

}

static          GnomeVFSResult

do_read(GnomeVFSMethod * method,

        GnomeVFSMethodHandle * method_handle,

        gpointer buffer,

        GnomeVFSFileSize num_bytes,

        GnomeVFSFileSize * bytes_read, GnomeVFSContext * context)

{

    GnomeVFSResult  retval = GNOME_VFS_OK;

    MythtvHandle   *myth_handle;

    GMythFileReadResult result;

    GByteArray     *myth_buffer = g_byte_array_new();

    _GNOME_VFS_METHOD_PARAM_CHECK(method_handle != NULL);

    myth_handle = (MythtvHandle *) method_handle;

    if (myth_handle->is_local_file)

        result = gmyth_file_local_read(GMYTH_FILE_LOCAL(myth_handle->file),

                                       myth_buffer,

                                       num_bytes, myth_handle->is_livetv);

    else

        result =

            gmyth_file_transfer_read(GMYTH_FILE_TRANSFER

                                     (myth_handle->file), myth_buffer,

                                     num_bytes, myth_handle->is_livetv);

    if (result == GMYTH_FILE_READ_ERROR) {

        retval = GNOME_VFS_ERROR_IO;

    }

    if (result == GMYTH_FILE_READ_EOF) {

        retval = GNOME_VFS_ERROR_EOF;

    }

    if (myth_buffer->len > 0) {

        g_memmove(buffer, myth_buffer->data, myth_buffer->len);

        *bytes_read = (GnomeVFSFileSize) myth_buffer->len;

        myth_handle->offset += myth_buffer->len;

        g_byte_array_free(myth_buffer, TRUE);

    }

    return retval;

}

static          GnomeVFSResult

do_write(GnomeVFSMethod * method,

         GnomeVFSMethodHandle * method_handle,

         gconstpointer buffer,

         GnomeVFSFileSize num_bytes,

         GnomeVFSFileSize * bytes_written, GnomeVFSContext * context)

{

    return GNOME_VFS_ERROR_NOT_SUPPORTED;

}

static          GnomeVFSResult

do_seek(GnomeVFSMethod * method,

        GnomeVFSMethodHandle * method_handle,

        GnomeVFSSeekPosition whence,

        GnomeVFSFileOffset offset, GnomeVFSContext * context)

{

    MythtvHandle   *myth_handle;

    guint64         whence_p = 0;

    gint64          new_offset = 0;

    _GNOME_VFS_METHOD_PARAM_CHECK(method_handle != NULL);

    myth_handle = (MythtvHandle *) method_handle;

    g_debug("seek offset %" G_GINT64_FORMAT " whence %d", offset, whence);

    if (gmyth_uri_is_livetv(myth_handle->gmyth_uri))

        return GNOME_VFS_ERROR_NOT_SUPPORTED;

    switch (whence) {

    case GNOME_VFS_SEEK_START:

        whence_p = 0;

        break;

    case GNOME_VFS_SEEK_CURRENT:

        whence_p = myth_handle->offset;

        break;

    case GNOME_VFS_SEEK_END:

        return GNOME_VFS_ERROR_NOT_SUPPORTED;

    }

    new_offset =

        gmyth_file_transfer_seek(myth_handle->file, offset, whence_p);

    if (new_offset != 0) {

        myth_handle->offset = new_offset;

        return GNOME_VFS_OK;

    }

    return GNOME_VFS_ERROR_NOT_SUPPORTED;

}

static          GnomeVFSResult

do_tell(GnomeVFSMethod * method,

        GnomeVFSMethodHandle * method_handle,

        GnomeVFSFileSize * offset_return)

{

    MythtvHandle   *myth_handle = NULL;

    _GNOME_VFS_METHOD_PARAM_CHECK(method_handle != NULL);

    myth_handle = (MythtvHandle *) method_handle;

    *offset_return = myth_handle->offset;

    return GNOME_VFS_OK;

}

static          GnomeVFSResult

do_truncate_handle(GnomeVFSMethod * method,

                   GnomeVFSMethodHandle * method_handle,

                   GnomeVFSFileSize where, GnomeVFSContext * context)

{

    return GNOME_VFS_ERROR_READ_ONLY;

}

static          GnomeVFSResult

do_open_directory(GnomeVFSMethod * method,

                  GnomeVFSMethodHandle ** method_handle,

                  GnomeVFSURI * uri,

                  GnomeVFSFileInfoOptions options,

                  GnomeVFSContext * context)

{

    return GNOME_VFS_ERROR_NOT_SUPPORTED;

}

static          GnomeVFSResult

do_close_directory(GnomeVFSMethod * method,

                   GnomeVFSMethodHandle * method_handle,

                   GnomeVFSContext * context)

{

    return GNOME_VFS_ERROR_NOT_SUPPORTED;

}

static          GnomeVFSResult

do_read_directory(GnomeVFSMethod * method,

                  GnomeVFSMethodHandle * method_handle,

                  GnomeVFSFileInfo * file_info, GnomeVFSContext * context)

{

    return GNOME_VFS_ERROR_NOT_SUPPORTED;

}

static          GnomeVFSResult

do_get_file_info(GnomeVFSMethod * method,

                 GnomeVFSURI * uri,

                 GnomeVFSFileInfo * file_info,

                 GnomeVFSFileInfoOptions options,

                 GnomeVFSContext * context)

{

    return myth_get_file_info(NULL, uri, file_info);

}

static          GnomeVFSResult

do_get_file_info_from_handle(GnomeVFSMethod * method,

                             GnomeVFSMethodHandle * method_handle,

                             GnomeVFSFileInfo * file_info,

                             GnomeVFSFileInfoOptions options,

                             GnomeVFSContext * context)

{

    MythtvHandle   *myth_handle = (MythtvHandle *) method_handle;

    return myth_get_file_info(myth_handle, NULL, file_info);

}

static          gboolean

do_is_local(GnomeVFSMethod * method, const GnomeVFSURI * uri)

{

    return FALSE;

}

static          GnomeVFSResult

do_make_directory(GnomeVFSMethod * method,

                  GnomeVFSURI * uri, guint perm, GnomeVFSContext * context)

{

    return GNOME_VFS_ERROR_READ_ONLY;

}

static          GnomeVFSResult

do_remove_directory(GnomeVFSMethod * method,

                    GnomeVFSURI * uri, GnomeVFSContext * context)

{

    return GNOME_VFS_ERROR_READ_ONLY;

}

static          GnomeVFSResult

do_move(GnomeVFSMethod * method,

        GnomeVFSURI * old_uri,

        GnomeVFSURI * new_uri,

        gboolean force_replace, GnomeVFSContext * context)

{

    return GNOME_VFS_ERROR_READ_ONLY;

}

static          GnomeVFSResult

do_unlink(GnomeVFSMethod * method,

          GnomeVFSURI * uri, GnomeVFSContext * context)

{

    return GNOME_VFS_ERROR_READ_ONLY;

}

static          GnomeVFSResult

do_check_same_fs(GnomeVFSMethod * method,

                 GnomeVFSURI * a,

                 GnomeVFSURI * b,

                 gboolean * same_fs_return, GnomeVFSContext * context)

{

    return GNOME_VFS_ERROR_NOT_SUPPORTED;

}

static          GnomeVFSResult

do_set_file_info(GnomeVFSMethod * method,

                 GnomeVFSURI * uri,

                 const GnomeVFSFileInfo * info,

                 GnomeVFSSetFileInfoMask mask, GnomeVFSContext * context)

{

    return GNOME_VFS_ERROR_READ_ONLY;

}

static          GnomeVFSResult

do_truncate(GnomeVFSMethod * method,

            GnomeVFSURI * uri,

            GnomeVFSFileSize where, GnomeVFSContext * context)

{

    return GNOME_VFS_ERROR_READ_ONLY;

}

static          GnomeVFSResult

do_find_directory(GnomeVFSMethod * method,

                  GnomeVFSURI * near_uri,

                  GnomeVFSFindDirectoryKind kind,

                  GnomeVFSURI ** result_uri,

                  gboolean create_if_needed,

                  gboolean find_if_needed,

                  guint permissions, GnomeVFSContext * context)

{

    return GNOME_VFS_ERROR_NOT_SUPPORTED;

}

static          GnomeVFSResult

do_create_symbolic_link(GnomeVFSMethod * method,

                        GnomeVFSURI * uri,

                        const char *target_reference,

                        GnomeVFSContext * context)

{

    return GNOME_VFS_ERROR_READ_ONLY;

}

static          GnomeVFSResult

do_monitor_add(GnomeVFSMethod * method,

               GnomeVFSMethodHandle ** method_handle_return,

               GnomeVFSURI * uri, GnomeVFSMonitorType monitor_type)

{

    return GNOME_VFS_ERROR_NOT_SUPPORTED;

}

static          GnomeVFSResult

do_monitor_cancel(GnomeVFSMethod * method,

                  GnomeVFSMethodHandle * method_handle)

{

    return GNOME_VFS_ERROR_NOT_SUPPORTED;

}

static          GnomeVFSResult

do_file_control(GnomeVFSMethod * method,

                GnomeVFSMethodHandle * method_handle,

                const char *operation,

                gpointer operation_data, GnomeVFSContext * context)

{

    return GNOME_VFS_ERROR_NOT_SUPPORTED;

}

static GnomeVFSMethod method = {

    sizeof(GnomeVFSMethod),

    do_open,

    do_create,

    do_close,

    do_read,

    do_write,

    do_seek,

    do_tell,

    do_truncate_handle,

    do_open_directory,

    do_close_directory,

    do_read_directory,

    do_get_file_info,

    do_get_file_info_from_handle,

    do_is_local,

    do_make_directory,

    do_remove_directory,

    do_move,

    do_unlink,

    do_check_same_fs,

    do_set_file_info,

    do_truncate,

    do_find_directory,

    do_create_symbolic_link,

    do_monitor_add,

    do_monitor_cancel,

    do_file_control

};

GnomeVFSMethod *

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

{

    return &method;

}

void

vfs_module_shutdown(GnomeVFSMethod * method)

{

}