source: AE/Installer/trunk/source/installer.cpp@ 488

/***************************************************************************\
| Project: AE Installer                                                                                                         |
| By: Gumby & Iritscen                                                                                                          |
| File: Installer.cpp                                                                                                           |
| Function: Contains the real meat of the installation process. Mm, beefy.      |
| Created: 24/05/2009 19:39:00                                                                                          |
\***************************************************************************/

// TODO: Load credits from text resource file
// TODO: Clear mod info fields when mod is de-selected

#define DEBUG

#include "boost/date_time/gregorian/gregorian.hpp"
#include "boost/date_time/date_parsing.hpp"
#include "boost/date_time/posix_time/posix_time.hpp"
#include "installer.h"
#include "aeinstallerapp.h"

using namespace boost::gregorian;
using namespace boost::posix_time;

// externs declared in installer.h
string strInstallCfg = "../GameDataFolder/Add.cfg";
string strEUFN = "Edition"; // GetUpdateStatus() may set this to "Edition-patch" later, but this is the assumed name of the new Edition folder in Updates/

int globalizeData(void)
{
        busy = 1;
        using boost::lexical_cast;
        using boost::bad_lexical_cast;
        using namespace boost::gregorian;
        using namespace boost::posix_time;
        ptime start_time(second_clock::local_time());
        
        setStatusArea("Globalizing!");
        int err = 0;
        int parts_done = 0;
        remove("Globalize.log");
        ofstream logfile("Globalize.log");
        logfile << "Globalization started " << to_simple_string(start_time) << endl;
        
        try {  // the levels Oni has...probably should have made a string array. Oops.
                char levels_cstr[15][3] = {"0", "1", "2", "3", "4", "6", "8", "9", "10", "11", "12", "13", "14", "18", "19"};
                vector<string> levels;
                for (int f = 0; f < 15; f++) {
                        levels.push_back(levels_cstr[f]);
                }

                path Characters = "../GameDataFolder/level0_Characters";
                path Particles = "../GameDataFolder/level0_Particles";
                path Archive = "../GameDataFolder/Archive";
                path Textures  = "../GameDataFolder/level0_Textures";
                path Sounds = "../GameDataFolder/level0_Sounds";
                path Animations = "../GameDataFolder/level0_Animations";
                path TRAC = Animations / "level0_TRAC";
                path TRAM = Animations / "level0_TRAM";
                
                vector<path> GDFPaths;
                GDFPaths.push_back(Particles);
                GDFPaths.push_back(Textures);
                GDFPaths.push_back(Sounds);
                GDFPaths.push_back(TRAC);
                GDFPaths.push_back(TRAM);
                
                path VanillaCharacters = "VanillaDats/level0_Final/level0_Characters/level0_Characters.oni";
                path VanillaParticles = "VanillaDats/level0_Final/level0_Particles/level0_Particles.oni";
                path VanillaTextures  = "VanillaDats/level0_Final/level0_Textures/level0_Textures.oni";
                path VanillaSounds = "VanillaDats/level0_Final/level0_Sounds/level0_Sounds.oni";
                path VanillaAnimations = "VanillaDats/level0_Final/level0_Animations/level0_Animations.oni";
                path VanillaTRAC = "VanillaDats/level0_Final/level0_Animations/level0_TRAC.oni";
                path VanillaTRAM = "VanillaDats/level0_Final/level0_Animations/level0_TRAM.oni";
                
                vector<path> VanillaPaths;
                
                VanillaPaths.push_back(VanillaParticles);
                VanillaPaths.push_back(VanillaTextures);
                VanillaPaths.push_back(VanillaSounds);
                VanillaPaths.push_back(VanillaTRAC);
                VanillaPaths.push_back(VanillaTRAM);
                
                setStatusArea("Removing old GameDataFolder...\n");
                logfile <<  "Removing old GameDataFolder...\n";
                remove_all( "../GameDataFolder/" );
                setStatusArea("Creating needed directories...");
                logfile <<  "Creating needed directories...\n";
                create_directory( "../GameDataFolder/" );
                
                create_directory( "packages" );
                
                if (exists("VanillaDats")) remove_all("VanillaDats"); 
                create_directory( "VanillaDats" );
                create_directory( "VanillaDats/level0_Final/" );
                create_directory( Characters );
                create_directory( Particles );
                create_directory( Archive );
                create_directory( Textures );
                create_directory( Sounds );
                create_directory( Animations );
                create_directory( TRAC );
                create_directory( TRAM );
                int num_levels = 0;
                for(int i = 1; i < 15; i++)
                {
                        if (exists("../../GameDataFolder/level" + levels[i] + "_Final.dat")) {
                                num_levels++;
                                
                        }
                }
                logfile << "Exporting and moving...\n\n";
                int total_steps =  8 + 2 * num_levels;
                
                for(int i = 0; i < 15; i++)
                {                       
                        if (exists("../../GameDataFolder/level" + levels[i] + "_Final.dat")) {
                                logfile << "level" << levels[i] << "_Final\n";
                                logfile << "\tExporting level" << levels[i] << "_Final.dat\n";
                                setStatusArea("Step " + lexical_cast<std::string>(parts_done + 1) + "/" + lexical_cast<std::string>(total_steps) + " exporting level" + levels[i]+"_Final.dat");
                                create_directory( "../GameDataFolder/level" + levels[i] + "_Final" ); 
                                system((strOniSplit + " -export ../GameDataFolder/level" + levels[i] + "_Final ../../GameDataFolder/level" + levels[i] + "_Final.dat").c_str());
                                create_directory( "VanillaDats/level" + levels[i] + "_Final" ); 
                                create_directory( "VanillaDats/level" + levels[i] + "_Final/level" + levels[i] + "_Final" );
                                
                                //Moves the AKEV and other files into a safe directory so that level specific textures are not globalized...
                                if ( strcmp(levels[i].c_str(), "0") ){
                                        create_directory( "../GameDataFolder/level" + levels[i] + "_Final/AKEV" ); 
                                        system((strOniSplit + " -move:overwrite ../GameDataFolder/level" + levels[i] + "_Final/AKEV ../GameDataFolder/level" + levels[i] + "_Final/AKEV*.oni").c_str());
                                        
                                }
                                
                                directory_iterator end_iter;
                                for ( directory_iterator dir_itr( "../GameDataFolder/level" + levels[i] + "_Final" ); dir_itr != end_iter; ++dir_itr )
                                {
                                        if ( is_regular_file( dir_itr->status() ) )
                                        {
                                                if ( dir_itr->path().filename().substr(0,8) == "TXMPfail" || 
                                                        dir_itr->path().filename().substr(0,9) == "TXMPlevel" ||
                                                        ( dir_itr->path().filename().substr(0,4) == "TXMP" && dir_itr->path().filename().find("intro")!=string::npos) ||
                                                        dir_itr->path().filename().substr(0,4) == "TXMB" || 
                                                        dir_itr->path().filename() == "M3GMpowerup_lsi.oni" ||
                                                        dir_itr->path().filename() == "TXMPlsi_icon.oni" ||
                                                        ( dir_itr->path().filename().substr(0,4) == "TXMB" && dir_itr->path().filename().find("splash_screen.oni")!=string::npos)       )
                                                {
                                                        cout <<dir_itr->path().filename() << "\n";
                                                        create_directory( dir_itr->path().parent_path() / "NoGlobal");  
                                                        if(!exists( dir_itr->path().parent_path() / "NoGlobal" / dir_itr->filename())) rename(dir_itr->path(), dir_itr->path().parent_path() / "NoGlobal" /
                                                                                                                                                                                                                                  dir_itr->filename());
                                                        else remove(dir_itr->path());
                                                }
                                                else if (dir_itr->path().filename().substr(0,4) == "TRAC"
                                                                 ) {
                                                        cout <<dir_itr->path().filename() << "\n";
                                                        if(!exists( TRAC / dir_itr->filename())) rename(dir_itr->path(), TRAC / dir_itr->filename());
                                                        else remove(dir_itr->path());
                                                }
                                                else if (dir_itr->path().filename().substr(0,4) == "TRAM") {
                                                        cout <<dir_itr->path().filename() << "\n";
                                                        if(!exists( TRAM / dir_itr->filename())) rename(dir_itr->path(), TRAM / dir_itr->filename());
                                                        else remove(dir_itr->path());
                                                }
                                                else if (dir_itr->path().filename().substr(0,4) == "ONSK" ||
                                                                 dir_itr->path().filename().substr(0,4) == "TXMP") {
                                                        cout <<dir_itr->path().filename() << "\n";\
                                                        create_directory( dir_itr->path().parent_path() / "TexFix");    
                                                        if(!exists( Textures / dir_itr->filename())) rename(dir_itr->path(), Textures / dir_itr->filename());
                                                }
                                                else if (dir_itr->path().filename().substr(0,4) == "ONCC" 
                                                                 || dir_itr->path().filename().substr(0,4) == "TRBS"
                                                                 || dir_itr->path().filename().substr(0,4) == "ONCV"
                                                                 || dir_itr->path().filename().substr(0,4) == "ONVL"
                                                                 || dir_itr->path().filename().substr(0,4) == "TRMA"
                                                                 || dir_itr->path().filename().substr(0,4) == "TRSC"
                                                                 || dir_itr->path().filename().substr(0,4) == "TRAS") {
                                                        cout <<dir_itr->path().filename() << "\n";
                                                        if(!exists( Characters / dir_itr->filename())) rename(dir_itr->path(), Characters / dir_itr->filename());
                                                        else remove(dir_itr->path());
                                                }
                                                else if (dir_itr->path().filename().substr(0,4) == "OSBD"
                                                                 || dir_itr->path().filename().substr(0,4) == "SNDD") {
                                                        cout << dir_itr->path().filename() << "\n";
                                                        if(!exists( Sounds / dir_itr->filename())) rename(dir_itr->path(), Sounds / dir_itr->filename());
                                                        else remove(dir_itr->path());
                                                }
                                                else if (dir_itr->path().filename().substr(0,5) == "BINA3"
                                                                 || dir_itr->path().filename().substr(0,10) == "M3GMdebris"
                                                                 || dir_itr->path().filename() == "M3GMtoxic_bubble.oni"
                                                                 || dir_itr->path().filename().substr(0,8) == "M3GMelec"
                                                                 || dir_itr->path().filename().substr(0,7) == "M3GMrat"
                                                                 || dir_itr->path().filename().substr(0,7) == "M3GMjet"
                                                                 || dir_itr->path().filename().substr(0,9) == "M3GMbomb_"
                                                                 || dir_itr->path().filename() == "M3GMbarab_swave.oni"
                                                                 || dir_itr->path().filename() == "M3GMbloodyfoot.oni"
                                                                 ){
                                                        cout <<dir_itr->path().filename() << "\n";
                                                        if(!exists( Particles / dir_itr->filename())) rename(dir_itr->path(), Particles / dir_itr->filename());
                                                        else remove(dir_itr->path());
                                                }
                                                else if (dir_itr->path().filename().substr(0,4) == "AGDB"
                                                                 || dir_itr->path().filename().substr(0,4) == "TRCM") {
                                                        cout <<dir_itr->path().filename() << "\n";
                                                        
                                                        if(!exists( Archive / dir_itr->filename())) rename(dir_itr->path(), Archive / dir_itr->filename());
                                                        else remove(dir_itr->path());
                                                }
                                                else if (dir_itr->path().filename().substr(0,4) == "ONWC") { //fix for buggy ONWC overriding
                                                        cout <<dir_itr->path().filename() << "\n";
                                                        
                                                        if(!exists( "VanillaDats/level0_Final/level0_Final/" +  dir_itr->filename()))
                                                                rename(dir_itr->path(), "VanillaDats/level0_Final/level0_Final/" +  dir_itr->filename());
                                                        else remove(dir_itr->path());
                                                }
                                                
                                                if (exists(dir_itr->path())) {
                                                        
                                                }
                                                else {
                                                        //logfile << "\tMoved file: " << dir_itr->path().filename() << "\n";
                                                }
                                        }
                                        
                                        
                                        
                                }
                                
                                logfile << "\tCleaning up TXMPs...\n";
                                system( (strOniSplit + " -move:delete " + Textures.string() + " ../GameDataFolder/level" + levels[i] + "_Final/TXMP*.oni").c_str());
                                
                                
                                if ( strcmp(levels[i].c_str(), "0") ){
                                        system((strOniSplit + " -move:overwrite ../GameDataFolder/level" + levels[i] + "_Final ../GameDataFolder/level" + levels[i] + "_Final/AKEV/AKEV*.oni").c_str());
                                        remove(  "../GameDataFolder/level" + levels[i] + "_Final/AKEV" );
                                }
                                
                                parts_done++;
                                
                                setProgressBar( (int)(1000 * (float)(parts_done) / (float)(total_steps) )); 
                                
                        }
                }
                logfile << "Reimporting levels\n";
                for (int i = 0; i < 15; i++)
                {
                        logfile << "\tReimporting level" << levels[i] << "_Final.oni\n";
                        setStatusArea("Step " + lexical_cast<std::string>(parts_done + 1) + "/" + lexical_cast<std::string>(total_steps) + " reimporting level" + levels[i]+"_Final.oni");
                        logfile << (strOniSplit + " " + strImportOption + " ../GameDataFolder/level" + levels[i] + "_Final VanillaDats/level" + levels[i] + "_Final/level" 
                                                + levels[i] + "_Final/level" + levels[i] + "_Final.oni >> Globalize.log").c_str() << '\n';
                        string sys_str = (strOniSplit + " " + strImportOption + " ../GameDataFolder/level" + levels[i] + "_Final VanillaDats/level" + levels[i] + "_Final/level"
                                                          + levels[i] + "_Final/level" + levels[i] + "_Final.oni");
                        system(sys_str.c_str() );
                        setProgressBar( (int)(1000 * (float)(parts_done) / (float)(total_steps) ));
                        parts_done++;
                }
                create_directory( VanillaParticles.parent_path() );
                create_directory( VanillaTextures.parent_path() );
                create_directory( VanillaSounds.parent_path() );
                create_directory( VanillaAnimations.remove_filename() );
                
                for(unsigned int j = 0; j < GDFPaths.size(); j++) {
                        logfile << "\tReimporting " << GDFPaths[j].filename() << ".oni\n";
                        setStatusArea("Step " + lexical_cast<std::string>(parts_done + 1) + "/" + lexical_cast<std::string>(total_steps) + ": reimporting " + GDFPaths[j].filename() );
                        system((strOniSplit + " " + strImportOption + " " + GDFPaths[j].string() + " " + VanillaPaths[j].string()).c_str());
                        parts_done++;
                        setProgressBar( (int)(1000 * (float)(parts_done) / (float)(total_steps) )); 
                }
                logfile << "\nMoving level0_Characters\n";
                setStatusArea("Step " + lexical_cast<std::string>(parts_done + 1) + "/" + lexical_cast<std::string>(total_steps) + ": moving level0_Characters" );      
                copy((path)"../GameDataFolder/level0_Characters", (path)("VanillaDats/level0_Final"));
                GDFPaths.push_back( Characters );
                for(int i = 0; i < GDFPaths.size(); i++) 
                {
                        directory_iterator end_iter;
                        for ( directory_iterator dir_itr( GDFPaths[i] ); dir_itr != end_iter; ++dir_itr )
                        {
                                try 
                                {
                                        rename(dir_itr->path(), "../GameDataFolder/level0_Final/" + dir_itr->path().filename() );
                                }
                                catch(exception &ex) {
                                        
                                }
                        }
                }

                create_directory((path)"../GameDataFolder/IGMD");
                copy((path)"packages/VanillaBSL/IGMD", (path)"../GameDataFolder");
                setProgressBar( 1000 );
                
                if(exists("../../persist.dat"))
                        if(!exists("../persist.dat")) 
                        
                        //TODO: Concatenate level0 Dirs.
                        
                                copy("../../persist.dat","..");
                if(exists("../../key_config.txt"))
                        if(!exists("../key_config.txt"))
                                copy("../../key_config.txt",".."); 
                
#ifndef WIN32
                /* On Mac only, set the current GDF to the AE GDF by writing to Oni's global preferences file (thankfully a standard OS X ".plist" XML file).
                 Tests for presence of prefs with [ -f ] before doing anything so it doesn't create a partial prefs file -- just in case user has never
                 run Oni before :-p */
                string fullAEpath = escapePath(system_complete(".").parent_path().parent_path().string()); // get full path for edition/
                char prefsCommand[300] = "[ -f ~/Library/Preferences/com.godgames.oni.plist ] && defaults write com.godgames.oni RetailInstallationPath -string '";
                strcat(prefsCommand, fullAEpath.c_str()); // get path of Edition/ folder (Oni wants the folder that *contains* the GDF)
                strcat(prefsCommand, "'"); // path string is enclosed in single quotes to avoid the need to escape UNIX-unfriendly characters
                system(prefsCommand);
#endif
                
                setStatusArea((string)"Done! Now select your mod packages and click install.");
        }
        catch (exception & ex) {
                setStatusArea("Warning, handled exception: " + (string)ex.what());
        }
        
        ptime end_time(second_clock::local_time());
        time_period total_time (start_time, end_time);
        logfile << "\n\nGlobalization ended " << to_simple_string(end_time) << "\nThe process took " << total_time.length();
        logfile.close();
        busy = 0;
        return err;
}

vector<ModPackage> getPackages(string packageDir)
{
        vector<ModPackage> packages;
        packages.reserve(256);
        fstream file;
        string filename = "\0";
        string MODINFO_CFG = "Mod_Info.cfg";
        
        try
        {
                for (directory_iterator dir_itr(packageDir), end_itr; dir_itr != end_itr; ++dir_itr)
                {
                        file.open((dir_itr->path().string() + "/" + MODINFO_CFG).c_str());
                        
                        if(!file.fail())
                        {
                                //would prefer to push a pointer to a package, but this will do for now
                                packages.push_back(fileToModPackage(file));
                        }       
                        file.close();
                        file.clear();
                }
                sort(packages.begin(), packages.end());
        }
        catch (const std::exception & ex)
        {
                cout << "Warning, something odd happened!\n";
        }
        
        return packages;
}

ModPackage fileToModPackage(fstream &file)
{
        /*
         This converts a file to a ModPackage struct.
         
         A few notes...
         "iter" is the current word we are on. I should have named it "token" or something, but I don't have multiple iterators, so its ok.
         I refer to (*iter) at the beginning of each if statement block. I could probably store it as a variable, but I'm pretty sure that dereferencing a pointer\iterator isn't much
         slower than reading a variable.
         */
        ModPackage package;
        string line;
        static string NameOfMod = "NameOfMod";  //used for comparing to the current token...
        //I could have done it in reverse (*iter).compare("ModString") or  
        static string ARROW = "->";                             //did something like "ModString".compare(*iter), and it would have been
        static string ModString = "ModString";  //functionably the same. 
        static string HasOnis = "HasOnis";
        static string HasDeltas = "HasDeltas";
        static string HasBSL = "HasBSL";
        static string HasDats = "HasDats";
        static string IsEngine = "IsEngine";
        static string Readme = "Readme";
        static string GlobalNeeded = "GlobalNeeded";
        static string Category = "Category";
        static string Creator = "Creator";
        while (! file.eof() )
        {
                getline (file,line);
                vector<string> tokens; 
                vector<string>::iterator iter;
                tokenize(line, tokens);                                 //string to vector of "words"
                if (tokens.capacity() >= 3) {                   //make sure they are using enough stuff
                        iter = tokens.begin();                          //what word we are on, starts at first word
                        /* TODO: Get this "required Installer version" code working
                         if (!AEInstallVersion.compare(*iter))
                         If mod is too old, skip this mod.
                         */
                        /*else*/if (!NameOfMod.compare(*iter))  {       //if it contains the name
                                for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++) {     // iterates through the words, ends if it reaches the end of the line or a "//" comment
                                        if (ARROW.compare(*iter) && NameOfMod.compare(*iter)) {                 // ignores "->" and "NameOfMod"
                                                package.name += *iter + " ";
                                        }
                                }
                                
                        }
                        else if (!ModString.compare(*iter)) {
                                iter++; iter++;
                                package.modStringName = *iter;
                                iter++;
                                package.modStringVersion = atoi((*iter).c_str());
                        }
                        else if (!HasOnis.compare(*iter)) {
                                iter++; iter++;  
                                if ( boost::iequals(*iter, "Yes")) package.hasOnis = 1;
                        }       
                        else if (!HasBSL.compare(*iter)) {
                                if(toupper((*iter)[0]) == 'Y' && toupper((*iter)[1]) == 'E' && toupper((*iter)[2]) == 'S') package.hasBSL = true;
                                else if ( boost::iequals(*iter, "Addon")) package.hasAddon = true;
                        }
                        else if (!HasDeltas.compare(*iter)) {
                                iter++; iter++;  
                                if (toupper((*iter)[0]) + toupper((*iter)[1]) + toupper((*iter)[2]) == 'Y' + 'E' + 'S') package.hasDeltas = 1;
                        }
                        else if (!HasDats.compare(*iter)) {
                                iter++; iter++;  
                                if (toupper((*iter)[0]) + toupper((*iter)[1]) + toupper((*iter)[2]) == 'Y' + 'E' + 'S') package.hasDats = 1;
                        }
                        else if (!IsEngine.compare(*iter)) {
                                iter++; iter++;  
                                if (toupper((*iter)[0]) + toupper((*iter)[1]) + toupper((*iter)[2]) == 'Y' + 'E' + 'S') package.isEngine = 1;
                        }
                        else if (!GlobalNeeded.compare(*iter)) {
                                iter++; iter++;  
                                if (toupper((*iter)[0]) + toupper((*iter)[1]) + toupper((*iter)[2]) == 'Y' + 'E' + 'S') package.globalNeeded = 1;
                                else if (toupper((*iter)[0]) + toupper((*iter)[1]) == 'N' + 'O') package.globalNeeded = 1; // only place where checking for "No" is important atm.
                        }
                        else if (!Category.compare(*iter))  {   
                                for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++) {     // iterates through the words, ends if it reaches end of line or a "//" comment
                                        if (ARROW.compare(*iter) && Category.compare(*iter)) {                  // ignores "->" and "Category"
                                                package.category += *iter + " ";
                                        }
                                }
                        }
                        else if (!Creator.compare(*iter))  {    //if it contains the name
                                for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++) {     // iterates through the words, ends if it reaches end of line or a "//" comment
                                        if (ARROW.compare(*iter) && Creator.compare(*iter)) {                   // ignores "->" and "Creator"
                                                package.creator += *iter + " ";
                                        }
                                }
                        }
                        else if (!Readme.compare(*iter))  {     //if it contains the name
                                for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++) {     // iterates through the words, ends if it reaches end of line or a "//" comment
                                        if (ARROW.compare(*iter) && Readme.compare(*iter)) {                    // ignores "->" and "Readme"
                                                if(!(*iter).compare("\\n")) package.readme += '\n';
                                                else package.readme += *iter + " ";
                                        }
                                }
                        }
                }
                
        }

        return package;
}

void recompileAll(vector<string> installedMods)
{try {
        busy = 1;
        using namespace boost::gregorian;
        using namespace boost::posix_time;
        using boost::lexical_cast;
        using boost::bad_lexical_cast;
        path vanilla_dir = "./VanillaDats/";
        string importCommand = "";
        int numberOfDats = 0;
        int j = 1;
        string datString;
                
        setStatusArea("Importing levels...");
        
        std::stringstream out;
        
        ptime start_time(second_clock::local_time());
        clearOldDats();
        
        if(exists("Install.log")) remove("Install.log");
        ofstream logfile("Install.log");
        logfile << "Mod Installation started " << to_simple_string(start_time) << endl;
        logfile.close();
        
        if(splitInstances == true)
        {
                recursive_directory_iterator end_iter;
                
                for ( recursive_directory_iterator dir_itr( vanilla_dir );
                         dir_itr != end_iter;
                         ++dir_itr )
                {
                        try{
                                if ( is_directory( dir_itr->status() ) &&  dir_itr.level() == 1)
                                {
                                        numberOfDats++;
                                }
                        }
                        catch(exception & ex) {
                                remove("Install.log");
                                ofstream logfile("Install.log");
                                
                                logfile << "Warning, exception " << ex.what() << "!";
                                setStatusArea("Warning, exception " + (string)ex.what() + "!");
                                logfile.close();        
                        }
                }
                try {
                        out << numberOfDats;
                        datString = out.str();
                        for ( recursive_directory_iterator dir_itr( vanilla_dir );
                                 dir_itr != end_iter;
                                 ++dir_itr )
                        {
                                try
                                {
                                        if ( is_directory( dir_itr->status() ) &&  dir_itr.level() == 1)
                                        {
                                                importCommand = strOniSplit + " " + strImportOption + " " + dir_itr->path().parent_path().string() + '/' + dir_itr->path().filename();
                                                for (unsigned int i = 0; i < installedMods.size(); ++i) {
                                                        if (exists("packages/" + installedMods[i] + "/oni/" + dir_itr->path().parent_path().filename() + '/' + dir_itr->path().filename()  ))
                                                                importCommand += " packages/" + installedMods[i] + "/oni/" + dir_itr->path().parent_path().filename() + '/' + dir_itr->path().filename();
                                                }
                                                importCommand += " ../GameDataFolder/" + dir_itr->path().filename() + ".dat >> Install.log";
                                                
                                                
                                                setProgressBar( (int)(1000 * (float)(j-1) / (float)numberOfDats) ); //100% * dat we're on / total dats
                                                setStatusArea("Step " + lexical_cast<std::string>(j) + '/' + lexical_cast<std::string>(numberOfDats)+ ": Importing " +  dir_itr->path().filename() + " ");
                                                
                                                system(importCommand.c_str());
                                                j++;                                            
                                        }
                                }
                                catch ( const std::exception & ex )
                                {
                                        remove("Install.log");
                                        ofstream logfile("Install.log");
                                        logfile << "Warning, exception " << ex.what() << "!";
                                        setStatusArea("Warning, exception " + (string)ex.what() + "!");
                                        logfile.close();        
                                }
                        }
                }
                catch( const std::exception & ex ) {
                        remove("Install.log");
                        ofstream logfile("Install.log");
                        logfile << "Warning, exception " << ex.what() << "!";
                        setStatusArea("Warning, exception " + (string)ex.what() + "!");
                        logfile.close();
                }
        }
        else if(splitInstances == false){
                directory_iterator end_iter;
                
                for ( directory_iterator dir_itr( vanilla_dir );
                         dir_itr != end_iter;
                         ++dir_itr )
                {
                        if ( is_directory( dir_itr->status() ) )
                        {
                                numberOfDats++;
                        }
                }
                
                out << numberOfDats;
                datString = out.str();
                
                for ( directory_iterator dir_itr( vanilla_dir );
                         dir_itr != end_iter;
                         ++dir_itr )
                {
                        try
                        {
                                if ( is_directory( dir_itr->status() ) )
                                {
                                        importCommand = strOniSplit + " " + strImportOption + " " + vanilla_dir.string() + dir_itr->path().filename() + " ";
                                        for (unsigned int i = 0; i < installedMods.size(); ++i) {
                                                if (exists("packages/" + installedMods[i] + "/oni/" + dir_itr->path().filename()  ))
                                                        importCommand += " packages/" + installedMods[i] + "/oni/" + dir_itr->path().filename();
                                        }
                                        importCommand += " ../GameDataFolder/" + dir_itr->path().filename() + ".dat >> Install.log";
                                        
                                        setProgressBar( (int)(1000 * (float)(j-1) / (float)numberOfDats) ); //100% * dat we're on / total dats
                                        setStatusArea("Step " + lexical_cast<std::string>(j) + '/' + lexical_cast<std::string>(numberOfDats)+ ": Importing " +  dir_itr->path().filename() + " ");
                                        system(importCommand.c_str());
                                        j++;
                                }
                        }
                        catch ( const std::exception & ex )
                        {
                                remove("Install.log");
                                ofstream logfile("Install.log");
                                logfile << "Warning, exception " << ex.what() << "!";
                                setStatusArea("Warning, exception " + (string)ex.what() + "!");
                                logfile.close();
                        }
                }
        }
        
        vector<string> BSLfolders;
        vector<string> skippedfolders;

        ofstream BSLlog("BSL.log");
        for ( directory_iterator dir_itr( "../GameDataFolder/IGMD/" ), end_itr;
                 dir_itr != end_itr;
                 ++dir_itr ) {
                if( exists(dir_itr->path().string() + "/ignore.txt") ){
                        BSLfolders.push_back(dir_itr->path().filename());
                        skippedfolders.push_back(dir_itr->path().filename());
                }
        }
        
        for (int i = installedMods.size() - 1; i >= 0; i--) {                                                   //Iterates through the installed mods (backwards :P)
                for (unsigned int j = 0; j < globalPackages.size(); ++j) {                              //looking in the global packages
                        if (globalPackages[j].modStringName == installedMods[i]) {      //for a mod that has BSL in it
                                if(!(globalPackages[j].hasAddon || globalPackages[j].hasBSL)) break; //skip non-BSL
                                if( exists( "packages/" + globalPackages[j].modStringName + "/BSL/" ) ) {
                                        copyBSL("packages/" + globalPackages[j].modStringName + "/BSL", BSLfolders, globalPackages[j] );
                                        BSLlog << "Copied " <<  globalPackages[j].modStringName << "!\n";
                                }
                        }
                }
        }
        
        ModPackage emptyPackage;
        emptyPackage.modStringName = "VanillaBSL";
        emptyPackage.hasBSL = 1;
        copyBSL("packages/VanillaBSL/IGMD", BSLfolders, emptyPackage);
        BSLlog.close();
        
        logfile << "Writing config file";
        writeInstalledMods(installedMods);
        setProgressBar(1000);
        
        string finallyDone = "Done! You can now play Oni.";
        setStatusArea(finallyDone);
        
        ptime end_time(second_clock::local_time());
        time_period total_time (start_time, end_time);
        ofstream logfile2("Install.log", ios::app | ios::ate);
        string outstring = (string)"\n\nGlobalization ended " + to_simple_string(end_time) + "\nThe process took ";// + (string)total_time.length();
        
        logfile2 << "\nInstallation ended " << to_simple_string(end_time) << "\nThe process took " << total_time.length();
        logfile2.close();
        
        Sleep(1000);
        setProgressBar(0);
}
        catch(exception & ex) {
                remove("Install.log"); //why did we do this? :|
                ofstream logfile("Install.log");
                logfile << "Warning, exception " << ex.what() << "!";
                setStatusArea("Warning, exception " + (string)ex.what() + "!");
                logfile.close();
        }
        busy = 0;
}

void copyBSL(string copypath, vector<string>& BSLfolders, ModPackage pkg)
{
        ofstream BSLlog("BSL2.log", ios::app );
        
        try {
                for ( directory_iterator dir_itr( copypath ), end_itr;
                         dir_itr != end_itr;
                         ++dir_itr ) {
                        
                        if ( is_directory( dir_itr->path() ) && dir_itr->path().string() != ".svn" ) {  
                                BSLlog << "Testing " << dir_itr->path().string() << " HasBSL: " << pkg.hasBSL << " HasAddon: " << pkg.hasAddon << "\n";
                                int skip_folder = 0;
                                
                                for(unsigned int k = 0; k < BSLfolders.size(); k++)             {//iterate through already found BSL folders    
                                        BSLlog << "testing " << dir_itr->path().filename() << " vs " << BSLfolders[k] << "\n";
                                        if(dir_itr->path().filename() == BSLfolders[k]) {
                                                skip_folder = 1;
                                                BSLlog << "skipping " << BSLfolders[k] << " in " << pkg.modStringName << "\n";
                                                break;
                                        }
                                }
                                if (!skip_folder && !exists("../GameDataFolder/IGMD/" + dir_itr->path().filename() + "/ignore.txt")) {
                                        remove_all( "../GameDataFolder/IGMD/" + dir_itr->path().filename() );
                                        Sleep(100);
                                        create_directory( "../GameDataFolder/IGMD/" + dir_itr->path().filename());
                                        BSLlog << "Copied " << dir_itr->path().string() << " in " << pkg.modStringName << "!\n";
                                        for ( directory_iterator bsl_itr( dir_itr->path() );
                                                 bsl_itr != end_itr;
                                                 bsl_itr++ ) {
                                                if ( bsl_itr->path().extension() == ".bsl" ) {
                                                        copy_file(bsl_itr->path(),  "../GameDataFolder/IGMD/" + dir_itr->path().filename() + "/" + bsl_itr->path().filename()); 
                                                }
                                        }
                                        BSLfolders.push_back( dir_itr->path().filename() ); //add back check for addon
                                        BSLlog << "Pushing " << dir_itr->path().filename() << "\n" ;
                                }
                        }
                }
        }
        catch ( const std::exception & ex )
        {
                setStatusArea("Warning, exception " + (string)ex.what() + "!");
                while(1) Sleep(1000);
        }
        BSLlog.close();
        
}


void writeInstalledMods(vector<string> installedMods)
{       
        if ( exists( strInstallCfg ) )
        {
                remove( strInstallCfg );
        }
        
        ofstream file(strInstallCfg.c_str());
        
        vector<string>list = installedMods;
        vector<string>::iterator begin_iter = list.begin(); 
        vector<string>::iterator end_iter = list.end();
        
        sort( list.begin(), list.end() );
        
        for( ; begin_iter != end_iter; ++begin_iter) {
                file << *begin_iter << " ";
        }
        
        file.close();
        file.clear();
}

vector<string> getInstallString(string Cfg)
{
        vector<string> returnval;       
        string line;
        fstream file;
        
        if (exists( Cfg ))
        {
                file.open(Cfg.c_str());
                getline(file, line);
                tokenize(line, returnval);
                file.close();
                file.clear();
                sort(returnval.begin(), returnval.end());
        }
        else cout << "fail";
        
        return returnval;
}

/* GetUpdateStatus determines whether there is an update available. It is called once, *\
|  on launch, by AEInstallerApp::OnInit(), and not only passes back a #defined result   |
|  code, but also oversees the setting of data in the global structures currentAE and   |
|  updateAE, which tell the Installer all the version information it needs to know.             |
|                                       ---Return Values---                                                                                                     |
|  UPDATE_LOG_READ_ERR          -- A log file could not be opened                                                       |
|  UPDATE_INST_REPL_ERR         -- The Installer self-updating process failed                           |
|  UPDATE_MNTH_REQD_ERR         -- The update is a patch, and the monthly release it            |
|                                                          patches is not installed                                                                     |
|  UPDATE_NO_UPD_AVAIL          -- Either there isn't an update in place, or it's not           |
|                                                          newer than what's installed                                                          |
|  UPDATE_SIMP_AVAIL            -- An update is available                                                                       |
|  UPDATE_GLOB_AVAIL            -- An update is available that requires re-globalization        |
|                                                          afterwards (because of some notable change in the AE)        |
|  UPDATE_INST_AVAIL            -- An update is available that first requires the                       |
|                                                          Installer to be replaced (when the new Installer                     |
|                                                          launches, this function will be called again but will        |
|                                                          return UPDATE_SIMP_AVAIL or UPDATE_GLOB_AVAIL)                       |
\* UPDATE_CONT_UPD                      -- Currently unused                                                                                */
int GetUpdateStatus(Install_info_cfg *currentAE, Install_info_cfg *updateAE, bool *installerJustUpdated)
{
        fstream currentAECfg, updateAECfg, updateLog;
        string strInstaller = "Installer";
        string strBeing = "being";
        string strWas = "was"; // lol
#ifdef WIN32
        string strInstallerName = "AEInstaller.exe";
#else
        string strInstallerName = "Installer.app";
#endif
        
        // Try to get current AE's version info; if it doesn't exist, then the default version data for 2009-07 remains in place
        if (exists("packages/Globalize/Install_Info.cfg"))
        {
                currentAECfg.open("packages/Globalize/Install_Info.cfg");
                if (!currentAECfg.fail())
                {
                        if (!ReadInstallInfoCfg(&currentAECfg, currentAE))
                                return UPDATE_LOG_READ_ERR;
                        
                        currentAECfg.close();
                        currentAECfg.clear();
                }
                else
                        return UPDATE_LOG_READ_ERR;
        }
        
        // Is there an update folder, and is it a monthly release or a patch?
        if (!exists("../updates/Edition"))
        {
                strEUFN = "Edition-patch";
                if (!exists("../updates/Edition-patch"))
                        return UPDATE_NO_UPD_AVAIL;
        }
        
        // Unlike the current AE's version info, we *need* to find the update's version info or we won't continue
        string updateCfgPath = ("../updates/" + strEUFN + "/install/packages/Globalize/Install_Info.cfg");
        updateAECfg.open(updateCfgPath.c_str());
        if (!updateAECfg.fail())
        {
                if (!ReadInstallInfoCfg(&updateAECfg, updateAE))
                        return UPDATE_LOG_READ_ERR;
                
                updateAECfg.close();
                updateAECfg.clear();
        }
        else
                return UPDATE_LOG_READ_ERR;

        // Now we check for an Installer update in progress
        if (exists("Update.log"))
        {
                updateLog.open("Update.log");
                if (!updateLog.fail())
                {
                        vector<string> lines; 
                        string line;
                        int num_lines = 0;
                        bool readingInstallerVersion = false, doneReadingFile = false;
                        
                        while (!updateLog.eof() && !doneReadingFile)
                        {
                                getline(updateLog, line);
                                lines.push_back(line);
                                num_lines++;
                                vector<string> tokens;
                                vector<string>::iterator iter;
                                tokenize(line, tokens);
                                iter = tokens.begin();
                                if (!readingInstallerVersion && tokens.capacity() >= 4)
                                {
                                        if (!strInstaller.compare(*iter))
                                        {
                                                if (!strBeing.compare(*++iter))
                                                        readingInstallerVersion = true;
                                                else if (!strWas.compare(*iter))
                                                        *installerJustUpdated = true; // our third indirect return value after currentAE and updateAE
                                        }
                                }
                                else if (readingInstallerVersion && tokens.capacity() >= 3)
                                {
                                        readingInstallerVersion = false;
                                        string installerVersion = INSTALLER_VERSION;
                                        if (installerVersion.compare(*iter)) // then the shell script-powered replacement failed
                                                return UPDATE_INST_REPL_ERR;
                                        else
                                        {
                                                updateLog.close();
                                                updateLog.clear();
                                                Sleep(1000);
                                                remove("Update.log");
                                                ofstream newUpdateLog("Update.log");
                                                if (!newUpdateLog.fail())
                                                {
                                                        // Write over old log with updated information
                                                        ptime startTime(second_clock::local_time());
                                                        string strStartTime = to_simple_string(startTime);
                                                        string newUpdateLine = installerVersion + " on " + strStartTime;
                                                        for (int a = 0; a < lines.capacity() - 2; a++) // if there were even lines in the log before this at all
                                                        {
                                                                newUpdateLog << lines[a].c_str();
                                                                newUpdateLog << "\n";
                                                        }
                                                        newUpdateLog << "Installer was updated to:\n";
                                                        newUpdateLog << newUpdateLine.c_str();
                                                        *installerJustUpdated = true; // this value is indirectly returned to AEInstallerAp::OnInit()
                                                        doneReadingFile = true;
                                                        newUpdateLog.close();
                                                        newUpdateLog.clear();
                                                        //return UPDATE_CONT_UPD; // as noted above, we are not using this return value; in fact, we want...
                                                        //                                                       ...the code to continue running down through the Edition version check
                                                }
                                                else
                                                        return UPDATE_LOG_READ_ERR;
                                        }
                                }
                        }
                        updateLog.close();
                        updateLog.clear();
                }
                else
                        return UPDATE_LOG_READ_ERR;
        }
        
        if (updateAE->AEVersion.compare(currentAE->AEVersion) >= 1) // is the release update newer than what's installed?
        {
                if (!strEUFN.compare("Edition-patch")) // if update is a patch...
                {
                        if (currentAE->AEVersion.compare(updateAE->AEVersion.substr(0, updateAE->AEVersion.length() - 1))) // ...is it for a different month?
                                return UPDATE_MNTH_REQD_ERR;
                }
                string strNewInstallerPath = "../updates/" + strEUFN + "/install/" + strInstallerName;
                string installerVersion = INSTALLER_VERSION;
                if (updateAE->InstallerVersion.compare(installerVersion) >= 1)
                {
                        if (exists(strNewInstallerPath))
                                return UPDATE_INST_AVAIL;
                }
                else if (updateAE->globalizationRequired)
                        return UPDATE_GLOB_AVAIL;
                else
                        return UPDATE_SIMP_AVAIL;
        }
        else
                return UPDATE_NO_UPD_AVAIL;
        
        return UPDATE_NO_UPD_AVAIL;
}

bool ReadInstallInfoCfg(fstream *fileHandler, Install_info_cfg *info_cfg)
{
        vector<string> tokens;
        vector<string>::iterator iter;
        string line;
        string strAEVersion = "AE_Version";
        string strInstallerVersion = "Installer_Version";
        string strDaodanVersion = "Daodan_Version";
        string strOniSplitVersion = "OniSplit_Version";
        string strGUIWinVersion = "GUI_Win_Version";
        string strGUIMacVersion = "GUI_Mac_Version";
        string strReglobalize = "Reglobalize";
        string strDeleteList = "Delete_List";
        string strArrow = "->";
        string strDoubleSlash = "//";
        string strYes = "Yes"; // this is getting silly
        
        while (getline(*fileHandler, line))
        {
                tokenize(line, tokens);
                iter = tokens.begin();
                
                if (tokens.size() >= 3)
                {
                        if (!strAEVersion.compare(*iter))
                        {
                                if (!strArrow.compare(*++iter))
                                        info_cfg->AEVersion = *++iter;
                                else
                                        return false;
                        }
                        else if (!strInstallerVersion.compare(*iter))
                        {
                                if (!strArrow.compare(*++iter))
                                        info_cfg->InstallerVersion = *++iter;
                                else
                                        return false;
                        }
                        else if (!strDaodanVersion.compare(*iter))
                        {
                                if (!strArrow.compare(*++iter))
                                        info_cfg->DaodanVersion = *++iter;
                                else
                                        return false;
                        }
                        else if (!strOniSplitVersion.compare(*iter))
                        {
                                if (!strArrow.compare(*++iter))
                                        info_cfg->OniSplitVersion = *++iter;
                                else
                                        return false;
                        }
                        else if (!strGUIWinVersion.compare(*iter))
                        {
                                if (!strArrow.compare(*++iter))
                                        info_cfg->WinGUIVersion = *++iter;
                                else
                                        return false;
                        }
                        else if (!strGUIMacVersion.compare(*iter))
                        {
                                if (!strArrow.compare(*++iter))
                                        info_cfg->MacGUIVersion = *++iter;
                                else
                                        return false;
                        }
                        else if (!strReglobalize.compare(*iter))
                        {
                                if (!strArrow.compare(*++iter))
                                {
                                        if (!strYes.compare(*++iter))
                                                info_cfg->globalizationRequired = true;
                                }
                                else
                                        return false;
                        }
                        else if (!strDeleteList.compare(*iter))
                        {
                                // We need to perform a totally customized parsing process on this data
                                if (!strArrow.compare(*++iter))
                                {
                                        vector<string> tokens2;
                                        tokenize(line, tokens2, ","); // the paths on this line are comma-delimited, so we parse it again
                                        vector<string>::iterator iter2 = tokens2.begin();
                                        string finalPath = "";
                                        for (; iter2 != tokens2.end(); iter2++)
                                        {
                                                finalPath = finalPath + *iter2;
                                                
                                                string::size_type loc = finalPath.find("->", 0); // the first word will have "Delete_List ->" at the front, so let's cut that off
                                                if (loc != string::npos)
                                                        finalPath = finalPath.substr(loc + 3, finalPath.size());
                                                
                                                // If a path has '//' in it, it must contain some optional comments that were at the end of the Delete_List line
                                                loc = finalPath.find("//", 0);
                                                if (loc != string::npos)
                                                        finalPath = finalPath.substr(0, loc);
                                                
                                                // Trim a single space if it exists at the start or finish; putting more than one space after a comma will break this
                                                if (finalPath.at(0) == ' ')
                                                        finalPath = finalPath.substr(1, finalPath.size());
                                                if (finalPath.at(finalPath.size() - 1) == ' ')
                                                        finalPath = finalPath.substr(0, finalPath.size() - 1);

                                                // If the tokenized path ends with a '\', then we assume it was followed by a comma
                                                if (finalPath.at(finalPath.size() - 1) == '\\')
                                                {
                                                        finalPath = finalPath.substr(0, finalPath.size() - 1); // clip the '\' off the end of the string now that it served its purpose...
                                                        finalPath = finalPath + ","; // ...and add the actual comma back at the end
                                                }
                                                else // we can add the path to deleteList, and clear the path; otherwise it will be added to on the next iteration
                                                {
                                                        if (StringIsLegalPathForDeletion(finalPath)) // ...and it's not violating any of our security rules as to what can be deleted...
                                                                info_cfg->deleteList.push_back(finalPath); // ...then add it to our deleteList in memory
                                                        finalPath.clear(); // clear the token we were building up before the next pass
                                                }
                                        }
                                }
                                else
                                        return false;
                        }
                }
                tokens.clear();
        }
        
        return true;
}

// TODO: Fix security holes here
/* There is currently a security hole in this function; the first occurrence of a '.' not followed by a second '.' will prevent the function from
 noticing an actual occurrence of '..' later in the string; iow, it only looks after the first period it finds for a second period.
 A second hole is that the last slash will be trimmed from the path, but one could still use ".//" and it would get past this function, and
 possibly be interpreted by the Boost file functions as "the current directory". Iow, both of these checks need to be iterative, not one-time.
 Not too concerned about this at the moment, as only we of the AE Team are supplying the install_info file that this function is connected to. -I */

/* This function serves as a barrier against the Installer deleting files it shouldn't. *\
|  It tests for each of the following conditions in the path it is passed:                               |
|   A. '..' as the whole path or '/..', '\..' anywhere in the path                                               |
|        Reason: Moving up from the parent directory, the Edition folder, would allow one        |
|        to delete anything on the hard drive, so all "parent path" references are illegal.      |
|   B. '/' at the beginning of the path                                                                                                  |
|        Reason: In Unix, this means the path starts from root level, as opposed to the          |
|        directory we will evaluate these paths as being relative to, which is Edition/.         |
|   C. '.' as the whole path                                                                                                                     |
|        Reason: This would mean "the Edition folder", which is not allowed to be deleted.       |
|   D. 'GameDataFolder' at the end of the path                                                                                   |
|        Reason: We don't allow the entire GDF to be deleted, only specific files in it.         |
|   E. '*' anywhere in the path                                                                                                                  |
|        Reason: We don't want this interpreted as a wildcard; it's best to only delete          |
*\       files by name.                                                                                                                                         */
bool StringIsLegalPathForDeletion(string word)
{
        string::size_type loc1, loc2;
        
        // Trim ending slashes in order to simplify the test
        // Note that we're only altering the local copy of the string here
        loc1 = word.find_last_of("\\", word.size());
        if (loc1 == word.size() - 1)
                word.resize(word.size() - 1);
        loc1 = word.find_last_of("/", word.size());
        if (loc1 == word.size() - 1)
                word.resize(word.size() - 1);
        
        // Test B
        loc1 = word.find_first_of("\\", 0);
        if (loc1 == 0)
                return false; // path begins with a slash, meaning root level of HD in Unix, an illegal path
        loc1 = word.find_first_of("/", 0);
        if (loc1 == 0)
                return false; // path begins with a slash, meaning root level of HD in Unix, an illegal path
        
        // Test E
        loc1 = word.find("*", 0);
        if (loc1 != string::npos) // if we found our character before reaching the end of the string
                return false; // path cannot contain the '*' character
        
        // Tests A (part 1) and C
        loc1 = word.find(".", 0);
        if (loc1 != string::npos)
        {
                if (word.size() == 1)
                        return false; // path cannot be simply '.', referring to Edition folder itself
                loc2 = word.find(".", loc1 + 1);
                if (loc2 == loc1 + 1) // make sure this second period comes after the first one
                        if (word.size() == 2)
                                return false; // not allowed to reference a parent directory
        }
        
        // Test A (part 2)
        loc1 = word.find("/..", 0);
        if (loc1 != string::npos)
                return false; // not allowed to reference a parent directory
        loc1 = word.find("\\..", 0);
        if (loc1 != string::npos)
                return false; // not allowed to reference a parent directory
        
        // Test D
        loc1 = word.find("GameDataFolder", 0);
        if (loc1 == word.size() - 14) // if "GameDataFolder" is the last 14 characters of the string...
                return false; // not allowed to delete the GDF

        return true;
}

bool ProcessInstallerUpdate(Install_info_cfg *currentAE, Install_info_cfg *updateAE)
{
        ofstream file;
        string shellScript;
        
        ptime startTime(second_clock::local_time());
        string strStartTime = to_simple_string(startTime);
        string progressMsg = "Installer being updated to:\n" +
                                                 updateAE->InstallerVersion + " on " + strStartTime;
        file.open("Update.log");
        if (!file.fail())
                file << progressMsg.c_str();
        file.close();
        file.clear();
        
        string popenCommand = "../updates/" + strEUFN + "/install/";
#ifdef WIN32
        // TODO: Fill in Windows equivalent of code below :-3
#else
        // We can't just use '~' to mean "the home directory" because we need to check the path in C...
        // ...so we actually get the current user's shortname and manually construct the path to home
        FILE *fUserName = NULL;
        char chrUserName[32];
        fUserName = popen("whoami", "r");
        fgets(chrUserName, sizeof(chrUserName), fUserName);
        pclose(fUserName);
        string strUserName = (string)chrUserName; // stringsblaaarrrgggghhhh
        int endOfName = strUserName.find("\n", 0);
        string pathToTrash = "/Users/" + strUserName.substr(0, endOfName) + "/.Trash/";
        tm tmStartTime = to_tm(startTime);
        pathToTrash = pathToTrash + "Old_Edition_files_" + currentAE->AEVersion + "_" + boost::lexical_cast<string>(tmStartTime.tm_hour) + "-" +
        boost::lexical_cast<string>(tmStartTime.tm_min) + "-" + boost::lexical_cast<string>(tmStartTime.tm_sec); // lol
        create_directory(pathToTrash);
        // The script takes as a parameter the path the old Installer should go to, in quotes
        popenCommand = "bash " + popenCommand + "replace_installer.sh " + pathToTrash + "/Installer.app";
                                   
#endif
        file.close();
        file.clear();
        popen(popenCommand.c_str(), "r");
        
        return true; // returning 'true' tells the Installer to quit itself ASAP so it can be replaced by the process that is now running
}

bool ProcessAEUpdate(Install_info_cfg *currentAE, Install_info_cfg *updateAE, bool *installerJustUpdated)
{
        fstream file;
        string line;
        vector<string> tokens, updateStarted;
        string strInstaller = "Installer";
        string strWas = "was";
        string strPathToEUFN = ("../updates/" + strEUFN + "/"); // strEUFN is set by GetUpdateStatus()
        string strPathToEUFNInstall = ("../updates/" + strEUFN + "/install/");
        string strPathToEUFNPackages = ("../updates/" + strEUFN + "/install/packages/");
        string strPathToPackages = "packages/";
        string strGlobalize = "Globalize/";
        string strOniSplit = "OniSplit.exe";
        string strDaodan = "binkw32.dll";
        string strWinGUI = "onisplit_gui.exe";
        string strWinGUILang = "ospgui_lang.ini";
        string strMacGUI = "AETools.app";
#ifdef WIN32
        string strOniApp = "Oni.exe";
#else
        string strOniApp = "Oni.app";
#endif
        bool needNewTrashDir = false;
        bool readingVerAndDate = false;
        
        // TODO: Fill in Windows equivalent of code below
#ifdef WIN32
        string strTrashDir = "%RECYCLE%";
#else
        FILE *fUserName = NULL;
        char chrUserName[32];
        fUserName = popen("whoami", "r");
        fgets(chrUserName, sizeof(chrUserName), fUserName);
        pclose(fUserName);
        string strUserName = (string)chrUserName; // stringsblaaarrrgggghhhh
        int endOfName = strUserName.find("\n", 0);
        string strTrashDir = "/Users/" + strUserName.substr(0, endOfName) + "/.Trash/";
#endif
        
        // Write to log that we are beginning the update process
        ptime startTime(second_clock::local_time());
        string strStartTime = to_simple_string(startTime);
        string progressMsg = "\nEdition being updated to:\n" +
                                                 updateAE->AEVersion + " on " + strStartTime;
        file.open("Update.log");
        if (!file.fail())
                file << progressMsg.c_str();
        
        if (*installerJustUpdated) // then we want to know what folder in the Trash the Installer was placed in...
        {
                while (!file.eof()) // ...so we read the log to get the timestamp so we know the name of the folder that should be in the Trash
                {
                        getline(file, line);
                        tokenize(line, tokens);
                        
                        if (tokens.capacity() >= 4)
                                if (!strInstaller.compare(tokens[0]))
                                        if (!strWas.compare(tokens[1]))
                                                readingVerAndDate = true;
                        if (readingVerAndDate && tokens.capacity() >= 3)
                                tokenize(tokens[2], updateStarted, "-");
                }
                if (updateStarted.capacity() < 3)
                        needNewTrashDir = true;
                else
                {
                        strTrashDir = strTrashDir + "Old_Edition_files_" + currentAE->AEVersion + "-" +
                                                  updateStarted[0] + "-" + updateStarted[1] + "-" + updateStarted[2] + "/";
                        if (!exists(strTrashDir))
                                needNewTrashDir = true;
                }
        }
        
        if (!*installerJustUpdated || needNewTrashDir) // prepare a new directory for deleted files to go to
        {
                tm tmStartTime = to_tm(startTime);
                strTrashDir = strTrashDir + "Old_Edition_files_" + currentAE->AEVersion + "_" + boost::lexical_cast<string>(tmStartTime.tm_hour) + "-" +
                                          boost::lexical_cast<string>(tmStartTime.tm_min) + "-" + boost::lexical_cast<string>(tmStartTime.tm_sec) + "/";
                create_directory(strTrashDir);
        }
        file.close();
        file.clear();

        // Special code to replace our special files -- the Oni app, OniSplit, the Daodan DLL, and the GUI for OniSplit
        if (exists(strPathToEUFN + strOniApp))
        {
                if (exists(strOniApp))
                        rename((path)strOniApp, (path)(strTrashDir + strOniApp));
                rename((path)(strPathToEUFN + strOniApp), (path)strOniApp);
        }
        if (updateAE->OniSplitVersion.compare(currentAE->OniSplitVersion) >= 1)
        {
                if (exists(strPathToEUFNInstall + strOniSplit))
                {
                        if (exists(strOniSplit))
                                rename((path)strOniSplit, (path)(strTrashDir + strOniSplit));
                        rename((path)(strPathToEUFNInstall + strOniSplit), (path)strOniSplit);
                }
        }
#ifdef WIN32
        if (updateAE->DaodanVersion.compare(currentAE->DaodanVersion) >= 1)
        {
                if (exists(strPathToEUFN + strDaodan))
                {
                        if (exists(("../" + strDaodan)))
                                rename((path)("../" + strDaodan), (path)(strTrashDir + strDaodan));
                        rename((path)(strPathToEUFN + strDaodan), (path)("../" + strDaodan));
                }
        }
        if (updateAE->WinGUIVersion.compare(currentAE->WinGUIVersion) >= 1)
        {
                if (exists(strPathToEUFNInstall + strWinGUI))
                {
                        if (exists((path)strWinGUI))
                                rename((path)strWinGUI, (path)strcat(strTrashDir, strWinGUI));
                        if (exists(strWinGUILang))
                                rename((path)strWinGUILang, (path)strcat(strTrashDir, strWinGUILang));
                        rename((path)(strPathToEUFNInstall + strWinGUI), (path)strWinGUI);
                        rename((path)(strPathToEUFNInstall + strWinGUILang), (path)strWinGUILang);
                }
        }
#else
        if (updateAE->MacGUIVersion.compare(currentAE->MacGUIVersion) >= 1)
        {
                if (exists(strPathToEUFN + strMacGUI))
                {
                        if (exists(("../" + strMacGUI)))
                                rename((path)("../" + strMacGUI), (path)(strTrashDir + strMacGUI));
                        rename((path)(strPathToEUFN + strMacGUI), (path)("../" + strMacGUI));
                }
        }
#endif
        
        // Now we trash whatever's in DeleteList; this allows us to clear out obsolete files in the previous AE install
        // Before moving a file to the Trash, we need to make sure each of the file's parent paths exists in the Trash...
        // ...so we iterate through the hierarchy of the file path, checking for each one and creating it if necessary
        for (vector<string>::iterator iter = updateAE->deleteList.begin(); iter != updateAE->deleteList.end(); iter++)
        {
                string thePath = *iter;
                if (exists((path)("../" + thePath)))
                {
                        string aParentPath;
                        string::size_type curPos = thePath.find("/", 0);
                        if (curPos != string::npos)
                                aParentPath = thePath.substr(0, curPos);
                        string::size_type lastPos = curPos;
                        while (curPos != string::npos && curPos < thePath.size())
                        {
                                aParentPath = aParentPath + thePath.substr(lastPos, curPos - lastPos);
                                if (!exists(strTrashDir + aParentPath))
                                        create_directory(strTrashDir + aParentPath);
                                lastPos = curPos + 1;
                                curPos = thePath.find("/", lastPos);
                                aParentPath = aParentPath + "/";
                        }
                        rename((path)("../" + thePath), (path)(strTrashDir + thePath));
                }
        }
        
        // Now we crawl the update's package folders for newer versions and move them over, trashing ones that are already present
        vector<ModPackage> updatePackages, currentPackages;
        bool matchFound;
        updatePackages.reserve(256);
        currentPackages.reserve(256);
        
        currentPackages = getPackages();
        updatePackages = getPackages(strPathToEUFNPackages);

        for (vector<ModPackage>::iterator iter1 = updatePackages.begin(); iter1 != updatePackages.end(); iter1++)
        {
                matchFound = false;
                for (vector<ModPackage>::iterator iter2 = currentPackages.begin(); iter2 != currentPackages.end(); iter2++)
                {
                        if (!iter1->modStringName.compare(iter2->modStringName))
                        {
                                matchFound = true;
                                if (iter1->modStringVersion > iter2->modStringVersion)
                                {
                                        rename((path)(strPathToPackages + iter2->modStringName), (path)(strTrashDir + iter2->modStringName));
                                        rename((path)(strPathToEUFNPackages + iter1->modStringName), (path)(strPathToPackages + iter1->modStringName));
                                }
                        }
                }
                if (!matchFound) // then there's no old package in the way, so just move in the one from the update
                        rename((path)(strPathToEUFNPackages + iter1->modStringName), (path)(strPathToPackages + iter1->modStringName));
        }
        
        // Next, we get a list of which files and folders in the update's Globalize folder to move over; all files not starting with '.' will be moved...
        // ...and folders which do not exist in the current AE will be created there
        vector<string> foldersToMake, filesToMove;
        string thePath;
        for (recursive_directory_iterator dir_itr(strPathToEUFNPackages + strGlobalize), end_itr; dir_itr != end_itr; ++dir_itr)
        {
                thePath = dir_itr->path().string();
                MakePathLocalToGlobalize(&thePath);
                if (is_regular_file(dir_itr->status()))
                {
                        if (dir_itr->filename().at(0) != '.') // skip over dot-files, which are invisible in Unix
                                filesToMove.push_back(thePath);
                }
                else if (is_directory(dir_itr->status()))
                {
                        if (!exists(strPathToPackages + strGlobalize + thePath))
                                foldersToMake.push_back(thePath);
                }
        }
        // Sort the foldersToMake strings by length, which is a fast solution to the problem of "How do we make sure we create folder 'parent/'...
        // ...before folder 'parent/child/'"?
        sort(foldersToMake.begin(), foldersToMake.end(), SortBySize); // SortBySize is a custom comparison function found later in this source file
        // First make the folders that don't exist in the current AE, so all the files have a place to go
        for (vector<string>::iterator iter = foldersToMake.begin(); iter != foldersToMake.end(); iter++)
        {
                create_directory(strPathToPackages + strGlobalize + *iter);
        }
        for (vector<string>::iterator iter = filesToMove.begin(); iter != filesToMove.end(); iter++)
        {
                if (exists(strPathToPackages + strGlobalize + *iter))
                        rename((path)(strPathToPackages + strGlobalize + *iter), (path)(strTrashDir + *iter));
                rename((path)(strPathToEUFNPackages + strGlobalize + *iter), (path)(strPathToPackages + strGlobalize + *iter));
        }
        
        // Clean up after ourselves, trashing any packages or programs in the update package that are not newer than the current AE
        create_directory(strTrashDir + "Unneeded update files");
        rename((path)strPathToEUFN, (path)(strTrashDir + "Unneeded update files/" + strEUFN));
        
        // Write to log that we are finished with update
        ptime end_time(second_clock::local_time());
        string progressMsg2 = "Edition was updated to:\n" +
                                                  updateAE->AEVersion + " on " + to_simple_string(end_time);
        
        file.open("Update.log");
        
        if(!file.fail())
                file.write(progressMsg2.c_str(), sizeof(progressMsg2.c_str()));
        
        file.close();
        file.clear();
        
        if (updateAE->globalizationRequired)
                CheckForGlobalization(true); // the 'true' value forces re-globalization
        
        globalPackages = getPackages(); // refresh the list in memory
        
        // TODO: Refresh the packages list in the window

        return true;
}

/* MakePathLocalToGlobalize is a function used once by ProcessAEUpdate() that takes a file in an        \
|  update's Globalize folder and changes its path, originally relative to the Installer, to be          |
|  relative to the structure of the Globalize folder; this makes it easier to have the Installer        |
\  move said file from an update's Globalize folder to the current Globalize folder.               */
void MakePathLocalToGlobalize(string *installerBasedPath)
{
        int deleteToHere = 0;
        deleteToHere = installerBasedPath->find("Globalize/");
        if (deleteToHere != 0)
        {
                deleteToHere += strlen("Globalize/");
                installerBasedPath->erase(0, deleteToHere);
        }
}

/* SortBySize is a custom comparison function that we call when using the C++ sort() function in \
\  ProcessAEUpdate() on some strings that we want to sort by length.                                                    */
bool SortBySize(string a, string b)
{
        return (a.size() < b.size());
}

//stolen token function...
void tokenize(const string& str, vector<string>& tokens, const string& delimiters)
{
        // Skip delimiters at beginning.
        string::size_type lastPos = str.find_first_not_of(delimiters, 0);
        // Find first "non-delimiter".
        string::size_type pos     = str.find_first_of(delimiters, lastPos);
        
        while (string::npos != pos || string::npos != lastPos)
        {
                // Found a token, add it to the vector.
                tokens.push_back(str.substr(lastPos, pos - lastPos));
                // Skip delimiters.  Note the "not_of"
                lastPos = str.find_first_not_of(delimiters, pos);
                // Find next "non-delimiter"
                pos = str.find_first_of(delimiters, lastPos);
        }
}

void clearOldDats(void) {
        directory_iterator end_iter_gdf;
        for ( directory_iterator dir_itr_gdf( "../GameDataFolder" );
                 dir_itr_gdf != end_iter_gdf;
                 ++dir_itr_gdf )
        {
                if ( dir_itr_gdf->path().extension() == ".dat" || dir_itr_gdf->path().extension() == ".raw" || dir_itr_gdf->path().extension() == ".sep" ) {
                        remove( dir_itr_gdf->path() );
                }
                
        }
        
}

// this function copies files and directories. If copying a 
// directory to a directory, it copies recursively. 

//pardon the mess, I did this at midnight, and had to fix a bug
void copy( const path & from_ph, 
                  const path & to_ph ) 
{ 
        cout << to_ph.string() << "\n";
        // Make sure that the destination, if it exists, is a directory 
        if((exists(to_ph) && !is_directory(to_ph)) || (!exists(from_ph))) cout << "error";
        if(!is_directory(from_ph)) 
        { 
                
                if(exists(to_ph)) 
                { 
                        copy_file(from_ph,to_ph/from_ph.filename()); 
                } 
                else 
                { 
                        try{
                                
                                copy_file(from_ph,to_ph);
                        }
                        catch (exception ex){
                                cout << from_ph.string() << " to " << to_ph.string() << "\n";
                        }
                }
                
        } 
        else if(from_ph.filename() != ".svn")
        { 
                path destination; 
                if(!exists(to_ph)) 
                { 
                        destination=to_ph; 
                } 
                else 
                { 
                        destination=to_ph/from_ph.filename(); 
                } 
                
                for(directory_iterator i(from_ph); i!=directory_iterator(); ++i) 
                { 
                        //the idiot who coded this in the first place (not me)
                        //forgot to make a new directory. Exception city. x_x
                        create_directory(destination); 
                        copy(*i,destination/i->filename()); 
                } 
        } 
} 

void copy_directory( const path &from_dir_ph, 
                                        const path &to_dir_ph) 
{ 
        if(!exists(from_dir_ph) || !is_directory(from_dir_ph) 
           || exists(to_dir_ph)) 
                cout << !exists(from_dir_ph) << " " << !is_directory(from_dir_ph) 
                << " " << exists(to_dir_ph);
        
# ifdef BOOST_POSIX 
        struct stat from_stat; 
        if ( (::stat( from_dir_ph.string().c_str(), &from_stat ) != 0) 
                || ::mkdir(to_dir_ph.native_directory_string().c_str(), 
                                   from_stat.st_mode)!=0) 
# endif 
                } 

string escapePath(string input)
{
        string output;
        string escape_me = "& ;()|<>\"'\\#*?$";
        for (unsigned int i = 0; i < input.size(); i++)
        {
                for (unsigned int j = 0; j < escape_me.size(); j++)
                        if (input[i] == escape_me[j])
                                output += '\\';
                output += input[i];
        }
        return output;
}

Install_info_cfg::Install_info_cfg()
{
        AEVersion = "2009-07b";
        InstallerVersion = "1.0.1";
        DaodanVersion = "1.0";
        OniSplitVersion = "0.9.38.0";
        WinGUIVersion = "0";
        MacGUIVersion = "0";
        patch = false;
        globalizationRequired = false;
        deleteList.reserve(255);
}

ModPackage::ModPackage()
{
        isInstalled = true; // replace with function 
        name = "";
        modStringName = "";
        modStringVersion = 0;
        hasOnis = false;
        hasDeltas = false;
        hasBSL = false;
        hasAddon = false;
        hasDats = false;
        category = "";
        creator = "";
        isEngine = false;
        readme = "";
        globalNeeded = true;
}

void Sleep(int ms)
{
        sleep(ms / 1000);
}

#ifdef WIN32

void RedirectIOToConsole()
{
        int hConHandle; 
        long lStdHandle;
        CONSOLE_SCREEN_BUFFER_INFO coninfo;
        FILE *fp;
        
        // allocate a console for this app
        AllocConsole();
        
        // set the screen buffer to be big enough to let us scroll text
        GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), 
                                                           &coninfo);
        coninfo.dwSize.Y = MAX_CONSOLE_LINES;
        SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), 
                                                           coninfo.dwSize);
        
        // redirect unbuffered STDOUT to the console
        lStdHandle = (long)GetStdHandle(STD_OUTPUT_HANDLE);
        hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
        fp = _fdopen( hConHandle, "w" );
        *stdout = *fp;
        setvbuf( stdout, NULL, _IONBF, 0 );
        
        // redirect unbuffered STDIN to the console
        lStdHandle = (long)GetStdHandle(STD_INPUT_HANDLE);
        hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
        fp = _fdopen( hConHandle, "r" );
        *stdin = *fp;
        setvbuf( stdin, NULL, _IONBF, 0 );
        
        // redirect unbuffered STDERR to the console
        lStdHandle = (long)GetStdHandle(STD_ERROR_HANDLE);
        hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
        fp = _fdopen( hConHandle, "w" );
        *stderr = *fp;
        setvbuf( stderr, NULL, _IONBF, 0 );
        
        // make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog 
        // point to console as well
        ios::sync_with_stdio();
}
#endif