/**

 * Test program for PhysicsFS. May only work on Unix.

 *

 * Please see the file LICENSE.txt in the source's root directory.

 *

 *  This file written by Ryan C. Gordon.

 */

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <string.h>

#if (defined __MWERKS__)

#include <SIOUX.h>

#endif

#if (defined PHYSFS_HAVE_READLINE)

#include <unistd.h>

#include <readline/readline.h>

#include <readline/history.h>

#endif

#include <time.h>

/* Define this, so the compiler doesn't complain about using old APIs. */

#define PHYSFS_DEPRECATED

#include "physfs.h"

#define TEST_VERSION_MAJOR  2

#define TEST_VERSION_MINOR  1

#define TEST_VERSION_PATCH  0

static FILE *history_file = NULL;

static PHYSFS_uint32 do_buffer_size = 0;

static void output_versions(void)

{

    PHYSFS_Version compiled;

    PHYSFS_Version linked;

    PHYSFS_VERSION(&compiled);

    PHYSFS_getLinkedVersion(&linked);

    printf("test_physfs version %d.%d.%d.\n"

           " Compiled against PhysicsFS version %d.%d.%d,\n"

           " and linked against %d.%d.%d.\n\n",

            TEST_VERSION_MAJOR, TEST_VERSION_MINOR, TEST_VERSION_PATCH,

            (int) compiled.major, (int) compiled.minor, (int) compiled.patch,

            (int) linked.major, (int) linked.minor, (int) linked.patch);

} /* output_versions */

static void output_archivers(void)

{

    const PHYSFS_ArchiveInfo **rc = PHYSFS_supportedArchiveTypes();

    const PHYSFS_ArchiveInfo **i;

    printf("Supported archive types:\n");

    if (*rc == NULL)

        printf(" * Apparently, NONE!\n");

    else

    {

        for (i = rc; *i != NULL; i++)

        {

            printf(" * %s: %s\n    Written by %s.\n    %s\n",

                    (*i)->extension, (*i)->description,

                    (*i)->author, (*i)->url);

            printf("    %s symbolic links.\n",

                    (*i)->supportsSymlinks ? "Supports" : "Does not support");

        } /* for */

    } /* else */

    printf("\n");

} /* output_archivers */

static int cmd_quit(char *args)

{

    return 0;

} /* cmd_quit */

static int cmd_init(char *args)

{

    if (*args == '\"')

    {

        args++;

        args[strlen(args) - 1] = '\0';

    } /* if */

    if (PHYSFS_init(args))

        printf("Successful.\n");

    else

        printf("Failure. reason: %s.\n", PHYSFS_getLastError());

    return 1;

} /* cmd_init */

static int cmd_deinit(char *args)

{

    if (PHYSFS_deinit())

        printf("Successful.\n");

    else

        printf("Failure. reason: %s.\n", PHYSFS_getLastError());

    return 1;

} /* cmd_deinit */

static int cmd_addarchive(char *args)

{

    char *ptr = strrchr(args, ' ');

    int appending = atoi(ptr + 1);

    *ptr = '\0';

    if (*args == '\"')

    {

        args++;

        *(ptr - 1) = '\0';

    } /* if */

    /*printf("[%s], [%d]\n", args, appending);*/

    if (PHYSFS_mount(args, NULL, appending))

        printf("Successful.\n");

    else

        printf("Failure. reason: %s.\n", PHYSFS_getLastError());

    return 1;

} /* cmd_addarchive */

/* wrap free() to avoid calling convention wankery. */

static void freeBuf(void *buf)

{

    free(buf);

} /* freeBuf */

typedef enum

{

    MNTTYPE_PATH,

    MNTTYPE_MEMORY,

    MNTTYPE_HANDLE

} MountType;

static int cmd_mount_internal(char *args, const MountType mnttype)

{

    char *ptr;

    char *mntpoint = NULL;

    int appending = 0;

    int rc = 0;

    if (*args == '\"')

    {

        args++;

        ptr = strchr(args, '\"');

        if (ptr == NULL)

        {

            printf("missing string terminator in argument.\n");

            return 1;

        } /* if */

        *(ptr) = '\0';

    } /* if */

    else

    {

        ptr = strchr(args, ' ');

        *ptr = '\0';

    } /* else */

    mntpoint = ptr + 1;

    if (*mntpoint == '\"')

    {

        mntpoint++;

        ptr = strchr(mntpoint, '\"');

        if (ptr == NULL)

        {

            printf("missing string terminator in argument.\n");

            return 1;

        } /* if */

        *(ptr) = '\0';

    } /* if */

    else

    {

        ptr = strchr(mntpoint, ' ');

        *(ptr) = '\0';

    } /* else */

    appending = atoi(ptr + 1);

    /*printf("[%s], [%s], [%d]\n", args, mntpoint, appending);*/

    if (mnttype == MNTTYPE_PATH)

        rc = PHYSFS_mount(args, mntpoint, appending);

    else if (mnttype == MNTTYPE_HANDLE)

    {

        PHYSFS_File *f = PHYSFS_openRead(args);

        if (f == NULL)

        {

            printf("PHYSFS_openRead('%s') failed. reason: %s.\n", args, PHYSFS_getLastError());

            return 1;

        } /* if */

        rc = PHYSFS_mountHandle(f, args, mntpoint, appending);

        if (!rc)

            PHYSFS_close(f);

    } /* else if */

    else if (mnttype == MNTTYPE_MEMORY)

    {

        FILE *in = fopen(args, "rb");

        void *buf = NULL;

        long len = 0;

        if (in == NULL)

        {

            printf("Failed to open %s to read into memory: %s.\n", args, strerror(errno));

            return 1;

        } /* if */

        if ( (fseek(in, 0, SEEK_END) != 0) || ((len = ftell(in)) < 0) )

        {

            printf("Failed to find size of %s to read into memory: %s.\n", args, strerror(errno));

            fclose(in);

            return 1;

        } /* if */

        buf = malloc(len);

        if (buf == NULL)

        {

            printf("Failed to allocate space to read %s into memory: %s.\n", args, strerror(errno));

            fclose(in);

            return 1;

        } /* if */

        if ((fseek(in, 0, SEEK_SET) != 0) || (fread(buf, len, 1, in) != 1))

        {

            printf("Failed to read %s into memory: %s.\n", args, strerror(errno));

            fclose(in);

            free(buf);

            return 1;

        } /* if */

        fclose(in);

        rc = PHYSFS_mountMemory(buf, len, freeBuf, args, mntpoint, appending);

    } /* else */

    if (rc)

        printf("Successful.\n");

    else

        printf("Failure. reason: %s.\n", PHYSFS_getLastError());

    return 1;

} /* cmd_mount_internal */

static int cmd_mount(char *args)

{

    return cmd_mount_internal(args, MNTTYPE_PATH);

} /* cmd_mount */

static int cmd_mount_mem(char *args)

{

    return cmd_mount_internal(args, MNTTYPE_MEMORY);

} /* cmd_mount_mem */

static int cmd_mount_handle(char *args)

{

    return cmd_mount_internal(args, MNTTYPE_HANDLE);

} /* cmd_mount_handle */

static int cmd_getmountpoint(char *args)

{

    if (*args == '\"')

    {

        args++;

        args[strlen(args) - 1] = '\0';

    } /* if */

    printf("Dir [%s] is mounted at [%s].\n", args, PHYSFS_getMountPoint(args));

    return 1;

} /* cmd_getmountpoint */

static int cmd_removearchive(char *args)

{

    if (*args == '\"')

    {

        args++;

        args[strlen(args) - 1] = '\0';

    } /* if */

    if (PHYSFS_unmount(args))

        printf("Successful.\n");

    else

        printf("Failure. reason: %s.\n", PHYSFS_getLastError());

    return 1;

} /* cmd_removearchive */

static int cmd_enumerate(char *args)

{

    char **rc;

    if (*args == '\"')

    {

        args++;

        args[strlen(args) - 1] = '\0';

    } /* if */

    rc = PHYSFS_enumerateFiles(args);

    if (rc == NULL)

        printf("Failure. reason: %s.\n", PHYSFS_getLastError());

    else

    {

        int file_count;

        char **i;

        for (i = rc, file_count = 0; *i != NULL; i++, file_count++)

            printf("%s\n", *i);

        printf("\n total (%d) files.\n", file_count);

        PHYSFS_freeList(rc);

    } /* else */

    return 1;

} /* cmd_enumerate */

static int cmd_getdirsep(char *args)

{

    printf("Directory separator is [%s].\n", PHYSFS_getDirSeparator());

    return 1;

} /* cmd_getdirsep */

static int cmd_getlasterror(char *args)

{

    printf("last error is [%s].\n", PHYSFS_getLastError());

    return 1;

} /* cmd_getlasterror */

static int cmd_getcdromdirs(char *args)

{

    char **rc = PHYSFS_getCdRomDirs();

    if (rc == NULL)

        printf("Failure. Reason: [%s].\n", PHYSFS_getLastError());

    else

    {

        int dir_count;

        char **i;

        for (i = rc, dir_count = 0; *i != NULL; i++, dir_count++)

            printf("%s\n", *i);

        printf("\n total (%d) drives.\n", dir_count);

        PHYSFS_freeList(rc);

    } /* else */

    return 1;

} /* cmd_getcdromdirs */

static int cmd_getsearchpath(char *args)

{

    char **rc = PHYSFS_getSearchPath();

    if (rc == NULL)

        printf("Failure. reason: %s.\n", PHYSFS_getLastError());

    else

    {

        int dir_count;

        char **i;

        for (i = rc, dir_count = 0; *i != NULL; i++, dir_count++)

            printf("%s\n", *i);

        printf("\n total (%d) directories.\n", dir_count);

        PHYSFS_freeList(rc);

    } /* else */

    return 1;

} /* cmd_getcdromdirs */

static int cmd_getbasedir(char *args)

{

    printf("Base dir is [%s].\n", PHYSFS_getBaseDir());

    return 1;

} /* cmd_getbasedir */

static int cmd_getuserdir(char *args)

{

    printf("User dir is [%s].\n", PHYSFS_getUserDir());

    return 1;

} /* cmd_getuserdir */

static int cmd_getprefdir(char *args)

{

    char *org;

    char *appName;

    char *ptr = args;

    org = ptr;

    ptr = strchr(ptr, ' '); *ptr = '\0'; ptr++; appName = ptr;

    printf("Pref dir is [%s].\n", PHYSFS_getPrefDir(org, appName));

    return 1;

} /* cmd_getprefdir */

static int cmd_getwritedir(char *args)

{

    printf("Write dir is [%s].\n", PHYSFS_getWriteDir());

    return 1;

} /* cmd_getwritedir */

static int cmd_setwritedir(char *args)

{

    if (*args == '\"')

    {

        args++;

        args[strlen(args) - 1] = '\0';

    } /* if */

    if (PHYSFS_setWriteDir(args))

        printf("Successful.\n");

    else

        printf("Failure. reason: %s.\n", PHYSFS_getLastError());

    return 1;

} /* cmd_setwritedir */

static int cmd_permitsyms(char *args)

{

    int num;

    if (*args == '\"')

    {

        args++;

        args[strlen(args) - 1] = '\0';

    } /* if */

    num = atoi(args);

    PHYSFS_permitSymbolicLinks(num);

    printf("Symlinks are now %s.\n", num ? "permitted" : "forbidden");

    return 1;

} /* cmd_permitsyms */

static int cmd_setbuffer(char *args)

{

    if (*args == '\"')

    {

        args++;

        args[strlen(args) - 1] = '\0';

    } /* if */

    do_buffer_size = (unsigned int) atoi(args);

    if (do_buffer_size)

    {

        printf("Further tests will set a (%lu) size buffer.\n",

                (unsigned long) do_buffer_size);

    } /* if */

    else

    {

        printf("Further tests will NOT use a buffer.\n");

    } /* else */

    return 1;

} /* cmd_setbuffer */

static int cmd_stressbuffer(char *args)

{

    int num;

    if (*args == '\"')

    {

        args++;

        args[strlen(args) - 1] = '\0';