/*
 * vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
 */
#include "e.h"

#ifdef EFM_DEBUG
# define D(x)  do {printf(__FILE__ ":%d:  ", __LINE__); printf x; fflush(stdout);} while (0)
#else
# define D(x)  ((void) 0)
#endif

/* local subsystem functions */
static void _e_fm_file_free(E_Fm_File *file);

/* TODO Make init and shutdown func that populates the assoc */
static E_Config_DD *assoc_app_edd = NULL;
static Evas_List   *assoc_apps = NULL;

/* externally accessible functions */
EAPI E_Fm_File *
e_fm_file_new(const char *filename)
{
   char *ext;
   E_Fm_File *file;
   struct stat st;

   if (stat(filename, &st) == -1) return NULL;
   /* FIXME: stat above will fail if the file is a BROKEN SYMLINK - maybe we
    * should not fail, but do an lstat here and see if it is a symlink (or
    * just a race condition where the file was deleted as we scan), and
    * if so mark it as a broken synlink. we should do an lstat ANYWAY
    * so we know if a file is a symlink or not regardless what it points
    * to.
    */
   file = E_OBJECT_ALLOC(E_Fm_File, E_FM_FILE_TYPE, _e_fm_file_free);
   if (!file) return NULL;
   file->path = strdup(filename);
   if (!file->path) goto error;
   file->name = strdup(ecore_file_get_file((char *)filename));
   if (!file->name) goto error;
   /* Get attributes */
   file->device = st.st_dev;
   file->inode = st.st_ino;
   file->mode = st.st_mode;
   file->nlink = st.st_nlink;
   file->owner = st.st_uid;
   file->group = st.st_gid;
   file->rdev = st.st_rdev;
   file->size = st.st_size;
   file->atime = st.st_atime;
   file->mtime = st.st_mtime;
   file->ctime = st.st_ctime;

   if (S_ISDIR(file->mode))
      file->type |= E_FM_FILE_TYPE_DIRECTORY;
   else if (S_ISREG(file->mode))
     file->type = E_FM_FILE_TYPE_FILE;
   else if (S_ISLNK(file->mode))
     file->type = E_FM_FILE_TYPE_SYMLINK;
   else
     file->type = E_FM_FILE_TYPE_UNKNOWN;

   if (file->name[0] == '.')
     file->type |= E_FM_FILE_TYPE_HIDDEN;

   
   e_fm_mime_set(file);
   D(("e_fm_file_new: %s\n", filename));
   return file;

   error:
   if (file->path) free(file->path);
   if (file->name) free(file->name);
   free(file);
   return NULL;
}

EAPI int
e_fm_file_rename(E_Fm_File *file, const char *name)
{
   char path[PATH_MAX], *dir;

   if ((!name) || (!name[0])) return 0;

   dir = ecore_file_get_dir(file->path);
   if (!dir) return 0;
   snprintf(path, sizeof(path), "%s/%s", dir, name);

   if (ecore_file_mv(file->path, path))
     {
  free(file->path);
  file->path = strdup(path);
  free(file->name);
  file->name = strdup(name);
  D(("e_fm_file_rename: ok (%p) (%s)\n", file, name));
  return 1;
     }
   else
     {
  D(("e_fm_file_rename: fail (%p) (%s)\n", file, name));
  return 0;
     }
}

EAPI int
e_fm_file_delete(E_Fm_File *file)
{
   if (ecore_file_recursive_rm(file->path))
     {
  free(file->path);
  file->path = NULL;
  free(file->name);
  file->name = NULL;
  D(("e_fm_file_delete: ok (%p) (%s)\n", file, file->name));
  return 1;
     }
   else
     {
  D(("e_fm_file_delete: fail (%p) (%s)\n", file, file->name));
  return 0;
     }
}

EAPI int
e_fm_file_copy(E_Fm_File *file, const char *name)
{
   if ((!name) || (!name[0])) return 0;

   if (ecore_file_cp(file->path, name))
     {
  free(file->path);
  file->path = strdup(name);
  free(file->name);
  file->name = strdup(ecore_file_get_file(name));
  D(("e_fm_file_copy: ok (%p) (%s)\n", file, name));
  return 1;
     }
   else
     {
  D(("e_fm_file_copy: fail (%p) (%s)\n", file, name));
  return 0;
     }
}

int
e_fm_file_is_regular(E_Fm_File *file) /* TODO: find better name */
{
   return ((file->type == E_FM_FILE_TYPE_FILE) 
        || (file->type == E_FM_FILE_TYPE_SYMLINK)); 
}

EAPI int
e_fm_file_is_image(E_Fm_File *file)
{
   /* We need to check if it is a filetype supported by evas.
    * If it isn't supported by evas, we can't show it in the
    * canvas.
    */
   
   D(("e_fm_file_is_image: (%p)\n", file));
   return e_fm_file_is_regular(file)
        &&(e_fm_file_has_mime(file,"jpg") 
        || e_fm_file_has_mime(file,"png")); 
}

EAPI int
e_fm_file_has_mime(E_Fm_File *file, char* mime)
{
   if (!file->mime) return 0;

   D(("e_fm_file_has_mime: (%p) : %s\n", file,file->mime->name));
   return (!strcasecmp(file->mime->name, mime));
}

/* this is pointless for the new model */
#if 0

EAPI int
e_fm_file_can_preview(E_Fm_File *file)
{
   int i;

   D(("e_fm_file_can_preview: (%s) (%p)\n", file->name, file));
   for (i = 0; file->preview_funcs[i]; i++)
     {
  E_Fm_File_Preview_Function func;

  func = file->preview_funcs[i];
  if (func(file))
    return 1;
     }
   return 0;
}


EAPI int
e_fm_file_is_etheme(E_Fm_File *file)
{
   int          val;
   Evas_List   *groups, *l;

   if (!e_fm_file_is_regular(file) || !e_fm_file_has_mime(file,".edj"))
     return 0;

   val = 0;
   groups = edje_file_collection_list(file->path);
   if (!groups)
     return 0;

   for (l = groups; l; l = l->next)
   {
    if (!strcmp(l->data, "widgets/border/default/border"))
    {
       val = 1;
       break;
    }
   }
   edje_file_collection_list_free(groups);
   return val;
}

EAPI int
e_fm_file_is_ebg(E_Fm_File *file)
{
   int          val;
   Evas_List   *groups, *l;

   if (!e_fm_file_is_regular(file) || !e_fm_file_has_mime(file,".edj"))
     return 0;
  
   val = 0;
   groups = edje_file_collection_list(file->path);
   if (!groups)
     return 0;

   for (l = groups; l; l = l->next)
   {
    if (!strcmp(l->data, "desktop/background"))
    {
       val = 1;
       break;
    }
   }
   edje_file_collection_list_free(groups);
   return val;
}

EAPI int
e_fm_file_is_eap(E_Fm_File *file)
{

   E_App *app;

  if (!e_fm_file_is_regular(file) || !e_fm_file_has_mime(file,".eap"))
     return 0;
  
   app = e_app_new(file->path, 0);
   if (!app)
   {
    e_object_unref(E_OBJECT(app));
    return 0;
   }
   e_object_unref(E_OBJECT(app));
   return 1;
}
EAPI int
e_fm_file_can_exec(E_Fm_File *file)
{
   if (e_fm_file_has_mime(file,".eap"))
   {
     D(("e_fm_file_can_exec: true (%p) (%s)\n", file, file->name));
     return 1;
   }

   if (ecore_file_can_exec(file->path))
   {
    D(("e_fm_file_can_exec: true (%p) (%s)\n", file, file->name));
    return 1;
   }

   D(("e_fm_file_can_exec: false (%p) (%s)\n", file, file->name));
   return 0;
}

EAPI int
e_fm_file_exec(E_Fm_File *file)
{
   Ecore_Exe *exe;

   /* FIXME: use the e app execution mechanisms where possible so we can
    * collect error output
    */
   if(e_fm_file_has_mime(file,".eap"))
   {
       E_App *e_app;
       Ecore_Exe *exe;

       e_app = e_app_new(file->path, 0);

       if (!e_app) return 0;

       exe = ecore_exe_run(e_app->exe, NULL);
       if (exe) ecore_exe_free(exe);
       e_object_unref(E_OBJECT(e_app));
       D(("e_fm_file_exec: eap (%p) (%s)\n", file, file->name));
       return 1;
    } 

   exe = ecore_exe_run(file->path, NULL);
   if (!exe)
   {
    e_error_dialog_show(_("Run Error"),
          _("Enlightenment was unable to fork a child process:\n"
            "\n"
            "%s\n"
            "\n"),
          file->path);
    D(("e_fm_file_exec: fail (%p) (%s)\n", file, file->name));
    return 0;
   }
   /* E/app is the correct tag if the data is en E_App!
   ecore_exe_tag_set(exe, "E/app");
   */
   D(("e_fm_file_exec: ok (%p) (%s)\n", file, file->name));
   return 1;
}

EAPI int
e_fm_file_assoc_set(E_Fm_File *file, const char *assoc)
{
   /* TODO */
   return 1;
}

EAPI int
e_fm_file_assoc_exec(E_Fm_File *file)
{
   char app[PATH_MAX * 2];
   Evas_List *l;
   E_Fm_Assoc_App *assoc;
   Ecore_Exe *exe;

   if (!assoc_apps) return 0;

   /* FIXME: use the e app execution mechanisms where possible so we can
    * collect error output
    */
   for (l = assoc_apps; l; l = l->next)
   {
    assoc = l->data;
    if (e_fm_file_has_mime(file,assoc->mime))
      break;
    assoc = NULL;
   }

   if (!assoc) return 0;

   snprintf(app, PATH_MAX * 2, "%s %s", assoc->app, file->path);
   exe = ecore_exe_run(app, NULL);

   if (!exe)
   {
    e_error_dialog_show(_("Run Error"),
          _("Enlightenment was unable to fork a child process:\n"
            "\n"
            "%s\n"
            "\n"),
          app);
    D(("e_fm_assoc_exec: fail (%s)\n", app));
    return 0;
   }
   /*
    * ecore_exe_tag_set(exe, "E/app");
    */
   D(("e_fm_assoc_exec: ok (%s)\n", app));
   return 1;
}

#endif

/* local subsystem functions */
static void
_e_fm_file_free(E_Fm_File *file)
{
   D(("_e_fm_file_free: (%p) (%s)\n", file, file->name));
   if (file->path) free(file->path);
   if (file->name) free(file->name);
   free(file);
}