#include <stdlib.h>

#include <string.h>

#include <sys/stat.h>

#include <dirent.h>

#include <fnmatch.h>

#include <fcntl.h>

#include <unistd.h>

#include <limits.h>

#include <assert.h>

#include "files.h"

static char *user_dir = NULL;

static char *gamedata_dir = NULL;

#define OPEN_EXISTING    0x0010

static char *FixFilePath(const char *filename, const char *prefix)

{

    int plen = strlen(prefix) + 1;

    size_t flen = strlen(filename) + plen + 1;

    char *f = malloc(flen);

    if (NULL != f)

        sprintf(f, "%s%c%s", prefix, DIR_SEPARATOR, filename);

return f;

}

FILE *OpenGameFile(const char *filename, int readonly, int type)

{

    char *rfilename = NULL;

    FILE *fp = NULL;

    switch(type)

    {

        case FILETYPE_GAMEDATA:

            readonly = 1;

            rfilename = FixFilePath(filename, gamedata_dir);

        break;

        case FILETYPE_CONFIG:

            rfilename = FixFilePath(filename, user_dir);

        break;

        default:

        return NULL;

    }

    fp = fopen(rfilename, (readonly ? "rb" : "wb"));

    free(rfilename);

return fp;

}

char *FullFilePath(const char *filename)

{

    return FixFilePath(filename, gamedata_dir);

}

static int GetFA(const char *filename)

{

    struct stat buf;

    int attr = 0;

    if (!stat(filename, &buf))

    {

        if (S_ISDIR(buf.st_mode))

            attr |= FILEATTR_DIRECTORY;

        if (!access(filename, R_OK))

            attr |= FILEATTR_READABLE;

        if (!access(filename, W_OK))

            attr |= FILEATTR_WRITABLE;

    }

return attr;

}

static time_t GetTS(const char *filename)

{

    struct stat buf;

    return !stat(filename, &buf) ? buf.st_mtime : 0;

}

/*

Create a directory: local dir only

TODO: maybe also mkdir parent directories, if they do not exist?

*/

int CreateGameDirectory(const char *dirname)

{

    char *rfilename = FixFilePath(dirname, user_dir);

    int ret = mkdir(rfilename, S_IRWXU);

    free(rfilename);

    if (ret == -1)

    {

        rfilename = FixFilePath(dirname, user_dir);

        ret = mkdir(rfilename, S_IRWXU);

        free(rfilename);

    }

return ret;

}

/* This struct is private. */

typedef struct GameDirectory

{

    DIR *localdir;        /* directory opened with opendir */

    DIR *globaldir;

    char *localdirname;

    char *globaldirname;

    char *pat;        /* pattern to match */

    GameDirectoryFile tmp;    /* Temp space */

} GameDirectory;

/*

"Open" a directory dirname, with type type

Returns a pointer to a directory datatype

Pattern is the pattern to match

*/

void *OpenGameDirectory(const char *dirname, const char *pattern, int type)

{

    char *localdirname = NULL, *globaldirname = NULL;

    DIR *localdir = NULL, *globaldir = NULL;

    if (type != FILETYPE_CONFIG)

    {

        globaldirname = FixFilePath(dirname, gamedata_dir);

        globaldir = opendir(globaldirname);

        if (globaldir == NULL)

        {

            free(globaldirname);

            globaldirname = FixFilePath(dirname, gamedata_dir);

            globaldir = opendir(globaldirname);

            if (globaldir == NULL)

                free(globaldirname);

            return NULL;

        }

    }

    if (type != FILETYPE_GAMEDATA)

    {

        localdirname = FixFilePath(dirname, user_dir);

        localdir = opendir(localdirname);

        if (localdir == NULL)

        {

            free(localdirname);

            localdirname = FixFilePath(dirname, user_dir);

            localdir = opendir(localdirname);

            if (localdir == NULL)

                free(localdirname);

            return NULL;

        }

    }

    GameDirectory *gd = malloc(sizeof(GameDirectory));

    if(NULL != gd)

    {

        gd->localdir = localdir;

        gd->globaldir = globaldir;

        gd->localdirname = localdirname;

        gd->globaldirname = globaldirname;

        gd->pat = strdup(pattern);

    }

return gd;

}

GameDirectoryFile *ScanGameDirectory(void *dir)

{

    GameDirectory *directory = (GameDirectory *)dir;

    char *ptr;

    struct dirent *file;

    if (directory->globaldir)

    {

        while ((file = readdir(directory->globaldir)) != NULL)

        {

            if (!fnmatch(directory->pat, file->d_name, FNM_PATHNAME))

            {

                ptr = FixFilePath(file->d_name, directory->globaldirname);

                directory->tmp.attr = GetFA(ptr);

                free(ptr);

                directory->tmp.filename = file->d_name;

                return &directory->tmp;

            }

        }

        closedir(directory->globaldir);

        free(directory->globaldirname);

        directory->globaldir = NULL;

        directory->globaldirname = NULL;

    }

    if (directory->localdir)

    {

        while ((file = readdir(directory->localdir)) != NULL)

        {

            if (!fnmatch(directory->pat, file->d_name, FNM_PATHNAME))

            {

                ptr = FixFilePath(file->d_name, directory->localdirname);

                directory->tmp.attr = GetFA(ptr);

                directory->tmp.timestamp = GetTS(ptr);

                free(ptr);

                directory->tmp.filename = file->d_name;

                return &directory->tmp;

            }

        }

        closedir(directory->localdir);

        free(directory->localdirname);

        directory->localdir = NULL;

        directory->localdirname = NULL;

    }

return NULL;

}

int CloseGameDirectory(void *dir)

{

    GameDirectory *directory = (GameDirectory *)dir;

    if (directory)

    {

        free(directory->pat);

        if (directory->localdirname)

            free(directory->localdirname);

        if (directory->globaldirname)

            free(directory->globaldirname);

        if (directory->localdir)

            closedir(directory->localdir);

        if (directory->globaldir)

            closedir(directory->globaldir);

        return 0;

    }

return -1;

}

static int try_game_directory(char *dir, char *file)

{

    char tmppath[FILENAME_MAX];

    size_t len = FILENAME_MAX-32;

    snprintf(tmppath, len, "%s%c%s", dir, DIR_SEPARATOR, file);

    //strncpy(tmppath, dir, len);

    tmppath[len] = 0;

    //strcat(tmppath, file);

    return !access(tmppath, R_OK);

}

static int check_game_directory(char *dir)

{

    return

    (

    (NULL != dir)

    &&

    (NULL != *dir)

    &&

    try_game_directory(dir, "avp_huds")

    &&

    try_game_directory(dir, "avp_huds/dropship.rif")

    &&

    try_game_directory(dir, "avp_rifs")

    &&

    try_game_directory(dir, "avp_rifs/temple.rif")

    &&

    try_game_directory(dir, "fastfile")

    &&

    try_game_directory(dir, "graphics/common/lights.png") 

    &&

    try_game_directory(dir, "sound/hud/predator/pred_injection.wav")

    );

}

void InitGameDirectories(char *argv0)

{

    char tmppath[FILENAME_MAX];

    char *tmp = NULL;

    size_t len, copylen;

    char *homedir = getenv("HOME");

    if (homedir == NULL)

        homedir = ".";

    char *localdir = malloc(strlen(homedir) + 10);

    sprintf(localdir, "%s%c.avp", homedir, DIR_SEPARATOR);

    /*

    1. $AVP_DATA overrides all

    2. executable path from argv[0]

    3. realpath of executable path from argv[0]

    4. $PATH

    5. current directory

    */

    char *gamedir = getenv("AVP_DATA");

    /* $AVP_DATA overrides all, so no check */

    if (gamedir == NULL)

    {

        /* 2. executable path from argv[0] */

        tmp = strdup(argv0);

        if (tmp == NULL)

        {

            fprintf(stderr, "InitGameDirectories failure\n");

            exit(EXIT_FAILURE);

        }

        gamedir = strrchr(tmp, '/');

        if (NULL != gamedir)

        {

            *gamedir = NULL;

            gamedir = tmp;

            if (!check_game_directory(gamedir)) 

                gamedir = NULL;

        }

        if (gamedir == NULL) 

        {

            /* 3. realpath of executable path from argv[0] */

            assert(tmp != NULL);

            gamedir = realpath(tmp, tmppath);

            if (!check_game_directory(gamedir)) 

                gamedir = NULL;

        }

        if (gamedir == NULL)

        {

            char *path = getenv("PATH");

            if (path)

            {

                while (*path)

                {

                    len = strcspn(path, ":");

                    copylen = (len < FILENAME_MAX-1) ? len : FILENAME_MAX-1;

                    strncpy(tmppath, path, copylen);

                    tmppath[copylen] = 0;

                    if (check_game_directory(tmppath)) 

                    {

                        gamedir = tmppath;

                        break;

                    }

                    path += len;

                    path += strspn(path, ":");

                }

            }

        }

        /* last chance sanity check */

        if (gamedir == NULL)

            gamedir = ".";

    }

    size_t len1 = strlen(gamedir);

    if(DIR_SEPARATOR == gamedir[len1-1])

        gamedir[len1-1] = '\0';

    if (check_game_directory(gamedir)) 

    {

        /*

        Sets the local and global directories used by the other functions.

        Local = ~/.dir, where config and user-installed files are kept.

        Global = installdir, where installed data is stored.

        */

        struct stat buf;

        user_dir = strdup(localdir);

        gamedata_dir = strdup(gamedir);

        if (stat(user_dir, &buf) == -1)

        {

            printf("Creating local directory %s...\n", user_dir);

            mkdir(user_dir, S_IRWXU);

        }

    }

    else

    {

        fprintf(stderr, "Unable to find the AvP gamedata.\n");

        fprintf(stderr, "The directory last examined was: %s\n", gamedir);

        fprintf(stderr, "Has the game been installed and\n");

        fprintf(stderr, "are all game files lowercase?\n");

        exit(EXIT_FAILURE);

    }

    if (tmp)

        free(tmp);

    free(localdir);

}