#include "core.h"
#include "filesystem.h"

#if defined _WINDOWS || defined _WINDOWS_SERVER

#include <windows.h>

bool MCFileSystemPathToNative(const char *p_path, void*& r_native_path)
{
	unichar_t *t_w_path;
	t_w_path = nil;
	if (!MCCStringToUnicode(p_path, t_w_path))
		return false;

	for(uint32_t i = 0; t_w_path[i] != 0; i++)
		if (t_w_path[i] == '/')
			t_w_path[i] = '\\';

	r_native_path = t_w_path;

	return true;
}

bool MCFileSystemPathFromNative(const void *p_native_path, char*& r_path)
{
	char *t_path;
	t_path = nil;
	if (!MCCStringFromUnicode((const unichar_t *)p_native_path, t_path))
		return false;

	for(uint32_t i = 0; t_path[i] != 0; i++)
		if (t_path[i] == '\\')
			t_path[i] = '/';

	r_path = t_path;

	return true;
}

bool MCFileSystemListEntries(const char *p_folder, uint32_t p_options, MCFileSystemListCallback p_callback, void *p_context)
{
	bool t_success;
	t_success = true;

	char *t_pattern;
	t_pattern = nil;
	if (t_success)
		t_success = MCCStringFormat(t_pattern, "%s%s", p_folder, MCCStringEndsWith(p_folder, "/") ? "*" : "/*");

	void *t_native_pattern;
	t_native_pattern = nil;
	if (t_success)
		t_success = MCFileSystemPathToNative(t_pattern, t_native_pattern);

	HANDLE t_find_handle;
	WIN32_FIND_DATAW t_find_data;
	t_find_handle = INVALID_HANDLE_VALUE;
	if (t_success)
	{
		t_find_handle = FindFirstFileW((LPCWSTR)t_native_pattern, &t_find_data);
		if (t_find_handle == INVALID_HANDLE_VALUE)
			t_success = false;
	}

	while(t_success)
	{
		char *t_entry_filename;
		if (t_success)
			t_success = MCFileSystemPathFromNative(t_find_data . cFileName, t_entry_filename);

		MCFileSystemEntry t_entry;
		if (t_success)
		{
			t_entry . type = (t_find_data . dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0 ? kMCFileSystemEntryFolder : kMCFileSystemEntryFile;
			t_entry . filename = t_entry_filename;

			t_success = p_callback(p_context, t_entry);
		}

		MCCStringFree(t_entry_filename);

		////

		if (!FindNextFileW(t_find_handle, &t_find_data))
		{
			if (GetLastError() == ERROR_NO_MORE_FILES)
				break;

			t_success = false;
		}
	}

	if (t_find_handle != INVALID_HANDLE_VALUE)
		FindClose(t_find_handle);

	MCMemoryDeallocate(t_native_pattern);
	MCCStringFree(t_pattern);

	return t_success;
}

bool MCFileSystemPathResolve(const char *p_path, char*& r_resolved_path)
{
	return MCCStringClone(p_path, r_resolved_path);
}

bool MCFileSystemPathExists(const char *p_path, bool p_folder, bool& r_exists)
{
	bool t_success;
	t_success = true;

	void *t_native_path;
	t_native_path = nil;
	if (t_success)
		t_success = MCFileSystemPathToNative(p_path, t_native_path);

	if (t_success)
	{
		DWORD t_result;
		t_result = GetFileAttributesW((LPCWSTR)t_native_path);
		if (t_result != INVALID_FILE_ATTRIBUTES)
		{
			r_exists =
				((t_result & (FILE_ATTRIBUTE_DIRECTORY)) == 0 && !p_folder) ||
				((t_result & (FILE_ATTRIBUTE_DIRECTORY)) != 0 && p_folder);
		}
		else
		{
			if (GetLastError() == ERROR_FILE_NOT_FOUND)
				r_exists = false;
			else
				t_success = false;
		}
	}

	MCMemoryDeleteArray(t_native_path);

	return t_success;
}

#elif defined(_MACOSX) || defined(_LINUX) || defined(TARGET_SUBPLATFORM_ANDROID) || defined(TARGET_SUBPLATFORM_IPHONE)

#ifndef _LINUX
#include <sys/syslimits.h>
#endif

#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>

#ifdef _LINUX
#define PATH_MAX 4096
#endif

bool MCFileSystemPathResolve(const char *p_path, char*& r_resolved_path)
{
	char t_path[PATH_MAX];
	ssize_t t_size;
	t_size = readlink(p_path, t_path, PATH_MAX);
	if (t_size == -1 || t_size == PATH_MAX)
	{
		if (errno == EINVAL)
			return MCCStringClone(p_path, r_resolved_path);
		return false;
	}
	t_path[t_size] = '\0';
	return MCCStringClone(t_path, r_resolved_path);
}

bool MCFileSystemPathExists(const char *p_path, bool p_folder, bool& r_exists)
{
	char *t_resolved_path;
	if (!MCFileSystemPathResolve(p_path, t_resolved_path))
		return false;

	struct stat t_stat;
	if (stat(t_resolved_path, &t_stat) == 0)
	{
		r_exists =
			(p_folder && (t_stat . st_mode & S_IFDIR) != 0) ||
			(!p_folder && (t_stat . st_mode & S_IFDIR) == 0);
	}
	else
		r_exists = false;

	MCCStringFree(t_resolved_path);

	return true;
}

#include <sys/types.h>
#include <dirent.h>

bool MCFileSystemListEntries(const char *p_folder, uint32_t p_options, MCFileSystemListCallback p_callback, void *p_context)
{
	bool t_success = true;
	
	char *t_resolved_path = nil;
	DIR *t_dir = nil;
	t_success = MCFileSystemPathResolve(p_folder, t_resolved_path);
	
	if (t_success)
	{
		t_dir = opendir(t_resolved_path);
		t_success = t_dir != nil;
	}
	
	if (t_success)
	{
		struct dirent *t_entry = nil;
		struct stat t_entry_stat;
		MCFileSystemEntry t_fs_entry;
		while (t_success && nil != (t_entry = readdir(t_dir)))
		{
			if (!MCCStringEqual(t_entry->d_name, ".") && !MCCStringEqual(t_entry->d_name, ".."))
			{
				char *t_child_path = nil;
				t_success = MCCStringFormat(t_child_path, "%s/%s", t_resolved_path, t_entry->d_name);
				if (t_success)
					t_success = -1 != lstat(t_child_path, &t_entry_stat);
				MCCStringFree(t_child_path);
				if (t_success)
				{
					t_fs_entry.filename = t_entry->d_name;
					if (S_ISLNK(t_entry_stat.st_mode))
						t_fs_entry.type = kMCFileSystemEntryLink;
					else if (S_ISDIR(t_entry_stat.st_mode))
						t_fs_entry.type = kMCFileSystemEntryFolder;
					else
						t_fs_entry.type = kMCFileSystemEntryFile;
					
					t_success = p_callback(p_context, t_fs_entry);
				}
			}
		}
		closedir(t_dir);
	}
	MCCStringFree(t_resolved_path);
	
	return t_success;
}

#endif