/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "hsStream.h"
#include "plFile/hsFiles.h"

#include "PythonInterface.h"

#include <vector>
#include <string>
#include <algorithm>

#include <direct.h>

static const char* kPackFileName = "python.pak";
static const char* kGlueFile = ".\\plasma\\glue.py";
static char* glueFile = (char*)kGlueFile;

void WritePythonFile(std::string fileName, std::string path, hsStream *s)
{
    hsUNIXStream pyStream, glueStream;
    std::string filePath;
    size_t filestart = fileName.find_last_of('.');
    if(filestart != std::string::npos)
        filePath = fileName.substr(filestart+1, std::string::npos);
    else
        filePath = fileName;
    filePath += ".py";
    filePath = path + filePath;

    if (!pyStream.Open(filePath.c_str()) || !glueStream.Open(glueFile))
    {
        printf("Unable to open path %s, ",filePath.c_str());
        return;
    }

    printf("==Packing %s, ",fileName.c_str());

    pyStream.FastFwd();
    UInt32 pyFileSize = pyStream.GetPosition();
    pyStream.Rewind();

    glueStream.FastFwd();
    UInt32 glueFileSize = glueStream.GetPosition();
    glueStream.Rewind();

    UInt32 totalSize = pyFileSize + glueFileSize + 2;

    char *code = new char[totalSize];

    UInt32 amountRead = pyStream.Read(pyFileSize, code);
    hsAssert(amountRead == pyFileSize, "Bad read");

    code[pyFileSize] = '\n';

    amountRead = glueStream.Read(glueFileSize, code+pyFileSize+1);
    hsAssert(amountRead == glueFileSize, "Bad read");

    code[totalSize-1] = '\0';

    // remove the CRs, they seem to give Python heartburn
    int k = 0;
    for (int i = 0; i < totalSize; i++)
    {
        if (code[i] != '\r')    // is it not a CR?
            code[k++] = code[i];
        // else
        //   skip the CRs
    }

    // import the module first, to make packages work correctly
    PyImport_ImportModule((char*)fileName.c_str());
    PyObject* pythonCode = PythonInterface::CompileString(code, (char*)fileName.c_str());
    if (pythonCode)
    {
        // we need to find out if this is PythonFile module
        // create a module name... with the '.' as an X
        // and create a python file name that is without the ".py"
        PyObject* fModule = PythonInterface::CreateModule((char*)fileName.c_str());
        // run the code
        if (PythonInterface::RunPYC(pythonCode, fModule) )
        {
    // set the name of the file (in the global dictionary of the module)
            PyObject* dict = PyModule_GetDict(fModule);
            PyObject* pfilename = PyString_FromString(fileName.c_str());
            PyDict_SetItemString(dict, "glue_name", pfilename);
    // next we need to:
    //  - create instance of class
            PyObject* getID = PythonInterface::GetModuleItem("glue_getBlockID",fModule);
            hsBool foundID = false;
            if ( getID!=nil && PyCallable_Check(getID) )
            {
                PyObject* id = PyObject_CallFunction(getID,nil);
                if ( id && PyInt_Check(id) )
                    foundID = true;
            }
            if ( foundID == false )     // then there was an error or no ID or somethin'
            {
                // oops, this is not a PythonFile modifier
                // re-read the source and compile it without the glue code this time
                pyStream.Rewind();
                amountRead = pyStream.Read(pyFileSize, code);
                hsAssert(amountRead == pyFileSize, "Bad read");
                code[amountRead] = '\n';
                code[amountRead+1] = '\0';
                k = 0;
                int len = strlen(code)+1;
                for (int i = 0; i < len; i++)
                {
                    if (code[i] != '\r')    // is it not a CR?
                        code[k++] = code[i];
                    // else
                    //   skip the CRs
                }
                pythonCode = PythonInterface::CompileString(code, (char*)fileName.c_str());
                hsAssert(pythonCode,"Not sure why this didn't compile the second time???");
                printf("an import file ");
            }
            else
                printf("a PythonFile modifier(tm) ");
        }
        else
        {
            printf("......blast! Error during run-code!\n");

            char* errmsg;
            int chars_read = PythonInterface::getOutputAndReset(&errmsg);
            if (chars_read > 0)
            {
                printf(errmsg);
                printf("\n");
            }
        }
    }

    // make sure that we have code to save
    if (pythonCode)
    {
        Int32 size;
        char* pycode;
        PythonInterface::DumpObject(pythonCode,&pycode,&size);

        printf("\n");
        // print any message after each module
        char* errmsg;
        int chars_read = PythonInterface::getOutputAndReset(&errmsg);
        if (chars_read > 0)
        {
            printf(errmsg);
            printf("\n");
        }
        s->WriteSwap32(size);
        s->Write(size, pycode);
    }
    else
    {
        printf("......blast! Compile error!\n");
        s->WriteSwap32(0);

        PyErr_Print();
        PyErr_Clear();

        char* errmsg;
        int chars_read = PythonInterface::getOutputAndReset(&errmsg);
        if (chars_read > 0)
        {
            printf(errmsg);
        }
    }

    delete [] code;

    pyStream.Close();
    glueStream.Close();
}

void FindFiles(std::vector<std::string> &filenames, std::vector<std::string> &pathnames, const char* path)
{
    // Get the names of all the python files
    hsFolderIterator folder;

    // if there is a path... set it
    if ( path )
        folder.SetPath(path);

    while (folder.NextFileSuffix(".py"))
    {
        const char *fileName = folder.GetFileName();
        filenames.push_back(fileName);
        if ( path )
            pathnames.push_back(path);
        else
            pathnames.push_back("");
    }
}

std::string ToLowerCase(std::string str)
{
    std::string retVal = "";
    for (int i=0; i<str.length(); i++)
    {
        if ((str[i]>='A')&&(str[i]<='Z'))
            retVal += (char)tolower(str[i]);
        else
            retVal += str[i];
    }
    return retVal;
}

void FindSubDirs(std::vector<std::string> &dirnames, const char *path)
{
    hsFolderIterator folder;
    if (path)
        folder.SetPath(path);

    while (folder.NextFile())
    {
        if (folder.IsDirectory())
        {
            std::string dirName = folder.GetFileName();
            if ((dirName != ".")&&(dirName != "..")&&(ToLowerCase(dirName) != "system") && (ToLowerCase(dirName) != "plasma"))
            {
                dirnames.push_back(dirName);
            }
        }
    }
}

// adds or removes the ending slash in a path as necessary
std::string AdjustEndingSlash(std::string path, bool endingSlash = false)
{
    std::string retVal = path;
    bool endSlashExists = false;
    char temp = path[path.length()-1];
    if (temp == '\\')
        endSlashExists = true;

    if (endingSlash)
    {
        if (!endSlashExists)
            retVal += "\\";
    }
    else
    {
        if (endSlashExists)
        {
            std::string temp = "";
            for (int i=0; i<retVal.length()-1; i++)
                temp += retVal[i];
            retVal = temp;
        }
    }
    return retVal;
}

// appends partialPath onto the end of fullPath, inserting or removing slashes as necesssary
std::string ConcatDirs(std::string fullPath, std::string partialPath)
{
    bool fullSlash = false, partialSlash = false;
    char temp = fullPath[fullPath.length()-1];
    if (temp == '\\')
        fullSlash = true;
    temp = partialPath[0];
    if (temp == '\\')
        partialSlash = true;

    std::string retVal = "";
    if (!fullSlash)
        retVal = fullPath + "\\";
    if (partialSlash)
    {
        std::string temp = "";
        for (int i=1; i<partialPath.length(); i++)
            temp += partialPath[i];
        partialPath = temp;
    }
    retVal += partialPath;
    return retVal;
}

void FindPackages(std::vector<std::string>& fileNames, std::vector<std::string>& pathNames, const char* path, std::string parent_package="")
{
    std::vector<std::string> packages;
    FindSubDirs(packages, path);
    for (int i = 0; i < packages.size(); i++)
    {
        std::string packageName;
        if(!parent_package.empty())
            packageName = parent_package + ".";
        packageName += packages[i];
        std::vector<std::string> packageFileNames;
        std::vector<std::string> packagePathNames;
        std::string packagePath = path;
        packagePath += "/" + packages[i];
        FindFiles(packageFileNames, packagePathNames, packagePath.c_str());
        for (int j = 0; j < packageFileNames.size(); j++) {
            fileNames.push_back(packageName+"."+packageFileNames[j]);
            pathNames.push_back(packagePathNames[j]+"/");
        }
        FindPackages(fileNames, pathNames, packagePath.c_str(), packageName);
    }
}

void PackDirectory(std::string dir, std::string rootPath, std::string pakName, std::vector<std::string>& extraDirs, bool packSysAndPlasma = false)
{
    // make sure the dir ends in a slash
    dir = AdjustEndingSlash(dir,true);

    printf("\nCreating %s using the contents of %s\n",pakName.c_str(),dir.c_str());
    printf("Changing working directory to %s\n",rootPath.c_str());
    if (_chdir(rootPath.c_str()))
    {
        printf("ERROR: Directory change to %s failed for some reason\n",rootPath.c_str());
        printf("Unable to continue with the packing of this directory, aborting...\n");
        return;
    }
    else
        printf("Directory changed to %s\n",rootPath.c_str());

    std::vector<std::string> fileNames;
    std::vector<std::string> pathNames;

    FindFiles(fileNames,pathNames,dir.c_str());
    FindPackages(fileNames,pathNames,dir.c_str());
    if (packSysAndPlasma)
    {
        printf("Adding the system and plasma directories to this pack file\n");
        std::string tempPath;
        tempPath = dir + "system/";
        FindFiles(fileNames,pathNames,tempPath.c_str());
        FindPackages(fileNames,pathNames,tempPath.c_str());
        tempPath = dir + "plasma/";
        FindFiles(fileNames,pathNames,tempPath.c_str());
        FindPackages(fileNames,pathNames,tempPath.c_str());
    }


    // ok, we know how many files we're gonna pack, so make a fake index (we'll fill in later)
    hsUNIXStream s;
    if (!s.Open(pakName.c_str(), "wb"))
        return;

    s.WriteSwap32(fileNames.size());

    int i;
    for (i = 0; i < fileNames.size(); i++)
    {
        s.WriteSafeString(fileNames[i].c_str());
        s.WriteSwap32(0);
    }

    PythonInterface::initPython(rootPath);
    for (i = 0; i < extraDirs.size(); i++)
        PythonInterface::addPythonPath(rootPath + extraDirs[i]);

    // set to maximum optimization (includes removing __doc__ strings)
    Py_OptimizeFlag = 2;

    std::vector<UInt32> filePositions;
    filePositions.resize(fileNames.size());

    for (i = 0; i < fileNames.size(); i++)
    {
        // strip '.py' from the file name
        std::string properFileName = fileNames[i].substr(0, fileNames[i].size()-3);
        UInt32 initialPos = s.GetPosition();
        WritePythonFile(properFileName, pathNames[i], &s);
        UInt32 endPos = s.GetPosition();

        filePositions[i] = initialPos;
    }

    s.SetPosition(sizeof(UInt32));
    for (i = 0; i < fileNames.size(); i++)
    {
        s.WriteSafeString(fileNames[i].c_str());
        s.WriteSwap32(filePositions[i]);
    }

    s.Close();

    PythonInterface::finiPython();
}

void PrintUsage()
{
    printf("Usage:\n");
    printf("plPythonPack [directory to pack...]\n");
    printf("NOTE: the directory to pack must have full system and plasma dirs and\n");
    printf("      must be a relative path to the current working directory\n");
}

void main(int argc, char *argv[])
{
    printf("The Python Pack Utility\n");

    char buffer[_MAX_PATH];
    _getcwd(buffer,_MAX_PATH);
    std::string baseWorkingDir = buffer;

    // are they asking for usage?
    if (argc == 2)
    {
        std::string temp = argv[1];
        temp = ToLowerCase(temp);
        if ((temp == "?") || (temp == "-?") || (temp == "/?") || (temp == "-help") || (temp == "/help")
            || (temp == "-h") || (temp == "/h"))
        {
            PrintUsage();
            return;
        }
    }
    // wrong number of args, print usage
    if (argc > 2)
    {
        PrintUsage();
        return;
    }

    std::vector<std::string> dirNames;
    std::string rootPath;

    if (argc == 1)
    {
        FindSubDirs(dirNames,nil);
        rootPath = AdjustEndingSlash(baseWorkingDir,true);
    }
    else
    {
        std::string path = argv[1];
        FindSubDirs(dirNames,argv[1]);
        rootPath = ConcatDirs(baseWorkingDir,path);
        rootPath = AdjustEndingSlash(rootPath,true);
    }
    
    PackDirectory(rootPath,rootPath,rootPath+kPackFileName,dirNames,true);
    for (int i=0; i<dirNames.size(); i++)
    {
        PackDirectory(dirNames[i],rootPath,rootPath+dirNames[i]+".pak",dirNames);
    }
}