#include "vfs.hpp"
#include "wchar_util.h"
#include "str_util.h"
#include "fileop.h"
#include "shlwapi.h"
#include "time_util.h"

DWORD mapZipError(zip_file_t* file) {
    auto error = zip_file_get_error(file);
    if (error) {
        switch (error->zip_err) {
        case ZIP_ER_EOF:
            return ERROR_HANDLE_EOF;
        case ZIP_ER_INVAL:
            return ERROR_INVALID_PARAMETER;
        case ZIP_ER_SEEK:
            return ERROR_SEEK;
        case ZIP_ER_READ:
            return ERROR_READ_FAULT;
        case ZIP_ER_CRC:
            return ERROR_CRC;
        case ZIP_ER_ZIPCLOSED:
            return ERROR_INVALID_HANDLE;
        case ZIP_ER_NOENT:
            return ERROR_FILE_NOT_FOUND;
        case ZIP_ER_EXISTS:
            return ERROR_FILE_EXISTS;
        case ZIP_ER_OPEN:
            return ERROR_OPEN_FAILED;
        }
    }
    return ERROR_INVALID_HANDLE;
}

VFS::VFS() {
    WCHAR exePath[MAX_PATH];
    GetModuleFileNameW(NULL, exePath, MAX_PATH);
    std::wstring path = exePath;
    std::string pathStr;
    if (!wchar_util::wstr_to_str(pathStr, path, CP_UTF8)) {
        char buf[MAX_PATH];
        GetModuleFileNameA(NULL, buf, MAX_PATH);
        pathStr = buf;
    }
    base_path = fileop::dirname(pathStr);
    base_path = str_util::str_replace(base_path, "/", "\\");
}

VFS::~VFS() {
    for (auto file : handles) {
        zip_fclose((zip_file_t*)file.first);
    }
    for (auto archive : archives) {
        zip_close(archive);
    }
}

bool VFS::AddArchive(std::string path) {
    zip_t* archive = zip_open(path.c_str(), ZIP_RDONLY, nullptr);
    if (!archive) return false;
    archives.push_front(archive);
    auto len = zip_get_num_entries(archive, 0);
    for (zip_int64_t i = 0; i < len; i++) {
        struct zip_stat st;
        zip_stat_init(&st);
        zip_stat_index(archive, i, 0, &st);
        // Skip directories/folders (directory entries usually end with a '/')
        if (st.name[strlen(st.name) - 1] == '/') {
            continue;
        }
        std::string name = st.name;
        name = str_util::str_replace(name, "/", "\\");
        files[name] = st;
    }
    return true;
}

bool VFS::AddArchiveFromResource(HMODULE hModule, int resourceID) {
    HRSRC hResInfo = FindResource(hModule, MAKEINTRESOURCE(resourceID), RT_RCDATA);
    if (!hResInfo) return false;
    HGLOBAL hResData = LoadResource(hModule, hResInfo);
    if (!hResData) return false;
    LPVOID lpResData = LockResource(hResData);
    if (!lpResData) return false;
    DWORD dwSize = SizeofResource(hModule, hResInfo);
    if (!dwSize) return false;
    auto re = zip_source_buffer_create(lpResData, dwSize, 0, nullptr);
    if (!re) {
        return false;
    }
    zip_t* archive = zip_open_from_source(re, ZIP_RDONLY, nullptr);
    if (!archive) return false;
    archives.push_front(archive);
    auto len = zip_get_num_entries(archive, 0);
    for (zip_int64_t i = 0; i < len; i++) {
        struct zip_stat st;
        zip_stat_init(&st);
        zip_stat_index(archive, i, 0, &st);
        // Skip directories/folders (directory entries usually end with a '/')
        if (st.name[strlen(st.name) - 1] == '/') {
            continue;
        }
        std::string name = st.name;
        name = str_util::str_replace(name, "/", "\\");
        files[name] = st;
    }
    return true;
}

void VFS::AddArchiveWithErrorMsg(std::string path) {
    if (!AddArchive(path)) {
        std::wstring wpath;
        if (!wchar_util::str_to_wstr(wpath, path, CP_UTF8)) {
            MessageBoxW(NULL, L"无法打开资源文件。请检查资源文件是否完整", L"错误", MB_ICONERROR);
            ExitProcess(1);
            return;
        }
        std::wstring wmsg = L"无法打开 " + wpath + L"。请检查文件是否存在";
        MessageBoxW(NULL, wmsg.c_str(), L"错误", MB_ICONERROR);
        ExitProcess(1);
        return;
    }
}

void VFS::AddArchiveFromResourceWithErrorMsg(HMODULE hModule, int resourceID) {
    if (!AddArchiveFromResource(hModule, resourceID)) {
        MessageBoxW(NULL, L"无法打开内置的资源文件。", L"错误", MB_ICONERROR);
        ExitProcess(1);
        return;
    }
}

bool VFS::ContainsFile(std::string path) {
    path = str_util::str_replace(path, "/", "\\");
    if (fileop::isabs(path)) {
        path = fileop::relpath(path, base_path);
    }
    return files.find(path) != files.end();
}

bool VFS::ContainsFile(std::wstring path) {
    std::string str;
    if (!wchar_util::wstr_to_str(str, path, CP_UTF8)) {
        return false;
    }
    return ContainsFile(str);
}

bool VFS::ContainsHandle(HANDLE hFile) {
    return handles.find(hFile) != handles.end();
}

HANDLE VFS::CreateFileW(std::wstring path) {
    std::string str;
    if (!wchar_util::wstr_to_str(str, path, CP_UTF8)) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return INVALID_HANDLE_VALUE;
    }
    str = fileop::relpath(str, base_path);
    str = str_util::str_replace(str, "/", "\\");
    auto c = files.find(str);
    if (c == files.end()) {
        SetLastError(ERROR_FILE_NOT_FOUND);
        return INVALID_HANDLE_VALUE;
    }
    str = (*c).first;
    str = str_util::str_replace(str, "\\", "/");
    zip_t* archive = nullptr;
    zip_uint64_t index = 0;
    for (auto a : archives) {
        if (zip_name_locate(a, str.c_str(), 0) != -1) {
            archive = a;
            break;
        }
    }
    if (!archive) {
        SetLastError(ERROR_FILE_NOT_FOUND);
        return INVALID_HANDLE_VALUE;
    }
    index = zip_name_locate(archive, str.c_str(), 0);
    zip_file_t* file = zip_fopen_index(archive, index, 0);
    handles[(HANDLE)file] = str;
    return (HANDLE)file;
}

bool VFS::ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead) {
    if (!ContainsHandle(hFile)) {
        SetLastError(ERROR_INVALID_HANDLE);
        return false;
    }
    zip_file_t* file = (zip_file_t*)hFile;
    if (!file) {
        SetLastError(ERROR_INVALID_HANDLE);
        return false;
    }
    zip_int64_t n = zip_fread(file, lpBuffer, nNumberOfBytesToRead);
    if (n == -1) {
        SetLastError(mapZipError(file));
        return false;
    }
    if (lpNumberOfBytesRead) {
        *lpNumberOfBytesRead = n;
    }
    return true;
}

void VFS::CloseHandle(HANDLE hFile) {
    if (!ContainsHandle(hFile)) {
        SetLastError(ERROR_INVALID_HANDLE);
        return;
    }
    zip_fclose((zip_file_t*)hFile);
    handles.erase(hFile);
}

DWORD VFS::GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh) {
    auto f = handles.find(hFile);
    if (f == handles.end()) {
        SetLastError(ERROR_INVALID_HANDLE);
        return INVALID_FILE_SIZE;
    }
    auto data = *f;
    auto name = data.second;
    auto size = files[name].size;
    if (lpFileSizeHigh) {
        *lpFileSizeHigh = size >> 32;
    }
    return size;
}

BOOL VFS::GetFileSizeEx(HANDLE hFile, PLARGE_INTEGER lpFileSize) {
    auto f = handles.find(hFile);
    if (f == handles.end()) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    auto data = *f;
    auto name = data.second;
    auto size = files[name].size;
    lpFileSize->QuadPart = size;
    return TRUE;
}

DWORD VFS::SetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod) {
    if (!ContainsHandle(hFile)) {
        SetLastError(ERROR_INVALID_HANDLE);
        return INVALID_SET_FILE_POINTER;
    }
    zip_file_t* file = (zip_file_t*)hFile;
    if (!file) {
        SetLastError(ERROR_INVALID_HANDLE);
        return INVALID_SET_FILE_POINTER;
    }
    zip_int64_t offset = lDistanceToMove;
    if (lpDistanceToMoveHigh) {
        offset |= ((zip_int64_t)*lpDistanceToMoveHigh) << 32;
    }
    zip_int8_t code = zip_fseek(file, offset, dwMoveMethod);
    if (code == -1) {
        SetLastError(mapZipError(file));
        return INVALID_SET_FILE_POINTER;
    }
    zip_int64_t n = zip_ftell(file);
    if (n == -1) {
        SetLastError(mapZipError(file));
        return INVALID_SET_FILE_POINTER;
    }
    if (lpDistanceToMoveHigh) {
        *lpDistanceToMoveHigh = n >> 32;
    }
    return n;
}

BOOL VFS::SetFilePointerEx(HANDLE hFile, LARGE_INTEGER liDistanceToMove, PLARGE_INTEGER lpNewFilePointer, DWORD dwMoveMethod) {
    if (!ContainsHandle(hFile)) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    zip_file_t* file = (zip_file_t*)hFile;
    if (!file) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    zip_int64_t offset = liDistanceToMove.QuadPart;
    zip_int8_t code = zip_fseek(file, offset, dwMoveMethod);
    if (code == -1) {
        SetLastError(mapZipError(file));
        return FALSE;
    }
    zip_int64_t n = zip_ftell(file);
    if (n == -1) {
        SetLastError(mapZipError(file));
        return FALSE;
    }
    if (lpNewFilePointer) {
        lpNewFilePointer->QuadPart = n;
    }
    return TRUE;
}

std::string VFS::GetBasePath() {
    return base_path;
}

BOOL VFS::GetFileAttributesExW(LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation) {
    std::string path;
    if (!wchar_util::wstr_to_str(path, lpFileName, CP_UTF8)) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    path = str_util::str_replace(path, "/", "\\");
    if (fileop::isabs(path)) {
        path = fileop::relpath(path, base_path);
    }
    auto c = files.find(path);
    if (c == files.end()) {
        SetLastError(ERROR_FILE_NOT_FOUND);
        return FALSE;
    }
    auto st = (*c).second;
    if (fInfoLevelId == GetFileExInfoStandard) {
        if (!lpFileInformation) {
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
        WIN32_FILE_ATTRIBUTE_DATA data;
        data.dwFileAttributes = FILE_ATTRIBUTE_READONLY;
        time_util::time_t_to_file_time(st.mtime, &data.ftLastWriteTime);
        data.ftCreationTime = data.ftLastWriteTime;
        data.ftLastAccessTime = data.ftLastWriteTime;
        data.nFileSizeHigh = st.size >> 32;
        data.nFileSizeLow = st.size & 0xFFFFFFFF;
        memcpy(lpFileInformation, &data, sizeof(data));
        return TRUE;
    }
    return FALSE;
}