/*

 * Skeleton platform-dependent support routines for PhysicsFS.

 *

 * Please see the file LICENSE in the source's root directory.

 *

 *  This file written by Ryan C. Gordon.

 */

#if HAVE_CONFIG_H

#  include <config.h>

#endif

#include <stdio.h>

#include <windows.h>

#define __PHYSICSFS_INTERNAL__

#include "physfs_internal.h"

#define INVALID_FILE_ATTRIBUTES		0xFFFFFFFF

#define INVALID_SET_FILE_POINTER	0xFFFFFFFF

typedef struct

{

    HANDLE handle;

    int readonly;

} winCEfile;

const char *__PHYSFS_platformDirSeparator = "\\";

/*

 * Figure out what the last failing Win32 API call was, and

 *  generate a human-readable string for the error message.

 *

 * The return value is a static buffer that is overwritten with

 *  each call to this function.

 */

static const char *win32strerror(void)

{

    static TCHAR msgbuf[255];

    TCHAR *ptr = msgbuf;

    FormatMessage(

        FORMAT_MESSAGE_FROM_SYSTEM |

        FORMAT_MESSAGE_IGNORE_INSERTS,

        NULL,

        GetLastError(),

        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */

        msgbuf,

        sizeof (msgbuf) / sizeof (TCHAR),

        NULL 

    );

        /* chop off newlines. */

    for (ptr = msgbuf; *ptr; ptr++)

    {

        if ((*ptr == '\n') || (*ptr == '\r'))

        {

            *ptr = ' ';

            break;

        } /* if */

    } /* for */

    return((const char *) msgbuf);

} /* win32strerror */

static char *UnicodeToAsc(const wchar_t *w_str)

{

	char *str=NULL;

	if(w_str!=NULL)

	{

		int len=wcslen(w_str)+1;

		str=(char *)malloc(len);

		if(WideCharToMultiByte(CP_ACP,0,w_str,-1,str,len,NULL,NULL)==0)

		{	//Conversion failed

			free(str);

			return NULL;

		}

		else

		{	//Conversion successful

			return(str);

		}

	}

	else

	{	//Given NULL string

		return NULL;

	}

}

static wchar_t *AscToUnicode(const char *str)

{

	wchar_t *w_str=NULL;

	if(str!=NULL)

	{

		int len=strlen(str)+1;

		w_str=(wchar_t *)malloc(sizeof(wchar_t)*len);

		if(MultiByteToWideChar(CP_ACP,0,str,-1,w_str,len)==0)

		{

			free(w_str);

			return NULL;

		}

		else

		{

			return(w_str);

		}

	}

	else

	{

		return NULL;

	}

}

int __PHYSFS_platformInit(void)

{

    return(1);  /* always succeed. */

} /* __PHYSFS_platformInit */

int __PHYSFS_platformDeinit(void)

{

    return(1);  /* always succeed. */

} /* __PHYSFS_platformDeinit */

char **__PHYSFS_platformDetectAvailableCDs(void)

{

    BAIL_MACRO(ERR_NOT_IMPLEMENTED, NULL);

} /* __PHYSFS_platformDetectAvailableCDs */

char *__PHYSFS_platformCalcBaseDir(const char *argv0)

{

	return("\\");

//    BAIL_MACRO(ERR_NOT_IMPLEMENTED, NULL);

} /* __PHYSFS_platformCalcBaseDir */

char *__PHYSFS_platformGetUserName(void)

{

    BAIL_MACRO(ERR_NOT_IMPLEMENTED, NULL);

} /* __PHYSFS_platformGetUserName */

char *__PHYSFS_platformGetUserDir(void)

{

	return("\\");

    BAIL_MACRO(ERR_NOT_IMPLEMENTED, NULL);

} /* __PHYSFS_platformGetUserDir */

PHYSFS_uint64 __PHYSFS_platformGetThreadID(void)

{

    return(1);  /* single threaded. */

} /* __PHYSFS_platformGetThreadID */

int __PHYSFS_platformStricmp(const char *x, const char *y)

{    

	const char *p1 = x, *p2 = y;

	int r = 0;

    while((*p1) && (*p2) && (toupper(*p1++) == toupper(*p2++)))  ++r;

    r = (!((*p1) || (*p2)) ? (0) : ((toupper(*p1) > toupper(*p2)) ?

                                    (r + 1) : -(r + 1)));

    return(r);

} /* __PHYSFS_platformStricmp */

int __PHYSFS_platformExists(const char *fname)

{

	int retval=0;

	wchar_t *w_fname=AscToUnicode(fname);

	if(w_fname!=NULL)

	{

		retval=(GetFileAttributes(w_fname) != INVALID_FILE_ATTRIBUTES);

		free(w_fname);

	}

	return(retval);

} /* __PHYSFS_platformExists */

int __PHYSFS_platformIsSymLink(const char *fname)

{

    BAIL_MACRO(ERR_NOT_IMPLEMENTED, 0);

} /* __PHYSFS_platformIsSymlink */

int __PHYSFS_platformIsDirectory(const char *fname)

{

	int retval=0;

	wchar_t *w_fname=AscToUnicode(fname);

	if(w_fname!=NULL)

	{

	    retval=((GetFileAttributes(w_fname) & FILE_ATTRIBUTE_DIRECTORY) != 0);

		free(w_fname);

	}

	return(retval);

} /* __PHYSFS_platformIsDirectory */

char *__PHYSFS_platformCvtToDependent(const char *prepend,

                                      const char *dirName,

                                      const char *append)

{

    int len = ((prepend) ? strlen(prepend) : 0) +

              ((append) ? strlen(append) : 0) +

              strlen(dirName) + 1;

    char *retval = malloc(len);

    char *p;

    BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);

    if (prepend)

        strcpy(retval, prepend);

    else

        retval[0] = '\0';

    strcat(retval, dirName);

    if (append)

        strcat(retval, append);

    for (p = strchr(retval, '/'); p != NULL; p = strchr(p + 1, '/'))

        *p = '\\';

    return(retval);

} /* __PHYSFS_platformCvtToDependent */

void __PHYSFS_platformTimeslice(void)

{

    Sleep(10);

} /* __PHYSFS_platformTimeslice */

LinkedStringList *__PHYSFS_platformEnumerateFiles(const char *dirname,

                                                  int omitSymLinks)

{

    LinkedStringList *retval = NULL;

    LinkedStringList *l = NULL;

    LinkedStringList *prev = NULL;

    HANDLE dir;

    WIN32_FIND_DATA ent;

    char *SearchPath;

	wchar_t *w_SearchPath;

    size_t len = strlen(dirname);

    /* Allocate a new string for path, maybe '\\', "*", and NULL terminator */

    SearchPath = (char *) alloca(len + 3);

    BAIL_IF_MACRO(SearchPath == NULL, ERR_OUT_OF_MEMORY, NULL);	

    /* Copy current dirname */

    strcpy(SearchPath, dirname);

    /* if there's no '\\' at the end of the path, stick one in there. */

    if (SearchPath[len - 1] != '\\')

    {

        SearchPath[len++] = '\\';

        SearchPath[len] = '\0';

    } /* if */

    /* Append the "*" to the end of the string */

    strcat(SearchPath, "*");

	w_SearchPath=AscToUnicode(SearchPath);

    dir = FindFirstFile(w_SearchPath, &ent);

	free(w_SearchPath);

	free(SearchPath);

	if(dir == INVALID_HANDLE_VALUE)

	{

		return NULL;

	}

    do

    {

        if (wcscmp(ent.cFileName, L".") == 0)

            continue;

        if (wcscmp(ent.cFileName, L"..") == 0)

            continue;

        l = (LinkedStringList *) malloc(sizeof (LinkedStringList));

        if (l == NULL)

            break;

		l->str=UnicodeToAsc(ent.cFileName);

        if (l->str == NULL)

        {

            free(l);

            break;

        }

        if (retval == NULL)

            retval = l;

        else

            prev->next = l;

        prev = l;

        l->next = NULL;

    } while (FindNextFile(dir, &ent) != 0);

    FindClose(dir);

    return(retval);

} /* __PHYSFS_platformEnumerateFiles */

char *__PHYSFS_platformCurrentDir(void)

{

	return("\\");

} /* __PHYSFS_platformCurrentDir */

char *__PHYSFS_platformRealPath(const char *path)

{

	char *retval=(char *)malloc(strlen(path)+1);

	strcpy(retval,path);

	return(retval);

} /* __PHYSFS_platformRealPath */

int __PHYSFS_platformMkDir(const char *path)

{

	wchar_t *w_path = AscToUnicode(path);

	if(w_path!=NULL)

	{

	    DWORD rc = CreateDirectory(w_path, NULL);

		free(w_path);

		if(rc==0)

		{

			return(0);

		}

		return(1);

	}

	else

	{

		return(0);

	}

} /* __PHYSFS_platformMkDir */

static void *doOpen(const char *fname, DWORD mode, DWORD creation, int rdonly)

{

    HANDLE fileHandle;

    winCEfile *retval;

	wchar_t *w_fname=AscToUnicode(fname);

    fileHandle = CreateFile(w_fname, mode, FILE_SHARE_READ, NULL,

                            creation, FILE_ATTRIBUTE_NORMAL, NULL);

	free(w_fname);

	if(fileHandle==INVALID_HANDLE_VALUE)

	{

		return NULL;

	}

    BAIL_IF_MACRO(fileHandle == INVALID_HANDLE_VALUE, win32strerror(), NULL);

	retval = malloc(sizeof (winCEfile));

	if (retval == NULL)

	{

		CloseHandle(fileHandle);

		BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);

	} /* if */

	retval->readonly = rdonly;

	retval->handle = fileHandle;

	return(retval);

} /* doOpen */

void *__PHYSFS_platformOpenRead(const char *filename)

{

    return(doOpen(filename, GENERIC_READ, OPEN_EXISTING, 1));

} /* __PHYSFS_platformOpenRead */

void *__PHYSFS_platformOpenWrite(const char *filename)

{

    return(doOpen(filename, GENERIC_WRITE, CREATE_ALWAYS, 0));

} /* __PHYSFS_platformOpenWrite */

void *__PHYSFS_platformOpenAppend(const char *filename)

{

    void *retval = doOpen(filename, GENERIC_WRITE, OPEN_ALWAYS, 0);

    if (retval != NULL)

    {

        HANDLE h = ((winCEfile *) retval)->handle;

        if (SetFilePointer(h, 0, NULL, FILE_END) == INVALID_SET_FILE_POINTER)

        {

            const char *err = win32strerror();

            CloseHandle(h);

            free(retval);

            BAIL_MACRO(err, NULL);

        } /* if */

    } /* if */

    return(retval);

} /* __PHYSFS_platformOpenAppend */

PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buffer,

                                    PHYSFS_uint32 size, PHYSFS_uint32 count)

{

    HANDLE FileHandle = ((winCEfile *) opaque)->handle;

    DWORD CountOfBytesRead;

    PHYSFS_sint64 retval;

    /* Read data from the file */

    /*!!! - uint32 might be a greater # than DWORD */

    if(!ReadFile(FileHandle, buffer, count * size, &CountOfBytesRead, NULL))

    {

		retval=-1;

    } /* if */

    else

    {

        /* Return the number of "objects" read. */

        /* !!! - What if not the right amount of bytes was read to make an object? */

        retval = CountOfBytesRead / size;

    } /* else */

    return(retval);

} /* __PHYSFS_platformRead */

PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,

                                     PHYSFS_uint32 size, PHYSFS_uint32 count)

{

    HANDLE FileHandle = ((winCEfile *) opaque)->handle;

    DWORD CountOfBytesWritten;

    PHYSFS_sint64 retval;

    /* Read data from the file */

    /*!!! - uint32 might be a greater # than DWORD */

    if(!WriteFile(FileHandle, buffer, count * size, &CountOfBytesWritten, NULL))

    {

		retval=-1;

    } /* if */

    else

    {

        /* Return the number of "objects" read. */

        /*!!! - What if not the right number of bytes was written? */

        retval = CountOfBytesWritten / size;

    } /* else */

	return(retval);

} /* __PHYSFS_platformWrite */

int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)

{

    HANDLE FileHandle = ((winCEfile *) opaque)->handle;

    DWORD HighOrderPos;

    DWORD rc;

    /* Get the high order 32-bits of the position */

    //HighOrderPos = HIGHORDER_UINT64(pos);

	HighOrderPos = (unsigned long)(pos>>32);

    /*!!! SetFilePointer needs a signed 64-bit value. */

    /* Move pointer "pos" count from start of file */

    rc = SetFilePointer(FileHandle, (unsigned long)(pos&0x00000000ffffffff),

                        &HighOrderPos, FILE_BEGIN);

    if ((rc == INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR))

	{

        BAIL_MACRO(win32strerror(), 0);

	}

    return(1);  /* No error occured */

} /* __PHYSFS_platformSeek */

PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)

{

    HANDLE FileHandle = ((winCEfile *) opaque)->handle;

    DWORD HighPos = 0;

    DWORD LowPos;

    PHYSFS_sint64 retval;

    /* Get current position */

    LowPos = SetFilePointer(FileHandle, 0, &HighPos, FILE_CURRENT);

    if ((LowPos == INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR))

    {

        BAIL_MACRO(win32strerror(), 0);

    } /* if */

    else

    {

        /* Combine the high/low order to create the 64-bit position value */

        retval = (((PHYSFS_uint64) HighPos) << 32) | LowPos;

        //assert(retval >= 0);

    } /* else */

    return(retval);

} /* __PHYSFS_platformTell */

PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)

{

    HANDLE FileHandle = ((winCEfile *) opaque)->handle;

    DWORD SizeHigh;

    DWORD SizeLow;

    PHYSFS_sint64 retval;