/*

  * Copyright (C) 2016  J. Ali Harlow <ali@juiblex.co.uk>

  *

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

  * it under the terms of the GNU 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 General Public License along

  * with this program; if not, write to the Free Software Foundation, Inc.,

  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

  */

 #include <stdlib.h>

 #include <string.h>

 #include <errno.h>

 #include <razor.h>

 #include <glib.h>

 #include <gio/gio.h>

 #include "config.h"

 #include "plover/plover.h"

 static GList *open_razor_files;

 static gboolean has_valid_scheme(const char *uri)

 {

     /*

      * RFC 2396 defines valid schemes as:

      * scheme = alpha *( alpha | digit | "+" | "-" | "." )

      */

     const char *s;

     if (!g_ascii_isalpha(*uri))

 	return FALSE;

     for(s=uri+1;;s++)

 	if (*s==':')

 	    return TRUE;

 	else if (!g_ascii_isalnum(*s) && *s!='+' && *s!='-' && *s!='.')

 	    return FALSE;

 }

 static GFile *file_for_uri(const char *uri)

 {

     GFile *file;

     if (!has_valid_scheme(uri))

     {

 	g_warning("%s: Not a valid URI",uri);

 	file=g_file_new_for_path(uri);

     }

     else

     {

 	if (strstr(uri+1,"file:/"))

 	    g_warning("%s: Implausible URI",uri);

 	file=g_file_new_for_uri(uri);

     }

     return file;

 }

 int file_mkdir(const char *uri,mode_t mode,struct razor_error **error)

 {

     GFile *file;

     GFileInfo *info;

     gchar *path;

     int retval;

     GError *err=NULL;

     g_message("file_mkdir(%s)",uri);

     file=file_for_uri(uri);

     path=g_file_get_path(file);

     if (path)

     {

 	retval=razor_file_default_mkdir(path,mode,error);

 	g_free(path);

     }

     else if (!g_file_make_directory(file,NULL,&err))

     {

 	retval=-1;

 	if (g_error_matches(err,G_IO_ERROR,G_IO_ERROR_EXISTS))

 	{

 	    info=g_file_query_info(file,G_FILE_ATTRIBUTE_STANDARD_TYPE,

 	      G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,NULL,NULL);

 	    if (info)

 	    {

 		g_clear_error(&err);

 		if (g_file_info_get_file_type(info)==G_FILE_TYPE_DIRECTORY)

 		    retval=0;

 		else

 		    razor_set_error(error,RAZOR_POSIX_ERROR,EEXIST,uri,

 		      "Not a directory");

 		g_object_unref(info);

 	    }

 	}

 	if (err)

 	    plover_propagate_g_error(error,err);

     }

     else

 	retval=0;

     g_object_unref(file);

     return retval;

 }

 int file_unlink(const char *uri,struct razor_error **error)

 {

     GFile *file;

     gchar *path;

     int retval;

     GError *err=NULL;

     g_message("file_unlink(%s)",uri);

     file=file_for_uri(uri);

     path=g_file_get_path(file);

     if (path)

     {

 	retval=razor_file_default_unlink(path,error);

 	g_free(path);

     }

     else if (!g_file_delete(file,NULL,&err))

     {

 	plover_propagate_g_error(error,err);

 	retval=-1;

     }

     else

 	retval=0;

     g_object_unref(file);

     return retval;

 }

 int file_open(const char *uri,int flags,mode_t mode,struct razor_error **error)

 {

     GFile *file;

     gchar *path;

     int retval;

     GError *err=NULL;

     g_message("file_open(%s)",uri);

     file=file_for_uri(uri);

     path=g_file_get_path(file);

     if (path)

     {

 	retval=razor_file_default_open(path,flags,mode,error);

 	g_free(path);

     }

     else

     {

 	razor_set_error(error,RAZOR_GENERAL_ERROR,RAZOR_GENERAL_ERROR_FAILED,

 	  uri,"File is not local");

 	retval=-1;

     }

     g_object_unref(file);

     return retval;

 }

 int file_move(const char *src_uri,const char *dst_uri,

   struct razor_error **error)

 {

     GFile *src,*dst;

     gchar *src_path,*dst_path;

     int retval;

     GError *err=NULL;

     g_message("file_move(%s,%s)",src_uri,dst_uri);

     src=file_for_uri(src_uri);

     dst=file_for_uri(dst_uri);

     src_path=g_file_get_path(src);

     dst_path=g_file_get_path(dst);

     if (src_path && dst_path)

 	retval=razor_file_default_move(src_path,dst_path,error);

     else if (!g_file_move(src,dst,G_FILE_COPY_OVERWRITE,NULL,NULL,NULL,&err))

     {

 	plover_propagate_g_error(error,err);

 	retval=-1;

     }

     else

 	retval=0;

     g_free(src_path);

     g_free(dst_path);

     g_object_unref(src);

     g_object_unref(dst);

     return retval;

 }

 static void *file_get_contents(const char *uri,size_t *length,int private,

   struct razor_error **error)

 {

     GFile *file;

     gchar *path;

     void *addr;

     char *contents;

     gsize len;

     GError *err=NULL;

     g_message("file_get_contents(%s)",uri);

     file=file_for_uri(uri);

     path=g_file_get_path(file);

     if (path)

     {

 	g_object_unref(file);

 	addr=razor_file_default_get_contents(path,length,private,error);

 	if (addr)

 	    open_razor_files=g_list_prepend(open_razor_files,addr);

 	g_free(path);

     }

     else if (!g_file_load_contents(file,NULL,&contents,&len,NULL,&err))

     {

 	plover_propagate_g_error(error,err);

 	g_object_unref(file);

 	addr=NULL;

     }

     else

     {

 	g_object_unref(file);

 	addr=contents;

 	if (length)

 	    *length=len;

     }

     return addr;

 }

 static int file_free_contents(void *addr,size_t length)

 {

     int retval;

     GList *lnk;

     g_message("file_free_contents(%p)",addr);

     lnk=g_list_find(open_razor_files,addr);

     if (lnk)

     {

 	open_razor_files=g_list_delete_link(open_razor_files,lnk);

 	retval=razor_file_default_free_contents(addr,length);

     }

     else

     {

 	g_free(addr);

 	retval=0;

     }

     return retval;

 }

 int file_is_directory(const char *uri,struct razor_error **error)

 {

     GFile *file;

     GFileInfo *info;

     gchar *path;

     int retval;

     GError *err=NULL;

     g_message("file_is_directory(%s)",uri);

     file=file_for_uri(uri);

     path=g_file_get_path(file);

     if (path)

     {

 	retval=razor_file_default_is_directory(path,error);

 	g_free(path);

     }

     else

     {

 	info=g_file_query_info(file,G_FILE_ATTRIBUTE_STANDARD_TYPE,

 	  G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,NULL,&err);

 	if (info)

 	{

 	    if (g_file_info_get_file_type(info)==G_FILE_TYPE_DIRECTORY)

 		retval=1;

 	    else

 		retval=0;

 	    g_object_unref(info);

 	}

 	else

 	{

 	    retval=-1;

 	    plover_propagate_g_error(error,err);

 	}

     }

     g_object_unref(file);

     return retval;

 }

 char *file_mkdtemp_near(const char *uri,const char *template,

   struct razor_error **error)

 {

     GFile *file;

     gchar *path,*tmpuri;

     char *tmppath,*retval;

     GError *err=NULL;

     g_message("file_mkdtemp_near(%s)",uri);

     file=file_for_uri(uri);

     path=g_file_get_path(file);

     g_object_unref(file);

     if (path)

     {

 	tmppath=razor_file_default_mkdtemp_near(path,template,error);

 	g_free(path);

 	if (tmppath)

 	{

 	    file=g_file_new_for_path(tmppath);

 	    tmpuri=g_file_get_uri(file);

 	    g_object_unref(file);

 	    retval=strdup(tmpuri);

 	    g_free(tmpuri);

 	}

 	else

 	    retval=NULL;

     }

     else

     {

 	razor_set_error(error,RAZOR_GENERAL_ERROR,RAZOR_GENERAL_ERROR_FAILED,

 	  uri,"File is not local");

 	retval=NULL;

     }

     return retval;

 }

 struct file_dir {

     void *razor_file_default;

     GFileEnumerator *enumerator;

 };

 void *file_opendir(const char *uri,struct razor_error **error)

 {

     GFile *file;

     gchar *path;

     struct file_dir *dir;

     GError *err=NULL;

     g_message("file_opendir(%s)",uri);

     dir=g_new0(struct file_dir,1);

     file=file_for_uri(uri);

     path=g_file_get_path(file);

     if (path)

     {

 	dir->razor_file_default=razor_file_default_opendir(path,error);

 	if (!dir->razor_file_default)

 	{

 	    g_free(dir);

 	    dir=NULL;

 	}

 	g_free(path);

     }

     else

     {

 	dir->enumerator=g_file_enumerate_children(file,

 	  G_FILE_ATTRIBUTE_STANDARD_NAME,G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,

 	  NULL,&err);

 	if (!dir->enumerator)

 	{

 	    g_free(dir);

 	    dir=NULL;

 	    plover_propagate_g_error(error,err);

 	}

     }

     g_object_unref(file);

     return dir;

 }

 char *file_readdir(void *dp,struct razor_error **error)

 {

     struct file_dir *dir=dp;

     char *name;

     GError *err=NULL;

     GFileInfo *info;

     g_message("file_readdir(%p)",dp);

     if (dir->razor_file_default)

 	name=razor_file_default_readdir(dir->razor_file_default,error);

     else

     {

 	info=g_file_enumerator_next_file(dir->enumerator,NULL,&err);

 	if (!info)

 	{

 	    name=NULL;

 	    plover_propagate_g_error(error,err);

 	}

 	else

 	{

 	    name=strdup(g_file_info_get_name(info));

 	    g_object_unref(info);

 	}

     }

     return name;

 }

 int file_closedir(void *dp,struct razor_error **error)

 {

     struct file_dir *dir=dp;

     int retval;

     GError *err=NULL;

     g_message("file_closedir(%p)",dp);

     if (dir->razor_file_default)

 	retval=razor_file_default_closedir(dir->razor_file_default,error);

     else

     {

 	retval=g_file_enumerator_close(dir->enumerator,NULL,&err)?0:-1;

 	if (retval)

 	    plover_propagate_g_error(error,err);

 	g_object_unref(dir->enumerator);

     }

     g_free(dir);

     return retval;

 }

 void plover__file_io_init(void)

 {

     static gsize init=0;

     struct razor_file_vtable file_vtable={0,};

     g_message("plover__file_io_init()");

     if (g_once_init_enter(&init))

     {

 	file_vtable.structure_size=sizeof(file_vtable);

 	file_vtable.mkdir=file_mkdir;

 	file_vtable.unlink=file_unlink;

 	file_vtable.open=file_open;

 	file_vtable.move=file_move;

 	file_vtable.get_contents=file_get_contents;

 	file_vtable.free_contents=file_free_contents;

 	file_vtable.is_directory=file_is_directory;

 	file_vtable.mkdtemp_near=file_mkdtemp_near;

 	file_vtable.opendir=file_opendir;

 	file_vtable.readdir=file_readdir;

 	file_vtable.closedir=file_closedir;

 	razor_file_set_vtable(&file_vtable);

 	g_once_init_leave(&init,1);

     }

 }