/*
 * PhysicsFS - ruby interface
 * 
 * Author::  Ed Sinjiashvili (slimb@vlinkmail.com)
 * License:: LGPL
 */

#include "physfs.h"
#include "ruby.h"

#include "rb_physfs.h" 
#include "rb_physfs_file.h"

VALUE modulePhysfs;

/*
 * PhysicsFS::init str
 *
 * initialize PhysicsFS
 */
VALUE physfs_init (VALUE self, VALUE str)
{
    int result = PHYSFS_init (STR2CSTR(str));

    if (result)
	return Qtrue;

    return Qfalse;
}

/*
 * PhysicsFS::deinit
 */
VALUE physfs_deinit (VALUE self)
{
    if (PHYSFS_deinit ())
	return Qtrue;

    return Qfalse;
}

/*
 * PhysicsFS::version
 * 
 * return PhysicsFS::Version object
 */
VALUE physfs_version (VALUE self)
{
    char evalStr[200];
    PHYSFS_Version ver;

    PHYSFS_getLinkedVersion (&ver);

    sprintf (evalStr, "PhysicsFS::Version.new %d, %d, %d", 
	     ver.major, ver.minor, ver.patch);
    return rb_eval_string (evalStr);
}

/*
 * PhysicsFS::supported_archives
 *
 * return Array of PhysicsFS::ArchiveInfo objects
 */
VALUE physfs_supported_archives (VALUE self)
{
    const PHYSFS_ArchiveInfo **info = PHYSFS_supportedArchiveTypes();
    VALUE klass = rb_const_get (modulePhysfs, rb_intern ("ArchiveInfo"));
    VALUE ary = rb_ary_new ();
    VALUE params[4];

    while ( *info != 0 ) 
    {
        params[0] = rb_str_new2 ((*info)->extension);
        params[1] = rb_str_new2 ((*info)->description);
        params[2] = rb_str_new2 ((*info)->author);
        params[3] = rb_str_new2 ((*info)->url);

        rb_ary_push (ary, rb_class_new_instance (4, params, klass));
        info++;
    }

    return ary;
}

/*
 * PhysicsFS::last_error
 *
 * return string representation of last PhysicsFS error
 */
VALUE physfs_last_error (VALUE self)
{
    const char *last_error = PHYSFS_getLastError ();

    if (last_error == 0)
	last_error = "";

    return rb_str_new2 (last_error);
}

/*
 * PhysicsFS::dir_separator
 *
 * return platform directory separator
 */
VALUE physfs_dir_separator (VALUE self)
{
    return rb_str_new2 (PHYSFS_getDirSeparator ());
}

/*
 * PhysicsFS::permit_symlinks boolValue
 *
 * turn symlinks support on/off
 */
VALUE physfs_permit_symlinks (VALUE self, VALUE allow)
{
    int p = 1;
    
    if (allow == Qfalse || allow == Qnil)
        p = 0;

    PHYSFS_permitSymbolicLinks (p);
    return Qtrue;
}

/*
 * PhysicsFS::cdrom_dirs
 *
 * return Array of strings containing available CDs 
 */
VALUE physfs_cdrom_dirs (VALUE self)
{
    char **cds = PHYSFS_getCdRomDirs();
    char **i;
    VALUE ary = rb_ary_new ();

    for (i = cds; *i != 0; i++)
        rb_ary_push (ary, rb_str_new2 (*i));

    PHYSFS_freeList (cds);
    return ary;
}

/*
 * PhysicsFS::base_dir
 *
 * return base directory
 */
VALUE physfs_base_dir (VALUE self)
{
    const char *base_dir = PHYSFS_getBaseDir ();
    if (base_dir == 0)
        base_dir = "";

    return rb_str_new2 (base_dir);
}

/*
 * PhysicsFS::user_dir
 *
 * return user directory
 */
VALUE physfs_user_dir (VALUE self)
{
    const char *user_dir = PHYSFS_getBaseDir ();
    if (user_dir == 0)
        user_dir = "";

    return rb_str_new2 (user_dir);
}
   
/*
 * PhysicsFS::write_dir 
 *
 * return write directory
 */
VALUE physfs_write_dir (VALUE self)
{
    const char *write_dir = PHYSFS_getWriteDir ();
    if (write_dir == 0)
        return Qnil;

    return rb_str_new2 (write_dir);
}

/*
 * PhysicsFS::write_dir= str
 *
 * set write directory to *str*
 */
VALUE physfs_set_write_dir (VALUE self, VALUE str)
{
    int result = PHYSFS_setWriteDir (STR2CSTR(str));

    if (result)
        return Qtrue;
    return Qfalse;
}

/*
 * PhysicsFS::add_to_search_path str, append
 *
 * if append > 0 - append str to search path, otherwise prepend it
 */
VALUE physfs_add_search_path (VALUE self, VALUE str, VALUE append)
{
    int result = PHYSFS_addToSearchPath (STR2CSTR(str), FIX2INT(append));
    if (result)
        return Qtrue;
    return Qfalse;
}

/*
 * PhysicsFS::remove_from_search_path str
 *
 * removes str from search path
 */
VALUE physfs_remove_search_path (VALUE self, VALUE str)
{
    int result = PHYSFS_removeFromSearchPath (STR2CSTR(str));
    if (result)
        return Qtrue;
    return Qfalse;
}

/*
 * PhysicsFS::search_path
 *
 * return current search_path - as array of strings
 */
VALUE physfs_search_path (VALUE self)
{
    char **path = PHYSFS_getSearchPath ();
    char **i;
    VALUE ary = rb_ary_new ();

    for (i = path ; *i != 0; i++)
        rb_ary_push (ary, rb_str_new2 (*i));

    PHYSFS_freeList (path);
    return ary;
}

// 
VALUE physfs_setSaneConfig(VALUE self, VALUE org, VALUE app, VALUE ext,
                           VALUE includeCdroms, VALUE archivesFirst)
{
    int res = PHYSFS_setSaneConfig (STR2CSTR(org), STR2CSTR(app), STR2CSTR(ext),
                                   RTEST(includeCdroms), RTEST(archivesFirst));
    if (res)
        return Qtrue;

    return Qfalse;
}

/*
 * PhysicsFS::mkdir newdir
 *
 * create new directory 
 */ 
VALUE physfs_mkdir (VALUE self, VALUE newdir)
{
    int result = PHYSFS_mkdir (STR2CSTR(newdir));
    if (result)
        return Qtrue;
    return Qfalse;
}

/*
 * PhysicsFS::delete name
 *
 * delete file with name
 */
VALUE physfs_delete (VALUE self, VALUE name)
{
    int result = PHYSFS_delete (STR2CSTR(name));
    if (result)
        return Qtrue;
    return Qfalse;
}

/*
 * PhysicsFS::real_dir name
 *
 * return real directory (in search path) of a name
 */
VALUE physfs_real_dir (VALUE self, VALUE name)
{
    const char *path = PHYSFS_getRealDir (STR2CSTR(name));
    if (path == 0)
        return Qnil;

    return rb_str_new2 (path);
}

/*
 * PhysicsFS::enumerate dir
 *
 * list a dir from a search path
 */
VALUE physfs_enumerate (VALUE self, VALUE dir)
{
    char **files = PHYSFS_enumerateFiles (STR2CSTR(dir));
    char **i;
    VALUE ary = rb_ary_new ();

    for (i = files; *i != 0; i++)
        rb_ary_push (ary, rb_str_new2 (*i));

    PHYSFS_freeList (files);
    return ary;
}

/*
 * PhysicsFS::exists? name
 *
 * does a file with name exist?
 */
VALUE physfs_exists (VALUE self, VALUE name)
{
    int result = PHYSFS_exists (STR2CSTR(name));
    if (result)
        return Qtrue;
    return Qfalse;
}

/*
 * PhysicsFS::is_directory? name
 *
 * return true if name is directory
 */
VALUE physfs_is_directory (VALUE self, VALUE name)
{
    int result = PHYSFS_isDirectory (STR2CSTR(name));
    if (result)
        return Qtrue;
    return Qfalse;
}

/*
 * PhysicsFS::is_symlink? name
 *
 * return true if name is symlink
 */
VALUE physfs_is_symlink (VALUE self, VALUE name)
{
    int result = PHYSFS_isSymbolicLink (STR2CSTR(name));
    if (result)
        return Qtrue;
    return Qfalse;
}

/*
 * PhysicsFS::last_mod_time name
 *
 * return last modification time of a file
 */
VALUE physfs_last_mod_time (VALUE self, VALUE name)
{
    int result = PHYSFS_getLastModTime (STR2CSTR(name));
    
    return INT2FIX(result);
}

/*
 * PhysicsFS::open_read name
 *
 * return +PhysicsFS::File+ ready for reading
 */
VALUE physfs_open_read (VALUE self, VALUE name)
{
    PHYSFS_file *file = PHYSFS_openRead (STR2CSTR(name));
    return physfs_file_new (file);
}

/*
 * PhysicsFS::open_write name
 *
 * return PhysicsFS::File ready for writing
 */
VALUE physfs_open_write (VALUE self, VALUE name)
{
    PHYSFS_file *file = PHYSFS_openWrite (STR2CSTR(name));
    return physfs_file_new (file);
}

/*
 * PhysicsFS::open_append name
 *
 * return PhysicsFS::File ready for appending
 */
VALUE physfs_open_append (VALUE self, VALUE name)
{
    PHYSFS_file *file = PHYSFS_openAppend (STR2CSTR(name));
    return physfs_file_new (file);
}

void Init_physfs_so (void)
{
    modulePhysfs = rb_define_module ("PhysicsFS");

    rb_define_singleton_method (modulePhysfs, "init_internal", physfs_init, 1);
    rb_define_singleton_method (modulePhysfs, "deinit", physfs_deinit, 0);
    rb_define_singleton_method (modulePhysfs, "version", physfs_version, 0);
    rb_define_singleton_method (modulePhysfs, "supported_archives",
				physfs_supported_archives, 0);
    rb_define_singleton_method (modulePhysfs, "last_error", 
				physfs_last_error, 0);
    rb_define_singleton_method (modulePhysfs, "dir_separator",
				physfs_dir_separator, 0);
    rb_define_singleton_method (modulePhysfs, "permit_symlinks",
                                physfs_permit_symlinks, 1);
    rb_define_singleton_method (modulePhysfs, "cdrom_dirs", 
                                physfs_cdrom_dirs, 0);
    rb_define_singleton_method (modulePhysfs, "base_dir", physfs_base_dir, 0);
    rb_define_singleton_method (modulePhysfs, "user_dir", physfs_user_dir, 0);

    rb_define_singleton_method (modulePhysfs, "write_dir", physfs_write_dir, 0);
    rb_define_singleton_method (modulePhysfs, "write_dir=", 
                                physfs_set_write_dir, 1);

    rb_define_singleton_method (modulePhysfs, "add_to_search_path",
                                physfs_add_search_path, 2);
    rb_define_singleton_method (modulePhysfs, "remove_from_search_path",
                                physfs_remove_search_path, 1);
    rb_define_singleton_method (modulePhysfs, "search_path",
                                physfs_search_path, 0);

    rb_define_singleton_method (modulePhysfs, "set_sane_config",
                                physfs_setSaneConfig, 5);

    rb_define_singleton_method (modulePhysfs, "mkdir", physfs_mkdir, 1);
    rb_define_singleton_method (modulePhysfs, "delete", physfs_delete, 1);
    rb_define_singleton_method (modulePhysfs, "real_dir",
                                physfs_real_dir, 1);
    rb_define_singleton_method (modulePhysfs, "enumerate", physfs_enumerate, 1);
    rb_define_singleton_method (modulePhysfs, "exists?", physfs_exists, 1);
    rb_define_singleton_method (modulePhysfs, "is_directory?", 
                                physfs_is_directory, 1);
    rb_define_singleton_method (modulePhysfs, "is_symlink?", 
                                physfs_is_symlink, 1);
    rb_define_singleton_method (modulePhysfs, "last_mod_time",
                                physfs_last_mod_time, 1);

    rb_define_singleton_method (modulePhysfs, "open_read", 
                                physfs_open_read, 1);
    rb_define_singleton_method (modulePhysfs, "open_write", 
                                physfs_open_write, 1);
    rb_define_singleton_method (modulePhysfs, "open_append", 
                                physfs_open_append, 1);

    init_physfs_file ();
    init_sdl_rwops ();
}

/*
// Local Variables:
// mode: C
// c-indentation-style: "stroustrup"
// indent-tabs-mode: nil
// End:
*/