#include <stdafx.h>
#include "ScriptAPI.h"
#include <sys/stat.h>

#pragma warning(disable: 4702) // disable unreachable code warning

enum fsop { FS_READ, FS_WRITE };
static duk_ret_t ReadWriteImpl(duk_context *ctx, fsop op); // (fd, buffer, offset, length, position)
static duk_ret_t js__FileFinalizer(duk_context *ctx);

void ScriptAPI::Define_fs(duk_context *ctx)
{
    // todo DukPutProps DukClass

    const duk_function_list_entry funcs[] = {
        { "open",      js_fs_open,      DUK_VARARGS },
        { "close",     js_fs_close,     DUK_VARARGS },
        { "write",     js_fs_write,     DUK_VARARGS },
        { "writefile", js_fs_writefile, DUK_VARARGS },
        { "read",      js_fs_read,      DUK_VARARGS },
        { "readfile",  js_fs_readfile,  DUK_VARARGS },
        { "exists",    js_fs_exists,    DUK_VARARGS },
        { "fstat",     js_fs_fstat,     DUK_VARARGS },
        { "stat",      js_fs_stat,      DUK_VARARGS },
        { "unlink",    js_fs_unlink,    DUK_VARARGS },
        { "mkdir",     js_fs_mkdir,     DUK_VARARGS },
        { "rmdir",     js_fs_rmdir,     DUK_VARARGS },
        { "readdir",   js_fs_readdir,   DUK_VARARGS },
        { "Stats", js_fs_Stats__constructor, DUK_VARARGS },
        { nullptr, nullptr, 0 }
    };

    const duk_function_list_entry Stats_funcs[] = {
        { "isFile",      js_fs_Stats_isFile,      DUK_VARARGS },
        { "isDirectory", js_fs_Stats_isDirectory, DUK_VARARGS },
        { nullptr, nullptr, 0 }
    };

    duk_push_global_object(ctx);
    duk_push_string(ctx, "fs");
    duk_push_object(ctx);
    duk_put_function_list(ctx, -1, funcs);

    duk_get_prop_string(ctx, -1, "Stats");
    duk_push_object(ctx);
    duk_put_function_list(ctx, -1, Stats_funcs);
    duk_put_prop_string(ctx, -2, "prototype");
    duk_pop(ctx);

    duk_freeze(ctx, -1);
    duk_def_prop(ctx, -3, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_SET_ENUMERABLE);
    duk_pop(ctx);
}

duk_ret_t ScriptAPI::js_fs_open(duk_context *ctx)
{
    CheckArgs(ctx, { Arg_String, Arg_String });

    const char* path = duk_get_string(ctx, 0);
    const char* mode = duk_get_string(ctx, 1);

    bool bModeValid = false;

    const char* validModes[] = {
        "r", "rb",
        "w", "wb",
        "a", "ab",
        "r+", "rb+", "r+b",
        "w+", "wb+", "w+b",
        "a+", "ab+", "a+b",
        nullptr
    };

    for (int i = 0; validModes[i] != nullptr; i++)
    {
        if (strcmp(mode, validModes[i]) == 0)
        {
            bModeValid = true;
            break;
        }
    }

    if (!bModeValid)
    {
        duk_push_error_object(ctx, DUK_ERR_TYPE_ERROR, "mode '%s' is not valid", mode);
        return duk_throw(ctx);
    }

    FILE *fp = fopen(path, mode);

    if(fp == nullptr)
    {
        duk_push_error_object(ctx, DUK_ERR_ERROR, "could not open '%s' (mode: '%s')", path, mode);
        return duk_throw(ctx);
    }

    int fd = _fileno(fp);

    //  FILES[fd] = {fp: fp}
    duk_get_global_string(ctx, HS_gOpenFileDescriptors);

    duk_push_object(ctx);
    duk_push_pointer(ctx, fp);
    duk_put_prop_string(ctx, -2, "fp");
    duk_push_c_function(ctx, js__FileFinalizer, 1);
    duk_set_finalizer(ctx, -2);

    duk_put_prop_index(ctx, -2, fd);
    duk_pop_n(ctx, 2);

    duk_push_number(ctx, fd);

    return 1;
}

duk_ret_t ScriptAPI::js_fs_close(duk_context *ctx)
{
    CheckArgs(ctx, { Arg_Number });

    int fd = duk_get_int(ctx, 0);
    int rc = -1;

    duk_get_global_string(ctx, HS_gOpenFileDescriptors);

    if(duk_has_prop_index(ctx, -1, fd))
    {
        duk_get_prop_index(ctx, -1, fd);
        duk_get_prop_string(ctx, -1, "fp");

        FILE* fp = (FILE*)duk_get_pointer(ctx, -1);
        rc = fclose(fp);

        // unset finalizer before deleting
        duk_push_undefined(ctx);
        duk_set_finalizer(ctx, -3); 
        duk_del_prop_index(ctx, -3, fd);

        duk_pop_n(ctx, 2);
    }
    else
    {
        duk_push_error_object(ctx, DUK_ERR_ERROR, "invalid file descriptor");
        return duk_throw(ctx);
    }

    duk_pop(ctx);
    duk_push_number(ctx, rc);
    return 1;
}

duk_ret_t ScriptAPI::js_fs_write(duk_context *ctx)
{
    CheckArgs(ctx, { Arg_Number, Arg_Any, Arg_OptNumber, Arg_OptNumber, Arg_OptNumber });
    return ReadWriteImpl(ctx, FS_WRITE);
}

duk_ret_t ScriptAPI::js_fs_writefile(duk_context *ctx)
{
    CheckArgs(ctx, { Arg_String, Arg_Any });

    const char* path = duk_get_string(ctx, 0);

    void* buffer;
    duk_size_t bufferSize;

    if(duk_is_string(ctx, 1))
    {
        buffer = (void*)duk_get_lstring(ctx, 1, &bufferSize);
    }
    else if(duk_is_buffer_data(ctx, 1))
    {
        buffer = duk_get_buffer_data(ctx, 1, &bufferSize);
    }
    else
    {
        return ThrowInvalidArgsError(ctx);
    }

    FILE* fp = fopen(path, "wb");

    if(fp == nullptr)
    {
        duk_push_error_object(ctx, DUK_ERR_ERROR, "could not open '%s' (mode: 'wb')", path);
        return duk_throw(ctx);
    }

    if(fwrite(buffer, 1, bufferSize, fp) != bufferSize)
    {
        fclose(fp);
        return DUK_RET_ERROR;
    }

    fclose(fp);
    return 0;
}

duk_ret_t ScriptAPI::js_fs_read(duk_context *ctx)
{
    CheckArgs(ctx, { Arg_Number, Arg_Any, Arg_Number, Arg_Number, Arg_Number });
    return ReadWriteImpl(ctx, FS_READ);
}

duk_ret_t ScriptAPI::js_fs_readfile(duk_context *ctx)
{
    CheckArgs(ctx, { Arg_String });

    const char* path = duk_get_string(ctx, 0);

    FILE* fp = fopen(path, "rb");

    if(fp == nullptr)
    {
        duk_push_error_object(ctx, DUK_ERR_ERROR, "could not open '%s' (mode: 'rb')", path);
        return duk_throw(ctx);
    }

    struct stat stats;
    if(fstat(_fileno(fp), &stats) != 0)
    {
        fclose(fp);
        return DUK_RET_ERROR;
    }

    void *data = duk_push_fixed_buffer(ctx, stats.st_size);
    duk_push_buffer_object(ctx, -1, 0, stats.st_size, DUK_BUFOBJ_NODEJS_BUFFER);

    if(fread(data, 1, stats.st_size, fp) != (size_t)stats.st_size)
    {
        duk_pop(ctx);
        fclose(fp);
        return DUK_RET_ERROR;
    }

    fclose(fp);
    return 1;
}

duk_ret_t ScriptAPI::js_fs_exists(duk_context* ctx)
{
    CheckArgs(ctx, { Arg_String });
    const char* path = duk_get_string(ctx, 0);
    duk_push_boolean(ctx, PathFileExistsA(path) ? 1 : 0);
    return 1;
}

duk_ret_t ScriptAPI::js_fs_fstat(duk_context *ctx)
{
    CheckArgs(ctx, { Arg_Number });

    int fd = duk_get_int(ctx, 0);

    duk_push_global_object(ctx);
    duk_get_prop_string(ctx, -1, "fs");
    duk_get_prop_string(ctx, -1, "Stats");
    duk_push_number(ctx, fd);
    duk_new(ctx, 1);
    return 1;
}

duk_ret_t ScriptAPI::js_fs_stat(duk_context *ctx)
{
    CheckArgs(ctx, { Arg_String });

    const char *path = duk_get_string(ctx, 0);

    duk_push_global_object(ctx);
    duk_get_prop_string(ctx, -1, "fs");
    duk_get_prop_string(ctx, -1, "Stats");
    duk_push_string(ctx, path);
    duk_new(ctx, 1);
    return 1;
}

duk_ret_t ScriptAPI::js_fs_unlink(duk_context *ctx)
{
    CheckArgs(ctx, { Arg_String });

    const char *path = duk_get_string(ctx, 0);
    duk_push_boolean(ctx, DeleteFileA(path) != 0);
    return 1;
}

duk_ret_t ScriptAPI::js_fs_mkdir(duk_context *ctx)
{
    CheckArgs(ctx, { Arg_String });

    const char *path = duk_get_string(ctx, 0);
    duk_push_boolean(ctx, CreateDirectoryA(path, nullptr) != 0);
    return 1;
}

duk_ret_t ScriptAPI::js_fs_rmdir(duk_context *ctx)
{
    CheckArgs(ctx, { Arg_String });

    const char *path = duk_get_string(ctx, 0);
    duk_push_boolean(ctx, RemoveDirectoryA(path) != 0);
    return 1;
}

// todo make sure failure behavior is similar to nodejs's fs.readdirSync
duk_ret_t ScriptAPI::js_fs_readdir(duk_context *ctx)
{
    CheckArgs(ctx, { Arg_String });

    const char* path = duk_get_string(ctx, 0);

    char findFileName[MAX_PATH];
    snprintf(findFileName, sizeof(findFileName), "%s%s", path, "\\*");

    WIN32_FIND_DATAA ffd;
    HANDLE hFind = FindFirstFileA(findFileName, &ffd);

    if(hFind == INVALID_HANDLE_VALUE)
    {
        return DUK_RET_ERROR;
    }

    duk_uarridx_t idx = 0;
    duk_push_array(ctx);

    do
    {
        if(strcmp(ffd.cFileName, ".") == 0 ||
           strcmp(ffd.cFileName, "..") == 0)
        {
            continue;
        }
        duk_push_string(ctx, ffd.cFileName);
        duk_put_prop_index(ctx, -2, idx++);
    } while(FindNextFileA(hFind, &ffd));
    
    FindClose(hFind);
    return 1;
}

duk_ret_t ScriptAPI::js_fs_Stats__constructor(duk_context *ctx)
{
    if(!duk_is_constructor_call(ctx))
    {
        return DUK_RET_TYPE_ERROR;
    }

    if(duk_get_top(ctx) != 1)
    {
        return ThrowInvalidArgsError(ctx);
    }

    struct stat stats;
    
    if(duk_is_number(ctx, 0))
    {
        int fd = duk_get_int(ctx, 0);
        if(fstat(fd, &stats) != 0)
        {
            return DUK_RET_ERROR;
        }
    }
    else if(duk_is_string(ctx, 0))
    {
        const char *path = duk_get_string(ctx, 0);
        if(stat(path, &stats) != 0)
        {
            return DUK_RET_ERROR;
        }
    }
    else
    {
        return ThrowInvalidArgsError(ctx);
    }

    const duk_number_list_entry numbers[] = {
        { "dev",     (double)stats.st_dev },
        { "ino",     (double)stats.st_ino },
        { "mode",    (double)stats.st_mode },
        { "nlink",   (double)stats.st_nlink },
        { "uid",     (double)stats.st_uid },
        { "gid",     (double)stats.st_gid },
        { "rdev",    (double)stats.st_rdev },
        { "size",    (double)stats.st_size },
        { "atimeMs", (double)stats.st_atime * 1000 },
        { "mtimeMs", (double)stats.st_mtime * 1000 },
        { "ctimeMs", (double)stats.st_ctime * 1000 },
        { nullptr, 0 }
    };

    struct { const char *key; time_t time; } dates[3] = {
        { "atime", stats.st_atime * 1000 },
        { "mtime", stats.st_mtime * 1000 },
        { "ctime", stats.st_ctime * 1000 },
    };

    duk_push_global_object(ctx);
    duk_get_prop_string(ctx, -1, "Date");
    duk_remove(ctx, -2);

    duk_push_this(ctx);
    duk_put_number_list(ctx, -1, numbers);

    for(int i = 0; i < 3; i++)
    {
        duk_dup(ctx, -2);
        duk_push_number(ctx, (duk_double_t)dates[i].time);
        duk_new(ctx, 1);
        duk_put_prop_string(ctx, -2, dates[i].key);
    }

    duk_remove(ctx, -2);
    duk_freeze(ctx, -1);
    return 0;
}

duk_ret_t ScriptAPI::js_fs_Stats_isDirectory(duk_context *ctx)
{
    CheckArgs(ctx, {});

    duk_push_this(ctx);
    duk_get_prop_string(ctx, -1, "mode");
    duk_uint_t mode = duk_get_uint(ctx, -1);
    duk_push_boolean(ctx, (mode & S_IFDIR) != 0);
    return 1;
}

duk_ret_t ScriptAPI::js_fs_Stats_isFile(duk_context *ctx)
{
    CheckArgs(ctx, {});

    duk_push_this(ctx);
    duk_get_prop_string(ctx, -1, "mode");
    duk_uint_t mode = duk_get_uint(ctx, -1);
    duk_push_boolean(ctx, (mode & S_IFREG) != 0);
    return 1;
}

static duk_ret_t ReadWriteImpl(duk_context *ctx, fsop op)
{
    int fd;
    const char* buffer;
    size_t offset = 0;
    size_t length = 0;
    size_t position = 0;

    bool bHavePos = false;
    duk_size_t bufferSize;
    FILE* fp;
    size_t rc;

    duk_idx_t nargs = duk_get_top(ctx);

    if(nargs < 2 || !duk_is_number(ctx, 0))
    {
        goto err_invalid_args;
    }

    fd = duk_get_int(ctx, 0);

    if(duk_is_buffer_data(ctx, 1))
    {
        buffer = (const char*)duk_get_buffer_data(ctx, 1, &bufferSize);
    }
    else if(duk_is_string(ctx, 1) && op == FS_WRITE)
    {
        buffer = duk_get_lstring(ctx, 1, &bufferSize);
    }
    else
    {
        goto err_invalid_args;
    }

    if(nargs >= 3)
    {
        if(!duk_is_number(ctx, 2))
        {
            goto err_invalid_args;
        }

        offset = duk_get_uint(ctx, 2);

        if(offset >= bufferSize)
        {
            goto err_invalid_range;
        }
    }

    length = bufferSize - offset;

    if(nargs >= 4)
    {
        if(!duk_is_number(ctx, 3))
        {
            goto err_invalid_args;
        }
        length = duk_get_uint(ctx, 3);
    }

    if(nargs >= 5)
    {
        if(!duk_is_number(ctx, 4))
        {
            goto err_invalid_args;
        }
        position = duk_get_uint(ctx, 4);
        bHavePos = true;
    }

    if(offset + length > bufferSize)
    {
        goto err_invalid_range;
    }

    duk_get_global_string(ctx, HS_gOpenFileDescriptors);

    if(!duk_has_prop_index(ctx, -1, fd))
    {
        goto err_invalid_fd;
    }

    duk_get_prop_index(ctx, -1, fd);
    duk_get_prop_string(ctx, -1, "fp");
    fp = (FILE*)duk_get_pointer(ctx, -1);
    
    duk_pop_n(ctx, 3);

    if(bHavePos)
    {
        fseek(fp, position, SEEK_SET);
    }

    switch(op)
    {
    case FS_READ:
        rc = fread((void*)&buffer[offset], 1, length, fp);
        break;
    case FS_WRITE:
        rc = fwrite((void*)&buffer[offset], 1, length, fp);
        break;
    default:
        return DUK_RET_ERROR;
    }

    duk_push_number(ctx, rc);
    return 1;

err_invalid_args:
    return ScriptAPI::ThrowInvalidArgsError(ctx);

err_invalid_range:
    duk_push_error_object(ctx, DUK_ERR_RANGE_ERROR, "invalid range");
    return duk_throw(ctx);

err_invalid_fd:
    duk_push_error_object(ctx, DUK_ERR_ERROR, "invalid file descriptor");
    return duk_throw(ctx);
}

static duk_ret_t js__FileFinalizer(duk_context *ctx)
{
    CScriptInstance* inst = ScriptAPI::GetInstance(ctx);

    duk_get_prop_string(ctx, 0, "fp");
    FILE *fp = (FILE *)duk_get_pointer(ctx, -1);
    duk_pop(ctx);
    fclose(fp);

    inst->System()->ConsoleLog("[SCRIPTSYS]: warning ('%s'): gc closed leftover file descriptor",
        inst->Name().c_str());

    return 0;
}