#define DLL_NAME "kernel32.dll"
#define NOUSER
#include "common.h"
#include "kernel32.h"
#include <tlhelp32.h>

typedef LPWCH (__cdecl *wcscpyPtr)(LPWCH dest, LPWCH source);
typedef size_t (__cdecl *wcstombsPtr)(LPSTR dest, LPWCH source, size_t maxCount);
typedef LONG (WINAPI *RegOpenKeyExWPtr)(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult);
typedef LONG (WINAPI *RegQueryValueExWPtr)(HKEY hKey, LPCWSTR lpValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData);
typedef LONG (WINAPI *RegCloseKeyPtr)(HKEY hKey);

DLL_EXPORT WINAPI BOOL GetVersionExW(LPOSVERSIONINFOW version) {
    //logDebug("GetVersionEx: Wrapping Call");
    if (version->dwOSVersionInfoSize == sizeof(OSVERSIONINFOW)) {
        version->dwMajorVersion = 4;
        version->dwMinorVersion = 0;
        version->dwBuildNumber = 1381;
        version->dwPlatformId = VER_PLATFORM_WIN32_NT;
        version->szCSDVersion[0] = L'\0';

        RegOpenKeyExWPtr regOpenKeyExW = (RegOpenKeyExWPtr) getFunction("advapi32.dll", "RegOpenKeyExW");
        RegQueryValueExWPtr regQueryValueExW = (RegQueryValueExWPtr) getFunction("advapi32.dll", "RegQueryValueExW");
        RegCloseKeyPtr regCloseKey = (RegCloseKeyPtr) getFunction("advapi32.dll", "RegCloseKey");
        HKEY key;
        if (regOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\BCompat", 0, KEY_READ, &key) == ERROR_SUCCESS) {
            DWORD size = sizeof(DWORD);
            DWORD major = 0;
            if (regQueryValueExW(key, L"ReportedMajor", NULL, NULL, (LPBYTE) &major, &size) == ERROR_SUCCESS) {
                version->dwMajorVersion = major;
            }
            DWORD minor = 0;
            if (regQueryValueExW(key, L"ReportedMinor", NULL, NULL, (LPBYTE) &minor, &size) == ERROR_SUCCESS) {
                version->dwMinorVersion = minor;
            }
            DWORD build = 0;
            if (regQueryValueExW(key, L"ReportedBuild", NULL, NULL, (LPBYTE) &build, &size) == ERROR_SUCCESS) {
                version->dwBuildNumber = build;
            }
            DWORD platform = 0;
            if (regQueryValueExW(key, L"ReportedPlatform", NULL, NULL, (LPBYTE) &platform, &size) == ERROR_SUCCESS) {
                version->dwPlatformId = platform;
            }
            size = sizeof(version->szCSDVersion);
            if (regQueryValueExW(key, L"ReportedServicePack", NULL, NULL, (LPBYTE) &version->szCSDVersion, &size) == ERROR_SUCCESS) {
                version->szCSDVersion[127] = L'\0';
            }
            regCloseKey(key);
        }
        return TRUE;
    } else {
        logWarn("GetVersionExW: Invalid Buffer Size");
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }
}

DLL_EXPORT WINAPI BOOL GetVersionExA(LPOSVERSIONINFOA version) {
    if (version->dwOSVersionInfoSize == sizeof(OSVERSIONINFOA)) {
        OSVERSIONINFOW versionW;
        versionW.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
        if (GetVersionExW(&versionW)) {
            version->dwMajorVersion = versionW.dwMajorVersion;
            version->dwMinorVersion = versionW.dwMinorVersion;
            version->dwBuildNumber = versionW.dwBuildNumber;
            version->dwPlatformId = versionW.dwPlatformId;
            version->szCSDVersion[0] = '\0';
            wcstombsPtr wcstombs = (wcstombsPtr) getFunction("msvcrt.dll", "wcstombs");
            wcstombs(version->szCSDVersion, versionW.szCSDVersion, ARRAYSIZE(version->szCSDVersion));
            return TRUE;
        }
        return FALSE;
    } else {
        logWarn("GetVersionExA: Invalid Buffer Size");
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }
}

DLL_EXPORT WINAPI DWORD GetVersion() {
    logDebug("GetVersion: Legacy Function called");
    OSVERSIONINFOW versionW;
    if (GetVersionExW(&versionW)) {
        return (versionW.dwPlatformId ^ 2) << 30 |
                versionW.dwBuildNumber     << 16 |
                versionW.dwMinorVersion    << 8  |
                versionW.dwMajorVersion;
    } else {
        return -1;
    }
}

DLL_EXPORT WINAPI HANDLE CreateToolhelp32Snapshot(DWORD dwFlags, DWORD th32ProcessID) {
    /*if (dwFlags == TH32CS_SNAPPROCESS) {
        logDebug("GetVersionEx: Called with TH32CS_SNAPPROCESS");
    } else {
        if (dwFlags & TH32CS_INHERIT) {
            logError("CreateToolhelp32Snapshot: Unsupported flag TH32CS_INHERIT");
        }
        if (dwFlags & TH32CS_SNAPHEAPLIST) {
            logError("CreateToolhelp32Snapshot: Unsupported flag TH32CS_SNAPHEAPLIST");
        }
        if (dwFlags & TH32CS_SNAPMODULE) {
            logError("CreateToolhelp32Snapshot: Unsupported flag TH32CS_SNAPMODULE");
        }
        if (dwFlags & TH32CS_SNAPMODULE32   ) {
            logError("CreateToolhelp32Snapshot: Unsupported flag TH32CS_SNAPMODULE32");
        }
        if (dwFlags & TH32CS_SNAPTHREAD) {
            logError("CreateToolhelp32Snapshot: Unsupported flag TH32CS_SNAPTHREAD");
        }*/
        logError("CreateToolhelp32Snapshot: Unimplemented");
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        return INVALID_HANDLE_VALUE;
    //}
}

DLL_EXPORT WINAPI BOOL Process32First(HANDLE hSnapshot, LPPROCESSENTRY32 lppe) {
    logError("Process32First: Unimplemented");
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return FALSE;
}

DLL_EXPORT WINAPI BOOL Process32Next(HANDLE hSnapshot, LPPROCESSENTRY32 lppe) {
    logError("Process32Next: Unimplemented");
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return FALSE;
}

DLL_EXPORT WINAPI BOOL Process32FirstW(HANDLE hSnapshot, LPPROCESSENTRY32W lppe) {
    logError("Process32FirstW: Unimplemented");
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return FALSE;
}

DLL_EXPORT WINAPI BOOL Process32NextW(HANDLE hSnapshot, LPPROCESSENTRY32W lppe) {
    logError("Process32NextW: Unimplemented");
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return FALSE;
}

DLL_EXPORT WINAPI LANGID GetUserDefaultUILanguage() {
    logDebug("GetUserDefaultUILanguage: Called");
    return GetSystemDefaultLangID();
}

DLL_EXPORT WINAPI DWORD GetLongPathNameW(LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWORD cchBuffer) {
    
}