/*
 * @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)
{
}