/**

 * vim: set ts=4 :

 * =============================================================================

 * SourceMod

 * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.

 * =============================================================================

 *

 * This program is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License, version 3.0, as published by the

 * Free Software Foundation.

 * 

 * 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/>.

 *

 * As a special exception, AlliedModders LLC gives you permission to link the

 * code of this program (as well as its derivative works) to "Half-Life 2," the

 * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

 * by the Valve Corporation.  You must obey the GNU General Public License in

 * all respects for all other code used.  Additionally, AlliedModders LLC grants

 * this exception to all derivative works.  AlliedModders LLC defines further

 * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

 * or <http://www.sourcemod.net/license.php>.

 *

 * Version: $Id$

 */

#include <sys/stat.h>

#include <stdio.h>

#include <stdarg.h>

#include <string.h>

#include <sm_platform.h>

#include "sm_stringutil.h"

#include "LibrarySys.h"

LibrarySystem g_LibSys;

CLibrary::~CLibrary()

{

	if (m_lib)

	{

#if defined PLATFORM_WINDOWS

		FreeLibrary(m_lib);

#elif defined PLATFORM_POSIX

		dlclose(m_lib);

#endif

		m_lib = NULL;

	}

}

CLibrary::CLibrary(LibraryHandle me)

{

	m_lib = me;

}

void CLibrary::CloseLibrary()

{

	delete this;

}

void *CLibrary::GetSymbolAddress(const char *symname)

{

#if defined PLATFORM_WINDOWS

	return GetProcAddress(m_lib, symname);

#elif defined PLATFORM_POSIX

	return dlsym(m_lib, symname);

#endif

}

/********************

 ** Directory Code **

 ********************/

CDirectory::CDirectory(const char *path)

{

#if defined PLATFORM_WINDOWS

	char newpath[PLATFORM_MAX_PATH];

	snprintf(newpath, sizeof(newpath), "%s\\*.*", path);

	m_dir = FindFirstFileA(newpath, &m_fd);

	if (!IsValid())

	{

		m_fd.cFileName[0] = '\0';

	}

#elif defined PLATFORM_POSIX

	m_dir = opendir(path);

	if (IsValid())

	{

		/* :TODO: we need to read past "." and ".."! */

		ep = readdir(m_dir);

		snprintf(m_origpath, PLATFORM_MAX_PATH, "%s", path);

	} else {

		ep = NULL;

	}

#endif

}

CDirectory::~CDirectory()

{

	if (IsValid())

	{

#if defined PLATFORM_WINDOWS

		FindClose(m_dir);

#elif defined PLATFORM_POSIX

		closedir(m_dir);

#endif

	}

}

void CDirectory::NextEntry()

{

#if defined PLATFORM_WINDOWS

	if (FindNextFile(m_dir, &m_fd) == 0)

	{

		FindClose(m_dir);

		m_dir = INVALID_HANDLE_VALUE;

	}

#elif defined PLATFORM_POSIX

	if ((ep=readdir(m_dir)) == NULL)

	{

		closedir(m_dir);

		m_dir = NULL;

	}

#endif

}

bool CDirectory::IsEntryValid()

{

	return IsValid();

}

bool CDirectory::IsEntryDirectory()

{

#if defined PLATFORM_WINDOWS

	return ((m_fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY);

#elif defined PLATFORM_POSIX

	char temppath[PLATFORM_MAX_PATH];

	snprintf(temppath, sizeof(temppath), "%s/%s", m_origpath, GetEntryName());

	return g_LibSys.IsPathDirectory(temppath);

#endif

}

bool CDirectory::IsEntryFile()

{

#if defined PLATFORM_WINDOWS

	return !(m_fd.dwFileAttributes & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_DEVICE));

#elif defined PLATFORM_POSIX

	char temppath[PLATFORM_MAX_PATH];

	snprintf(temppath, sizeof(temppath), "%s/%s", m_origpath, GetEntryName());

	return g_LibSys.IsPathFile(temppath);

#endif

}

const char *CDirectory::GetEntryName()

{

#if defined PLATFORM_WINDOWS

	return m_fd.cFileName;

#elif defined PLATFORM_POSIX

	return ep ? ep->d_name : "";

#endif

}

bool CDirectory::MoreFiles()

{

	return IsValid();

}

bool CDirectory::IsValid()

{

#if defined PLATFORM_WINDOWS

	return (m_dir != INVALID_HANDLE_VALUE);

#elif defined PLATFORM_POSIX

	return (m_dir != NULL);

#endif

}

/*************************

 ** Library System Code **

 *************************/

bool LibrarySystem::PathExists(const char *path)

{

#if defined PLATFORM_WINDOWS

	DWORD attr = GetFileAttributesA(path);

	return (attr != INVALID_FILE_ATTRIBUTES);

#elif defined PLATFORM_POSIX

	struct stat s;

	return (stat(path, &s) == 0);

#endif

}

bool LibrarySystem::IsPathFile(const char *path)

{

#if defined PLATFORM_WINDOWS

	DWORD attr = GetFileAttributes(path);

	if (attr == INVALID_FILE_ATTRIBUTES)

	{

		return false;

	}

	if (attr & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_DEVICE))

	{

		return false;

	}

	return true;

#elif defined PLATFORM_POSIX

	struct stat s;

	if (stat(path, &s) != 0)

	{

		return false;

	}

	return S_ISREG(s.st_mode) ? true : false;

#endif

}

bool LibrarySystem::IsPathDirectory(const char *path)

{

#if defined PLATFORM_WINDOWS

	DWORD attr = GetFileAttributes(path);

	if (attr == INVALID_FILE_ATTRIBUTES)

	{

		return false;

	}

	if (attr & FILE_ATTRIBUTE_DIRECTORY)

	{

		return true;

	}

#elif defined PLATFORM_LINUX

	struct stat s;

	if (stat(path, &s) != 0)

	{

		return false;

	}

	if (S_ISDIR(s.st_mode))

	{

		return true;

	}

#endif

	return false;

}

IDirectory *LibrarySystem::OpenDirectory(const char *path)

{

	CDirectory *dir = new CDirectory(path);

	if (!dir->IsValid())

	{

		delete dir;

		return NULL;

	}

	return dir;

}

void LibrarySystem::GetPlatformError(char *error, size_t maxlength)

{

#if defined PLATFORM_WINDOWS

	return GetPlatformErrorEx(GetLastError(), error, maxlength);

#elif defined PLATFORM_POSIX

	return GetPlatformErrorEx(errno, error, maxlength);

#endif

}

void LibrarySystem::GetPlatformErrorEx(int code, char *error, size_t maxlength)

{

	if (error && maxlength)

	{

#if defined PLATFORM_WINDOWS

		FormatMessageA(

			FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,

			NULL,

			(DWORD)code,

			MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),

			(LPSTR)error,

			maxlength,

			NULL);

#elif defined PLATFORM_LINUX

		const char *ae = strerror_r(code, error, maxlength);

		if (ae != error)

		{

			UTIL_Format(error, maxlength, "%s", ae);

		}

#elif defined PLATFORM_POSIX

		strerror_r(code, error, maxlength);

#endif

	}

}

void LibrarySystem::GetLoaderError(char *buffer, size_t maxlength)

{

#if defined PLATFORM_WINDOWS

	GetPlatformError(buffer, maxlength);

#elif defined PLATFORM_POSIX

	if (buffer != NULL && maxlength)

	{

		strncopy(buffer, dlerror(), maxlength);

	}

#endif

}

void LibrarySystem::CloseDirectory(IDirectory *dir)

{

	delete dir;

}

ILibrary *LibrarySystem::OpenLibrary(const char *path, char *error, size_t maxlength)

{

	LibraryHandle lib;

#if defined PLATFORM_WINDOWS

	lib = LoadLibraryA(path);

#elif defined PLATFORM_POSIX

	lib = dlopen(path, RTLD_NOW);

#endif

	if (lib == NULL)

	{

		GetLoaderError(error, maxlength);

		return NULL;

	}

	return new CLibrary(lib);

}

size_t LibrarySystem::PathFormat(char *buffer, size_t len, const char *fmt, ...)

{

	va_list ap;

	va_start(ap, fmt);

	size_t mylen = vsnprintf(buffer, len, fmt, ap);

	va_end(ap);

	if (mylen >= len)

	{

		mylen = len - 1;

		buffer[mylen] = '\0';

	}

	for (size_t i=0; i<mylen; i++)

	{

		if (buffer[i] == PLATFORM_SEP_ALTCHAR)

		{

			buffer[i] = PLATFORM_SEP_CHAR;

		}

	}

	return mylen;

}

const char *LibrarySystem::GetFileExtension(const char *filename)

{

	size_t len, end;

	len = strlen(filename);

	/* Minimum string length for filename with ext would be 3; example: a.a */

	if (len < 3)

	{

		return NULL;

	}

	end = len - 1;

	for (size_t i = end; i <= end; i--)

	{

		if (filename[i] == PLATFORM_SEP_CHAR || filename[i] == PLATFORM_SEP_ALTCHAR)

		{

			break;

		}

		if (filename[i] == '.' && i != end && i != 0)

		{

			return &filename[++i];

		}

	}

	return NULL;

}

bool LibrarySystem::CreateFolder(const char *path)

{

#if defined PLATFORM_WINDOWS

	return (mkdir(path) != -1);

#elif defined PLATFORM_POSIX

	return (mkdir(path, 0775) != -1);

#endif

}

size_t LibrarySystem::GetFileFromPath(char *buffer, size_t maxlength, const char *path)

{

	size_t length = strlen(path);

	for (size_t i = length - 1;

		 i >= 0 && i <= length - 1;

		 i--)

	{

		if (path[i] == '/' 

#if defined PLATFORM_WINDOWS

			|| path[i] == '\\'

#endif

			)

		{

			return UTIL_Format(buffer, maxlength, "%s", &path[i+1]);

		}

	}

	/* We scanned and found no path separator */

	return UTIL_Format(buffer, maxlength, "%s", path);

}

bool LibrarySystem::FileTime(const char *path, FileTimeType type, time_t *pTime)

{

#ifdef PLATFORM_WINDOWS

	struct _stat s;

	if (_stat(path, &s) != 0)

#elif defined PLATFORM_POSIX

	struct stat s;

	if (stat(path, &s) != 0)

#endif

	{

		return false;

	}

	if (type == FileTime_LastAccess)

	{

		*pTime = s.st_atime;

	}

	else if (type == FileTime_Created)

	{

		*pTime = s.st_ctime;

	}

	else if (type == FileTime_LastChange)

	{

		*pTime = s.st_mtime;

	}

	return true;

}