/**

 * Test program for PhysicsFS, using wxWidgets. May only work on Unix.

 *

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

 *

 *  This file written by Ryan C. Gordon.

 */

#if ( (defined(__MACH__)) && (defined(__APPLE__)) )

#define PLATFORM_MACOSX 1

#include <Carbon/Carbon.h>

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <errno.h>

#include <wx/wx.h>

#include <wx/treectrl.h>

#include "physfs.h"

#define TEST_VER_MAJOR  2

#define TEST_VER_MINOR  0

//static PHYSFS_uint32 do_buffer_size = 0;

enum WxTestPhysfsMenuCommands

{

    // start with standard menu items, since using the wxIDs will map them

    //  to sane things in the platform's UI (gnome icons in GTK+, moves the

    //  about and quit items to the Apple menu on Mac OS X, etc).

    MENUCMD_About = wxID_ABOUT,

    MENUCMD_Quit = wxID_EXIT,

    // non-standard menu items go here.

    MENUCMD_Init = wxID_HIGHEST,

    MENUCMD_Deinit,

    MENUCMD_AddArchive,

    MENUCMD_Mount,

    MENUCMD_Remove,

    MENUCMD_GetCDs,

    MENUCMD_SetWriteDir,

    MENUCMD_PermitSymLinks,

    MENUCMD_SetSaneConfig,

    MENUCMD_MkDir,

    MENUCMD_Delete,

    MENUCMD_Cat,

    MENUCMD_SetBuffer,

    MENUCMD_StressBuffer,

    MENUCMD_Append,

    MENUCMD_Write,

    MENUCMD_GetLastError,

/*

    { "getdirsep",      cmd_getdirsep,      0, NULL                         },

    { "getsearchpath",  cmd_getsearchpath,  0, NULL                         },

    { "getbasedir",     cmd_getbasedir,     0, NULL                         },

    { "getuserdir",     cmd_getuserdir,     0, NULL                         },

    { "getwritedir",    cmd_getwritedir,    0, NULL                         },

    { "getrealdir",     cmd_getrealdir,     1, "<fileToFind>"               },

    { "exists",         cmd_exists,         1, "<fileToCheck>"              },

    { "isdir",          cmd_isdir,          1, "<fileToCheck>"              },

    { "issymlink",      cmd_issymlink,      1, "<fileToCheck>"              },

    { "filelength",     cmd_filelength,     1, "<fileToCheck>"              },

    { "getlastmodtime", cmd_getlastmodtime, 1, "<fileToExamine>"            },

*/

};

class WxTestPhysfsFrame : public wxFrame

{

public:

    WxTestPhysfsFrame(const wxChar *argv0);

    void rebuildTree();

    void onMenuInit(wxCommandEvent &evt);

    void onMenuDeinit(wxCommandEvent &evt);

    void onMenuAddArchive(wxCommandEvent &evt);

    void onMenuGetCDs(wxCommandEvent &evt);

    void onMenuPermitSymLinks(wxCommandEvent &evt);

private:

    wxTreeCtrl *fileTree;

    wxTreeItemId stateItem;

    wxTreeItemId fsItem;

    int err(int success);

    void fillFileSystemTree(const char *path, const wxTreeItemId &item);

    void doInit(const char *argv0);

    void doDeinit();

    DECLARE_EVENT_TABLE()

};

BEGIN_EVENT_TABLE(WxTestPhysfsFrame, wxFrame)

    EVT_MENU(MENUCMD_Init, WxTestPhysfsFrame::onMenuInit)

    EVT_MENU(MENUCMD_Deinit, WxTestPhysfsFrame::onMenuDeinit)

    EVT_MENU(MENUCMD_AddArchive, WxTestPhysfsFrame::onMenuAddArchive)

    EVT_MENU(MENUCMD_GetCDs, WxTestPhysfsFrame::onMenuGetCDs)

    EVT_MENU(MENUCMD_PermitSymLinks, WxTestPhysfsFrame::onMenuPermitSymLinks)

END_EVENT_TABLE()

// This is the the Application itself.

class WxTestPhysfsApp : public wxApp

{

public:

    WxTestPhysfsApp() : mainWindow(NULL) { /* no-op. */ }

    virtual bool OnInit();

private:

    WxTestPhysfsFrame *mainWindow;

};

DECLARE_APP(WxTestPhysfsApp)

static inline char *newstr(const char *str)

{

    char *retval = NULL;

    if (str != NULL)

    {

        retval = new char[strlen(str) + 1];

        strcpy(retval, str);

    } // if

    return retval;

} // newstr

static char *newutf8(const wxString &wxstr)

{

    #if wxUSE_UNICODE

    size_t len = wxstr.Len() + 1;

    char *utf8text = new char[len * 6];

    wxConvUTF8.WC2MB(utf8text, wxstr, len);

    return utf8text;

    #else

    return newstr(wxstr);

    #endif

} // newutf8

WxTestPhysfsFrame::WxTestPhysfsFrame(const wxChar *argv0)

    : wxFrame(NULL, -1, wxT("WxTestPhysfs"))

{

    this->CreateStatusBar();

    wxMenuBar *menuBar = new wxMenuBar;

    wxMenu *stuffMenu = new wxMenu;

    stuffMenu->Append(MENUCMD_Init, wxT("&Init"));

    stuffMenu->Append(MENUCMD_Deinit, wxT("&Deinit"));

    stuffMenu->Append(MENUCMD_AddArchive, wxT("&Add Archive"));

    stuffMenu->Append(MENUCMD_Mount, wxT("&Mount Archive"));

    stuffMenu->Append(MENUCMD_Remove, wxT("&Remove Archive"));

    stuffMenu->Append(MENUCMD_GetCDs, wxT("&Get CD-ROM drives"));

    stuffMenu->Append(MENUCMD_SetWriteDir, wxT("&Set Write Dir"));

    stuffMenu->Append(MENUCMD_SetSaneConfig, wxT("Set Sane &Config"));

    stuffMenu->Append(MENUCMD_MkDir, wxT("M&kDir"));

    stuffMenu->Append(MENUCMD_Delete, wxT("D&elete"));

    stuffMenu->Append(MENUCMD_Cat, wxT("&Cat"));

    stuffMenu->Append(MENUCMD_SetBuffer, wxT("Set &Buffer"));

    stuffMenu->Append(MENUCMD_StressBuffer, wxT("Stress &Test Buffer"));

    stuffMenu->Append(MENUCMD_Append, wxT("&Append"));

    stuffMenu->Append(MENUCMD_Write, wxT("&Write"));

    stuffMenu->Append(MENUCMD_Write, wxT("&Update getLastError"));

    stuffMenu->AppendCheckItem(MENUCMD_PermitSymLinks, wxT("&Permit symlinks"));

    menuBar->Append(stuffMenu, wxT("&Stuff"));

    //wxMenu *helpMenu = new wxMenu;

    //helpMenu->Append(MENUCMD_About, wxT("&About\tF1"));

    //menuBar->Append(helpMenu, wxT("&Help"));

    this->SetMenuBar(menuBar);

    this->fileTree = new wxTreeCtrl(this, -1);

    // The sizer just makes sure that fileTree owns whole client area.

    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);

    sizer->Add(this->fileTree, 1, wxALL | wxEXPAND | wxALIGN_CENTRE);

    sizer->SetItemMinSize(this->fileTree, 1, 1);

    this->SetSizer(sizer);

    char *utf8argv0 = newutf8(wxString(argv0));

    this->doInit(utf8argv0);

    delete[] utf8argv0;

} // WxTestPhysfsFrame::WxTestPhysfsFrame

int WxTestPhysfsFrame::err(int success)

{

    if (success)

        this->SetStatusText(wxT(""));

    else

        this->SetStatusText(wxString(PHYSFS_getLastError(), wxConvUTF8));

    return success;

} // WxTestPhysfsFrame::err

void WxTestPhysfsFrame::fillFileSystemTree(const char *path,

                                           const wxTreeItemId &item)

{

    char **rc = PHYSFS_enumerateFiles(path);

    char **i;

    wxTreeItemId id;

    if (rc == NULL)

    {

        const wxString quote(wxT("'"));

        wxString str(wxT("Enumeration error: "));

        str << quote << wxString(PHYSFS_getLastError(), wxConvUTF8) << quote;

        id = this->fileTree->AppendItem(item, str);

        this->fileTree->SetItemTextColour(id, wxColour(255, 0, 0));

    } // if

    else

    {

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

        {

            id = this->fileTree->AppendItem(item, wxString(*i, wxConvUTF8));

            const int len = strlen(path) + strlen(*i) + 2;

            char *fname = new char[len];

            const char *origdir = path;

            if (strcmp(origdir, "/") == 0)

                origdir = "";

            snprintf(fname, len, "%s/%s", origdir, *i);

            if (PHYSFS_isDirectory(fname))

            {

                this->fileTree->SetItemTextColour(id, wxColour(0, 0, 255));

                this->fillFileSystemTree(fname, id);

            } // if

            else if (PHYSFS_isSymbolicLink(fname))

            {

                this->fileTree->SetItemTextColour(id, wxColour(0, 255, 0));

            } // else if

            else  // ...file.

            {

            } // else

            delete[] fname;

        } // for

        PHYSFS_freeList(rc);

    } // else

} // fillFileSystemTree

void WxTestPhysfsFrame::rebuildTree()

{

    const wxString dot(wxT("."));

    const wxString quote(wxT("'"));

    wxTreeItemId item;

    wxString str;

    const char *cstr = NULL;

    const bool wasInit = PHYSFS_isInit() ? true : false;

    this->fileTree->DeleteAllItems();

    wxTreeItemId root = this->fileTree->AddRoot(wxT("PhysicsFS"));

    this->stateItem = this->fileTree->AppendItem(root, wxT("Library state"));

    str = wxT("Initialized: ");

    str << ((wasInit) ? wxT("true") : wxT("false"));

    this->fileTree->AppendItem(this->stateItem, str);

    this->fileTree->Expand(this->stateItem);

    this->fileTree->Expand(root);

    // Fill in version information...

    PHYSFS_Version ver;

    item = this->stateItem;

    str = wxT("wxtest_physfs version: ");

    str << TEST_VER_MAJOR << dot << TEST_VER_MINOR << dot << TEST_VER_PATCH;

    this->fileTree->AppendItem(item, str);

    PHYSFS_VERSION(&ver);

    str = wxT("Compiled against PhysicsFS version: ");

    str << (int) ver.major << dot << (int) ver.minor << dot << ver.patch;

    this->fileTree->AppendItem(item, str);

    PHYSFS_getLinkedVersion(&ver);

    str = wxT("Linked against PhysicsFS version: ");

    str << (int) ver.major << dot << (int) ver.minor << dot << ver.patch;

    this->fileTree->AppendItem(item, str);

    if (!wasInit)

        return;   // nothing else to do before initialization...

    str = wxT("Symbolic links permitted: ");

    str << ((PHYSFS_symbolicLinksPermitted()) ? wxT("true") : wxT("false"));

    this->fileTree->AppendItem(this->stateItem, str);

    str = wxT("Native directory separator: ");

    str << quote << wxString(PHYSFS_getDirSeparator(), wxConvUTF8) << quote;

    this->fileTree->AppendItem(this->stateItem, str);

    // Fill in supported archives...

    item = this->fileTree->AppendItem(this->stateItem, wxT("Archivers"));

    const PHYSFS_ArchiveInfo **arcs = PHYSFS_supportedArchiveTypes();

    if (*arcs == NULL)

        this->fileTree->AppendItem(item, wxT("(none)"));

    else

    {

        const PHYSFS_ArchiveInfo **i;

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

        {

            const wxString ext((*i)->extension, wxConvUTF8);

            const wxString desc((*i)->description, wxConvUTF8);

            const wxString auth((*i)->author, wxConvUTF8);

            const wxString url((*i)->url, wxConvUTF8);

            wxTreeItemId arcitem = this->fileTree->AppendItem(item, ext);

            this->fileTree->AppendItem(arcitem, desc);

            this->fileTree->AppendItem(arcitem, auth);

            this->fileTree->AppendItem(arcitem, url);

        } // for

    } // else

    // Fill in the standard paths...

    item = this->fileTree->AppendItem(this->stateItem, wxT("Paths"));

    str = wxT("Base directory: ");

    str << quote << wxString(PHYSFS_getBaseDir(), wxConvUTF8) << quote;

    this->fileTree->AppendItem(item, str);

    str = wxT("User directory: ");

    str << quote << wxString(PHYSFS_getUserDir(), wxConvUTF8) << quote;

    this->fileTree->AppendItem(item, str);

    str = wxT("Write directory: ");

    if ((cstr = PHYSFS_getWriteDir()) == NULL)

        str << wxT("(NULL)");

    else

        str << quote << wxString(cstr ? cstr : "(NULL)", wxConvUTF8) << quote;

    this->fileTree->AppendItem(item, str);

    //str = wxT("Preference directory: ");

    //str << wxString(PHYSFS_getUserDir(), wxConvUTF8);

    //this->fileTree->AppendItem(item, str);

    // Fill in the CD-ROMs...

    item = this->fileTree->AppendItem(this->stateItem, wxT("CD-ROMs"));

    char **cds = PHYSFS_getCdRomDirs();

    if (cds == NULL)

    {

        str = wxT("Error: ");

        str << quote << wxString(PHYSFS_getLastError(), wxConvUTF8) << quote;

        wxTreeItemId id = this->fileTree->AppendItem(item, str);

        this->fileTree->SetItemTextColour(id, wxColour(255, 0, 0));

    } // if

    else

    {

        if (*cds == NULL)

            this->fileTree->AppendItem(item, wxT("(none)"));

        else

        {

            char **i;

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

                this->fileTree->AppendItem(item, wxString(*i, wxConvUTF8));

        } // else

        PHYSFS_freeList(cds);

    } // else

    // Fill in search path...

    item = this->fileTree->AppendItem(this->stateItem, wxT("Search path"));

    char **sp = PHYSFS_getSearchPath();

    if (sp == NULL)

    {

        str = wxT("Error: ");

        str << quote << wxString(PHYSFS_getLastError(), wxConvUTF8) << quote;

        wxTreeItemId id = this->fileTree->AppendItem(item, str);

        this->fileTree->SetItemTextColour(id, wxColour(255, 0, 0));

    } // if

    else

    {

        if (*sp == NULL)

            this->fileTree->AppendItem(item, wxT("(none)"));

        else

        {

            char **i;

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

                this->fileTree->AppendItem(item, wxString(*i, wxConvUTF8));

        } // else

        PHYSFS_freeList(sp);

    } // else

    // Now fill in the filesystem...

    this->fsItem = this->fileTree->AppendItem(root, wxT("Filesystem"));

    this->fillFileSystemTree("/", this->fsItem);

    this->fileTree->Expand(this->fsItem);

} // WxTestPhysfsFrame::rebuildTree

void WxTestPhysfsFrame::doInit(const char *argv0)

{

    if (!this->err(PHYSFS_init(argv0)))

        ::wxMessageBox(wxT("PHYSFS_init() failed!"), wxT("wxTestPhysfs"));

    this->rebuildTree();

} // WxTestPhysfsFrame::doInit

void WxTestPhysfsFrame::doDeinit()

{

    if (!this->err(PHYSFS_deinit()))

        ::wxMessageBox(wxT("PHYSFS_deinit() failed!"), wxT("wxTestPhysfs"));

    this->rebuildTree();

} // WxTestPhysfsFrame::doDeinit

void WxTestPhysfsFrame::onMenuInit(wxCommandEvent &evt)

{

    wxString argv0(wxGetApp().argv[0] == NULL ? wxT("") : wxGetApp().argv[0]);

    wxString str(wxGetTextFromUser(wxT("PHYSFS_init"),

                 wxT("argv[0]? (cancel for NULL)"), argv0));

    char *cstr = str.IsEmpty() ? NULL : newutf8(str);

    this->doInit(cstr);

    delete[] cstr;

} // WxTestPhysfsFrame::onMenuInit

void WxTestPhysfsFrame::onMenuDeinit(wxCommandEvent &evt)

{

    this->doDeinit();

} // WxTestPhysfsFrame::onMenuDeinit

void WxTestPhysfsFrame::onMenuAddArchive(wxCommandEvent &evt)

{

    wxString arc = wxFileSelector(wxT("Choose archive to add"));

    if (!arc.IsEmpty())

    {

        char *cstr = newutf8(arc);

        // !!! FIXME: add to start/end?

        if (!this->err(PHYSFS_addToSearchPath(cstr, 1)))

            ::wxMessageBox(wxT("PHYSFS_addToSearchPath() failed!"), wxT("wxTestPhysfs"));

        delete[] cstr;

        this->rebuildTree();

    } // if

} // WxTestPhysfsFrame::onMenuAddArchive

void WxTestPhysfsFrame::onMenuGetCDs(wxCommandEvent &evt)

{

    this->rebuildTree();  // This will call PHYSFS_getCdRomDirs()...

} // WxTestPhysfsFrame::onMenuGetCDs

void WxTestPhysfsFrame::onMenuPermitSymLinks(wxCommandEvent &evt)

{

    PHYSFS_permitSymbolicLinks(evt.IsChecked() ? 1 : 0);

    this->rebuildTree();

} // WxTestPhysfsFrame::onMenuPermitSymLinks

IMPLEMENT_APP(WxTestPhysfsApp)

bool WxTestPhysfsApp::OnInit()

{

    #if PLATFORM_MACOSX

    // This lets a stdio app become a GUI app. Otherwise, you won't get

    //  GUI events from the system and other things will fail to work.

    // Putting the app in an application bundle does the same thing.

    //  TransformProcessType() is a 10.3+ API. SetFrontProcess() is 10.0+.

    if (TransformProcessType != NULL)  // check it as a weak symbol.

    {

        ProcessSerialNumber psn = { 0, kCurrentProcess };

        TransformProcessType(&psn, kProcessTransformToForegroundApplication);

        SetFrontProcess(&psn);

    } // if

    #endif

    this->mainWindow = new WxTestPhysfsFrame(this->argv[0]);

    this->mainWindow->Show(true);

    SetTopWindow(this->mainWindow);

    return true;

} // WxTestPhysfsApp::OnInit

// end of wxtest_physfs.cpp ...