/*

* Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  

*

*/

#include "CmdGlobals.h"

#ifdef __WIN__

#pragma warning(disable:4786)

#endif

#include <fstream>

#include <stdlib.h>

#include <string>

#include <map>

#include <iostream>

#include <sys/types.h>

#include <sys/stat.h>

#ifdef __WIN__

#include <io.h>

#include <windows.h>

#else

#include <unistd.h>

#include <glob.h>

#include <fcntl.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/param.h>

#include <unistd.h>

#define _MAX_PATH MAXPATHLEN

#endif

#include "BBCFileUtils.h"

#include "HAException.h"

#include "Utils.h"

#include "XMLUtils.h"

// ----------------------------------------------------------------------------

// BBCFileUtils::BBCFileUtils

// ----------------------------------------------------------------------------

//

BBCFileUtils::BBCFileUtils(string basedir)

{

    iBaseDir = basedir;

}

// ----------------------------------------------------------------------------

// BBCFileUtils::~BBCFileUtils

// ----------------------------------------------------------------------------

//

BBCFileUtils::~BBCFileUtils()

{

}

typedef int intptr_t;

// ----------------------------------------------------------------------------

// BBCFileUtils::getFilesInDir

// ----------------------------------------------------------------------------

//

list<pair<string, string> > BBCFileUtils::getFilesInDir(string wildcard, string aRelPath)

{

    // START -- Support for multiple header directories

    list<pair<string, string> > ret;

    list<pair<string, string> > dirs = BBCFileUtils::extractFilenames(iBaseDir);

    list<pair<string, string> >::iterator dirbegin = dirs.begin();

    for(; dirbegin != dirs.end(); dirbegin++)

    {

    // END -- Support for multiple header directories

        string basedir = BBCFileUtils::getFullPath(dirbegin->first);

        if (aRelPath != "")

        {

            iWildcard = basedir + DIR_SEPARATOR + aRelPath + DIR_SEPARATOR + wildcard;

        } else

        {

            iWildcard = basedir + DIR_SEPARATOR + wildcard;

        }

    // search for all files which were specified in wildcard string

#ifdef __WIN__

        _finddata_t finddata;

        intptr_t searchsession =_findfirst(iWildcard.c_str(),&finddata);

        int found = -1;

        if (searchsession > 0)

        {

            found = 0;

        }

        while (found == 0)

        {

            string path;

            if (aRelPath != "")

            {

                path = DIR_SEPARATOR + aRelPath + DIR_SEPARATOR + string(finddata.name);

            } else

            {

                path = DIR_SEPARATOR + string(finddata.name);

            }

            string fullpath = basedir + path;

            if (isValidFilename(fullpath))

            {

                pair<string, string> tempval(path, toLowerCaseWin(path));

                ret.push_back(tempval);

            }

            found = _findnext(searchsession, &finddata);

        }

        _findclose(searchsession);

#else

        glob_t p_glob;

        glob(iWildcard.c_str() , 0, NULL, &p_glob);    

        for (unsigned int i = 0; i < p_glob.gl_pathc; i++ )

        {

            string path = p_glob.gl_pathv[i];

            if (isValidFilename(path))

            {

                path = StripPath(path);

                if (aRelPath != "")

                {

                    path = aRelPath + DIR_SEPARATOR + path;

                }

                path = DIR_SEPARATOR + path;

                pair<string, string> tempval(path, toLowerCaseWin(path));

                ret.push_back(tempval);

            }

        }  

        globfree(&p_glob);

#endif

    }

    return ret;

}

// ----------------------------------------------------------------------------

// BBCFileUtils::getFilesInDir

// ----------------------------------------------------------------------------

//

list<pair<string,string> > BBCFileUtils::getFilesInDir(list<pair<string, string> >& fileset, string aRelPath, list<pair<string, string> >& aFoundfiles)

{

    // START -- Support for multiple header directories

    list<pair<string, string> > ret;

    list<pair<string, string> > notfound;

    list<pair<string, string> > dirs = BBCFileUtils::extractFilenames(iBaseDir);

    list<pair<string, string> >::iterator dirbegin = dirs.begin();

    for(; dirbegin != dirs.end(); dirbegin++)

    {

        // END -- Support for multiple header directories

        string basedir = BBCFileUtils::getFullPath(dirbegin->first);

        if (aRelPath != "")

        {

            iWildcard = basedir + DIR_SEPARATOR + aRelPath + DIR_SEPARATOR + WILDCARD_ALLFILES;

        } else

        {

            iWildcard = basedir + DIR_SEPARATOR + WILDCARD_ALLFILES;

        }

    // Search for all files which were specified in wildcard string

#ifdef __WIN__

        _finddata_t finddata;

        intptr_t searchsession =_findfirst(iWildcard.c_str(),&finddata);

        int found = -1;

        if (searchsession > 0)

        {

            found = 0;

        }

        while (found == 0)

        {

            string filename = DIR_SEPARATOR + string(finddata.name);

            if (aRelPath != "")

            {

                filename = DIR_SEPARATOR + aRelPath + filename;

            }

            string fullpath = basedir + filename;

            // Check if path is pointing to a file

            if (isValidFilename(fullpath))

            {

                list<pair<string, string> >::iterator file = FindFromList(toLowerCaseWin(filename), fileset, ERightValue);

                if (file == fileset.end() && aRelPath != "")

                {

                    file = FindFromList(toLowerCaseWin(finddata.name), fileset, ERightValue);

                }

                if (file != fileset.end())

                {

                    pair<string, string> tempval;

                    tempval.first = filename;

                    tempval.second = toLowerCaseWin(filename);

                    ret.push_back(tempval);

                    aFoundfiles.push_back(*file);

                    fileset.erase(file);

                } else if (aRelPath == "")

                {

                    pair<string, string> tempvar(filename, toLowerCaseWin(filename));

                    notfound.push_back(tempvar);

                } else

                {

                    list<pair<string, string> >::iterator alreadyfound = FindFromList(toLowerCaseWin(finddata.name), aFoundfiles, ERightValue);

                    if (alreadyfound != aFoundfiles.end())

                    {

                        cout << "Warning: More than one files matches for the given filename '" << finddata.name;

                        cout << "' in the file set, only the first file is used." << endl;

                        aFoundfiles.erase(alreadyfound);

                    }

                }

            }

            found = _findnext(searchsession, &finddata);

        }

        _findclose(searchsession);

#else

        glob_t p_glob;

        int result = glob(iWildcard.c_str() , 0, NULL, &p_glob);    

        if (result == 0)

        {

            for ( unsigned int i = 0; i < p_glob.gl_pathc; i++ )

            {

                string path = p_glob.gl_pathv[i];

                // Check if path is pointing to a file

                if (isValidFilename(path))

                {

                    string filename = DIR_SEPARATOR + StripPath(path);

                    string pathfile = "";

                    if (aRelPath != "")

                    {

                        pathfile = DIR_SEPARATOR + aRelPath + filename;

                    } else

                    {

                        pathfile = filename;

                    }

                    list<pair<string, string> >::iterator file = FindFromList(toLowerCaseWin(pathfile), fileset,ERightValue);

                    if (file == fileset.end() && aRelPath != "")

                    {

                        file = FindFromList(toLowerCaseWin(filename.substr(1)), fileset,ERightValue);

                    }

                    if (file != fileset.end())

                    {

                        pair<string, string> tempval;

                        tempval.first = pathfile;

                        tempval.second = toLowerCaseWin(pathfile);

                        ret.push_back(tempval);

                        aFoundfiles.push_back(*file);

                        fileset.erase(file);

                    } else if (aRelPath == "")

                    {

                        pair<string, string> tempvar(pathfile, toLowerCaseWin(pathfile));

                        notfound.push_back(tempvar);

                    } else

                    {

                        list<pair<string, string> >::iterator alreadyfound = FindFromList(toLowerCaseWin(filename.substr(1)), aFoundfiles,ERightValue);

                        if (alreadyfound != aFoundfiles.end())

                        {

                            cout << "Warning: More than one files matches for the given filename '" << filename.substr(1);

                            cout << "' in the file set, only the first file is used.";

                            aFoundfiles.erase(alreadyfound);

                        }

                    }

                }

            }

            globfree(&p_glob);

        }

#endif

    }

    if (notfound.size() != 0)

    {

        list<pair<string, string> >::iterator file = notfound.begin();

        list<pair<string, string> >::iterator fileend = notfound.end();

        for(; file != fileend; file++)

        {

            string filename = file->second.substr(1);

            list<pair<string, string> >::iterator file = FindFromList(filename, fileset, ERightValue);

            if (file != fileset.end())

            {

                pair<string, string> tempval;

                tempval.first = DIR_SEPARATOR + file->first;

                tempval.second = DIR_SEPARATOR + file->second;

                ret.push_back(tempval);

                aFoundfiles.push_back(*file);

                fileset.erase(file);

            } else

            {

                list<pair<string, string> >::iterator alreadyfound = FindFromList(filename, aFoundfiles, ERightValue);

                if (alreadyfound != aFoundfiles.end())

                {

                    cout << "Warning: More than one files matches for the given filename '" << filename;

                    cout << "' in the file set, only the first file is used." << endl;

                    aFoundfiles.erase(alreadyfound);

                }

            }

        }

    }

    ret.sort();

    return ret;

}

// ----------------------------------------------------------------------------

// BBCFileUtils::setTemp

// Set temp dir

// ----------------------------------------------------------------------------

//

void BBCFileUtils::setTemp(const string& aTempDir)

{

    iTempDir = aTempDir;

}

// ----------------------------------------------------------------------------

// BBCFileUtils::getFilesInDir

// Calculates quite unique fingerprint for a string.

// ----------------------------------------------------------------------------

//

unsigned int BBCFileUtils::quickHash(string str)

{

    int ret = 0;

    unsigned int len = (unsigned int)str.length();

    for (unsigned int i = 0; i < len; i++)

    {

        ret += (i+1) * str.at(i);

    }

    return ret;

}

// ----------------------------------------------------------------------------

// BBCFileUtils::trimFilenames

// 

// ----------------------------------------------------------------------------

//

/*

string BBCFileUtils::trimFilenames(string aFilenameList)

{

    string ret("");

    unsigned int i = 0;

    for (; i < aFilenameList.length(); i++)

    {

        char ch = aFilenameList.at(i);

        if (ch != ';')

        {

            ret += ch;

        } else 

        {

            ret += ' ';

        }

    }

    return ret;

}

*/

// ----------------------------------------------------------------------------

// BBCFileUtils::extractFilenames

// Extract filenames to string list 

// ----------------------------------------------------------------------------

//

list<pair<string, string> > BBCFileUtils::extractFilenames(string aFilenameList)

{

    size_t i = 0;

    list<pair<string, string> > ret;

    string current("");

    for (; i < aFilenameList.length(); i++)

    {

        char ch = aFilenameList.at(i);

        if (ch != ';')

        {

            current += ch;

        } else

        {

            pair<string, string> tempvar(current, toLowerCaseWin(current));

            ret.push_back(tempvar);

            current = "";

        }

    }

    if (current.length() > 0)

    {

        pair<string, string> tempvar(current, toLowerCaseWin(current));

        ret.push_back(tempvar);

    }

    return ret;

}

// ----------------------------------------------------------------------------

// BBCFileUtils::isValidFilename

// Check if the given filename is valid

// ----------------------------------------------------------------------------

//

bool BBCFileUtils::isValidFilename(const string& aFilename)

{

    bool valid = true;

    if (aFilename.length() < 1)

    {

        valid = false;

    }

    struct stat stats;

    int fSuccess = stat(aFilename.c_str(), &stats);

    // Check if path is pointing to a directory

    if (fSuccess == -1)

    {

        valid = false;

    } else if ((stats.st_mode & S_IFDIR) != 0)

    {

        valid = false;

    }

    return valid;

}

// ----------------------------------------------------------------------------

// BBCFileUtils::isValidDirectory

// Check if the given path is valid directory

// ----------------------------------------------------------------------------

//

bool BBCFileUtils::isValidDirectory(const string& aPath)

{

    bool valid = true;

    if (aPath.length() < 1)

    {

        valid = false;

    }

    struct stat stats;

    int fSuccess = stat(aPath.c_str(), &stats);

    // Check if path is pointing to a directory

    if (fSuccess == -1)

    {

        valid = false;

    } else if ((stats.st_mode & S_IFDIR) == 0)

    {

        valid = false;

    }

    return valid;

}

// ----------------------------------------------------------------------------

// BBCFileUtils::getFullPath

// Check if the given path is valid directory

// ----------------------------------------------------------------------------

//

string BBCFileUtils::getFullPath(const string& aPath)

{

    string ret;

#ifdef __WIN__

    char temppath[_MAX_PATH+2];

    char * filepart = NULL;

    GetFullPathName(aPath.c_str(), _MAX_PATH, temppath, &filepart);

    ret = temppath;

#else

    string path = aPath;

    string filename;

    struct stat statinfo;

    if ( 0 != stat(aPath.c_str(),&statinfo) )

    {

    filename = StripPath(aPath.c_str());

    path = aPath.substr(0,aPath.size()-filename.size());

    }

    if (path.size() == 0)

    {

        path = ".";

    }

    if ( !absolutePath(path,ret) )

    {

            throw HAException("Internal error: Error parsing path.");

    }

    if (filename.size())

    {

    ret += DIR_SEPARATOR;

    ret += filename;

    }

#endif

    return ret;

}

#ifdef __UNIX__

// ----------------------------------------------------------------------------

// BBCFileUtils::absolutePath

// Get full path

// ----------------------------------------------------------------------------

//

bool BBCFileUtils::absolutePath(const string& aRelpath, string& aAbspath)

{

    char* base = new char[_MAX_PATH+1];

    char* home;

    getcwd(base, _MAX_PATH);

    home = getenv("HOME");

    aAbspath = base;

    if (aRelpath.length() == 0)

    {

        aAbspath = "";

        return false;

    }

    vector<string> splittedabspath = splitString(aAbspath, '/');

    vector<string> splittedrelpath = splitString(aRelpath, '/');

    vector<string> splittedhomepath = splitString(home, '/');

    int longest;

    if (splittedabspath.size() > splittedhomepath.size())

    {

        longest = splittedabspath.size();

    } else

    {

        longest = splittedhomepath.size();

    }

    splittedabspath.reserve(longest + splittedrelpath.size());

    if (splittedrelpath.at(0) == "")

    {

        splittedabspath.clear();

        if (splittedrelpath.at(1) == "")

        {

            splittedabspath.push_back("");

            splittedabspath.push_back("");

        }

    }

    if (splittedrelpath.at(0) == "~")