/*
* 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 the License "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: 
*
*/



#define WIN32_LEAN_AND_MEAN 1

#ifdef _MSC_VER
#pragma warning (disable: 4786)
#endif // _MSC_VER

#include <windows.h>
#include <fstream>
#include <stdio.h>
#include <io.h>
#include <fcntl.h>
#include <iostream>
#include <sstream>
#include <sys/stat.h>

#include "logger.h"
#include "stringutils.h"
#include "is_utils.h"


int GetStat(const std::wstring& aFile, struct stat* s)
{
	return _wstat(aFile.c_str(), reinterpret_cast<struct _stat*>(s));
}

bool IsDirectory(std::wstring& aStr)
{
    bool ret = false;
    //
    if ( aStr.length() > 0 )
        {
	    struct stat x;
        //
	    int err = GetStat(aStr,&x );
        //
        if ( err != 0 )
            {
            wchar_t lastChar = aStr[ aStr.length() - 1 ];

            if ( lastChar == L'\\' || lastChar == '/' )
                {
                // Try again, but without the trailing backslash
                std::wstring path = aStr.substr( 0, aStr.length() - 1 );
                err = GetStat( path, &x );
                if ( err == 0 && (x.st_mode & S_IFDIR) > 0 )
                    {
                    aStr = path;
                    }
                }
            }
        //
        ret = ( err == 0 && (x.st_mode & S_IFDIR) > 0 );
        }
    //
	return ret;
}


bool FileExists(const std::wstring& aFile)
{
	struct stat x;
	int err = GetStat(aFile,&x );
	return err == 0; 
}


bool RemoveFile(const std::wstring& aFile)
{
	return _wunlink(aFile.c_str()) == 0;
}

void RemoveHashForFile(const std::wstring& aFile, const int aDriveLetter, const std::wstring& aPath)
{
	std::wstring hashdir = L"$:\\sys\\hash\\";
	std::wstring basename = aFile.substr( aFile.rfind( KDirectorySeparator ) + 1) ;
	if (basename.size() == 0)
	{
		basename = aFile.substr(aFile.rfind(L"\\"));
	}

	hashdir[0] = aDriveLetter;
	std::wstring hashFile = aPath + L"\\sys\\hash\\" + basename;
	if (FileExists(hashFile))
	{
		RemoveFile(hashFile);
	}
}

bool OpenFile(const std::wstring& aFile, std::fstream& aStream,
			  std::ios_base::open_mode aMode)
{
	std::string s;
	aStream.open(Ucs2ToUtf8(aFile, s).c_str(), aMode);
	return aStream.good();
}

bool MakeDir(const std::wstring& aDir)
{
	// This function makes all the directories in a subdirectory hierarchy.
  	// If the first character in aDir is a backslash, then we assume it refers
  	// to the root of a drive, hence we start the index below at 1 to skip over
  	// this initial root directory.
    size_t index = aDir.find(L':', 0);
    if(std::wstring::npos == index)
    	{
    	index = 0;
    	}
    else
    	{// Skip creation of root directory
    	index = aDir.find(L'\\', index);
    	}
	do
		{
    	index += 1;
		// Try to make each directory in the path. If ERR_ALREADY_EXISTS is returned
  	  	// then this is okay. Other errors are fatal.
		index = aDir.find(L'\\', index);
		std::wstring dir = aDir.substr( 0, index );
		if(dir == L".")
			{
			continue;
			}
		if (!CreateDirectory(dir.c_str(),0) && GetLastError() != ERROR_ALREADY_EXISTS)
            {
			int lastErr = GetLastError();
  	  	    (void) lastErr;
			return false;
            }

		} while (index != std::wstring::npos);

    return true;
	}

#ifndef _MSC_VER

void GetDirContents(const std::wstring& path, 
					std::list<std::wstring>& contents)
	{
	_WDIR* currDir =  _wopendir(path.c_str());
	if(currDir == NULL)
		{
		return;
		}
	
	_wdirent* currElem = _wreaddir(currDir);
	
	while (currElem)
		{
		contents.push_back(currElem->d_name);
		currElem = _wreaddir(currDir);
		}
	_wclosedir(currDir);
	}

#else

// missing structures for the posix directory calls 
struct dirent 
{
	wchar_t* d_name;
};

struct DIR 
{
	WIN32_FIND_DATA iWinData;
	HANDLE          iHandle;
	dirent          iEntry;
	std::wstring     iName;	
};

DIR* opendir(const wchar_t* dirname) 
	{
	static DIR dir;
	
	std::wstring s(dirname);
	std::wstring wildcard = strchr("/\\", s[s.length()-1]) ? L"*" : L"/*";
	dir.iName = s.append(wildcard);
	dir.iHandle = FindFirstFile(dir.iName.c_str(), &dir.iWinData);
	if (dir.iHandle != INVALID_HANDLE_VALUE )
		return &dir;
	else
		return 0;
	};


dirent* readdir(DIR* aDir)
{
	int result = FindNextFile(aDir->iHandle, &aDir->iWinData);
	if (result != 0)
	{
		aDir->iEntry.d_name = aDir->iWinData.cFileName;
		return &aDir->iEntry;
	}
	return 0;
}

void closedir(DIR* aDir)
{
	FindClose(aDir->iHandle);
	aDir = 0;
}


void GetDirContents(const std::wstring& path, 
					std::list<std::wstring>& contents)
{

	DIR* currDir =  opendir(path.c_str());
	
	while (currDir)
	{
		dirent* currElem = readdir(currDir);
		if (currElem == 0)
		{
			closedir(currDir);
			currDir = 0;
		}
		else
		{
			contents.push_back(currElem->d_name);
		}
	}
}

#endif



bool CheckSisRegistryDirPresent(const std::wstring& aDrivePath, TUint32 aUid)
{
    std::wstring ret = StringUtils::MakePathFromSID( aDrivePath + L"/sys/install/sisregistry/", aUid );

	return IsDirectory(ret);
}


int GetAugmentationsNumber(const std::wstring& aFile)
{
	for (int index = 1; index < 0xFFFFFFFF; index++)
	{
		std::wstringstream s2;
		s2 << std::hex << index;

		// e.g. 12345678_x.sis
		std::wstring fileName = aFile + s2.str() + L".sis";

		if ( !FileExists(fileName) )
		{
			// return the next available index
			return index;
		}
	}

	return 0;
}
std::string Utils::wstring2string (const std::wstring& aWide)
	{
	int max = WideCharToMultiByte(CP_OEMCP,0,aWide.c_str(),aWide.length(),0,0,0,0);
	std::string reply;
	if (max > 0 )
		{
		char* buffer = new char [max];
		try
			{
			WideCharToMultiByte(CP_OEMCP,0,aWide.c_str(),aWide.length(),buffer,max,0,0);
			reply = std::string (buffer, max);
			}
		catch (...)
			{
			}
		delete [] buffer;
		}
	return reply;
	}

std::wstring Utils::string2wstring (const std::string& aNarrow)
	{
	int max = MultiByteToWideChar(CP_OEMCP,0,aNarrow.c_str(),aNarrow.length(),0,0);
	std::wstring reply;
	if (max > 0 )
		{
		wchar_t* buffer = new wchar_t [max];
		try
			{
			MultiByteToWideChar(CP_OEMCP,0,aNarrow.c_str(),aNarrow.length(),buffer,max);
			reply = std::wstring (buffer, max);
			}
		catch (...)
			{
			}
		delete [] buffer;
		}
	return reply;
	}

const std::wstring Utils::IntegerToWideString(int aInt)
	{
	std::wstringstream wstream;
	wstream << aInt;
	return wstream.str();
	}

std::wstring Utils::Int64ToWideString(TInt64 aInt)
	{
	wchar_t wint[20];
	
#ifdef _MSC_VER
	swprintf(wint, L"%I64u", aInt);
#else
	swprintf(wint, 20, L"%I64u", aInt);
#endif // _MSC_VER
	
	std::wstring strInt64(wint);
	return strInt64;
	}

int Utils::WideStringToInteger(const std::wstring& aWideString)
	{
	unsigned long int value=0;
	std::wstringstream str(aWideString);
	str >> value;
	return value;
	}