/*
 * Copyright (c) 2016, NVIDIA CORPORATION.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and/or associated documentation files (the
 * "Materials"), to deal in the Materials without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Materials, and to
 * permit persons to whom the Materials are furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * unaltered in all copies or substantial portions of the Materials.
 * Any additions, deletions, or changes to the original source files
 * must be clearly indicated in accompanying documentation.
 *
 * If only executable code is distributed, then the accompanying
 * documentation must state that "this software is based in part on the
 * work of the Khronos Group."
 *
 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
 */

#include "libeglerror.h"

#include <string.h>
#include <assert.h>

#include <EGL/egl.h>
#include <EGL/eglext.h>

#include "glvnd_pthread.h"
#include "libeglmapping.h"
#include "libeglcurrent.h"
#include "utils_misc.h"

enum
{
    __EGL_DEBUG_BIT_CRITICAL = 0x1,
    __EGL_DEBUG_BIT_ERROR = 0x2,
    __EGL_DEBUG_BIT_WARN = 0x4,
    __EGL_DEBUG_BIT_INFO = 0x8,
};

static inline unsigned int DebugBitFromType(GLenum type);

static EGLDEBUGPROCKHR debugCallback = NULL;
static unsigned int debugTypeEnabled = __EGL_DEBUG_BIT_CRITICAL | __EGL_DEBUG_BIT_ERROR;
static glvnd_rwlock_t debugLock = GLVND_RWLOCK_INITIALIZER;

static inline unsigned int DebugBitFromType(EGLenum type)
{
    assert(type >= EGL_DEBUG_MSG_CRITICAL_KHR &&
            type <= EGL_DEBUG_MSG_INFO_KHR);
    return (1 << (type - EGL_DEBUG_MSG_CRITICAL_KHR));
}

EGLint eglDebugMessageControlKHR(EGLDEBUGPROCKHR callback,
        const EGLAttrib *attrib_list)
{
    unsigned int newEnabled = debugTypeEnabled;
    struct glvnd_list *vendorList;
    __EGLvendorInfo *vendor;
    int i;

    __eglEntrypointCommon();

    // Parse the attribute list. Note that if (callback != NULL), then we'll
    // check for errors even though we otherwise ignore it.
    if (attrib_list != NULL) {
        for (i = 0; attrib_list[i] != EGL_NONE; i += 2) {
            if (attrib_list[i] >= EGL_DEBUG_MSG_CRITICAL_KHR &&
                    attrib_list[i] <= EGL_DEBUG_MSG_INFO_KHR) {
                if (attrib_list[i + 1]) {
                    newEnabled |= DebugBitFromType(attrib_list[i]);
                } else {
                    newEnabled &= ~DebugBitFromType(attrib_list[i]);
                }
            } else {
                // On error, set the last error code, call the current
                // debug callback, and return the error code.
                __eglReportError(EGL_BAD_ATTRIBUTE, "eglDebugMessageControlKHR", NULL,
                        "Invalid attribute 0x%04lx", (unsigned long) attrib_list[i]);
                return EGL_BAD_ATTRIBUTE;
            }
        }
    }

    __glvndPthreadFuncs.rwlock_wrlock(&debugLock);

    if (callback != NULL) {
        debugCallback = callback;
        debugTypeEnabled = newEnabled;
    } else {
        debugCallback = NULL;
        debugTypeEnabled = __EGL_DEBUG_BIT_CRITICAL | __EGL_DEBUG_BIT_ERROR;
    }

    // Call into each vendor library.
    vendorList = __eglLoadVendors();
    glvnd_list_for_each_entry(vendor, vendorList, entry) {
        if (vendor->staticDispatch.debugMessageControlKHR != NULL) {
            EGLint result = vendor->staticDispatch.debugMessageControlKHR(callback, attrib_list);
            if (result != EGL_SUCCESS && (debugTypeEnabled & __EGL_DEBUG_BIT_WARN) && callback != NULL) {
                char buf[200];
                snprintf(buf, sizeof(buf), "eglDebugMessageControlKHR failed in vendor library with error 0x%04x. Error reporting may not work correctly.", result);
                callback(EGL_SUCCESS, "eglDebugMessageControlKHR", EGL_DEBUG_MSG_WARN_KHR,
                        __eglGetThreadLabel(), NULL, buf);
            }
        } else if ((debugTypeEnabled & __EGL_DEBUG_BIT_WARN) && callback != NULL) {
            callback(EGL_SUCCESS, "eglDebugMessageControlKHR", EGL_DEBUG_MSG_WARN_KHR,
                    __eglGetThreadLabel(), NULL,
                    "eglDebugMessageControlKHR is not supported by vendor library. Error reporting may not work correctly.");
        }
    }

    __glvndPthreadFuncs.rwlock_unlock(&debugLock);
    return EGL_SUCCESS;
}

EGLBoolean eglQueryDebugKHR(EGLint attribute, EGLAttrib *value)
{
    __eglEntrypointCommon();

    __glvndPthreadFuncs.rwlock_rdlock(&debugLock);
    if (attribute >= EGL_DEBUG_MSG_CRITICAL_KHR &&
            attribute <= EGL_DEBUG_MSG_INFO_KHR) {
        if (debugTypeEnabled & DebugBitFromType(attribute)) {
            *value = EGL_TRUE;
        } else {
            *value = EGL_FALSE;
        }
    } else if (attribute == EGL_DEBUG_CALLBACK_KHR) {
        *value = (EGLAttrib) debugCallback;
    } else {
        __glvndPthreadFuncs.rwlock_unlock(&debugLock);
        __eglReportError(EGL_BAD_ATTRIBUTE, "eglQueryDebugKHR", NULL,
                "Invalid attribute 0x%04lx", (unsigned long) attribute);
        return EGL_FALSE;
    }
    __glvndPthreadFuncs.rwlock_unlock(&debugLock);
    return EGL_TRUE;
}

EGLint eglLabelObjectKHR(
        EGLDisplay display,
        EGLenum objectType,
        EGLObjectKHR object,
        EGLLabelKHR label)
{
    __eglEntrypointCommon();

    if (objectType == EGL_OBJECT_THREAD_KHR) {
        struct glvnd_list *vendorList;
        __EGLThreadAPIState *state = __eglGetCurrentThreadAPIState(label != NULL);
        __EGLvendorInfo *vendor;

        if (state != NULL) {
            if (state->label == label) {
                return EGL_SUCCESS;
            }
            state->label = label;
        } else {
            if (label == NULL) {
                return EGL_SUCCESS;
            }
        }

        vendorList = __eglLoadVendors();
        glvnd_list_for_each_entry(vendor, vendorList, entry) {
            if (vendor->staticDispatch.labelObjectKHR != NULL) {
                EGLint result = vendor->staticDispatch.labelObjectKHR(NULL, objectType, NULL, label);
                if (result != EGL_SUCCESS) {
                    __eglReportWarn("eglLabelObjectKHR", NULL,
                            "eglLabelObjectKHR failed in vendor library with error 0x%04x. Thread label may not be reported correctly.",
                            result);
                }
            } else {
                __eglReportWarn("eglLabelObjectKHR", NULL,
                        "eglLabelObjectKHR is not supported by vendor library. Thread label may not be reported correctly.");
            }
        }
        return EGL_SUCCESS;
    } else {
        __EGLdisplayInfo *dpyInfo = __eglLookupDisplay(display);
        if (dpyInfo == NULL) {
            __eglReportError(EGL_BAD_DISPLAY, "eglLabelObjectKHR", NULL,
                    "Invalid display %p", display);
            return EGL_BAD_DISPLAY;
        }

        if (objectType == EGL_OBJECT_DISPLAY_KHR) {
            if (display != (EGLDisplay) object) {
                __eglReportError(EGL_BAD_PARAMETER, "eglLabelObjectKHR", NULL,
                        "Display %p and object %p do not match", display, object);
                return EGL_BAD_PARAMETER;
            }
        }

        if (dpyInfo->vendor->staticDispatch.labelObjectKHR != NULL) {
            __eglSetLastVendor(dpyInfo->vendor);
            return dpyInfo->vendor->staticDispatch.labelObjectKHR(display, objectType, object, label);
        } else {
            __eglReportError(EGL_BAD_PARAMETER, "eglLabelObjectKHR", NULL,
                    "eglLabelObjectKHR is not supported by vendor library. Object label may not be reported correctly.");
            return EGL_BAD_PARAMETER;
        }
    }
}

EGLLabelKHR __eglGetThreadLabel(void)
{
    __EGLThreadAPIState *state = __eglGetCurrentThreadAPIState(EGL_FALSE);
    if (state != NULL) {
        return state->label;
    } else {
        return NULL;
    }
}

void __eglDebugReport(EGLenum error, const char *command, EGLint type, EGLLabelKHR objectLabel, const char *message, ...)
{
    EGLDEBUGPROCKHR callback = NULL;

    __glvndPthreadFuncs.rwlock_rdlock(&debugLock);
    if (debugTypeEnabled & DebugBitFromType(type)) {
        callback = debugCallback;
    }
    __glvndPthreadFuncs.rwlock_unlock(&debugLock);

    if (callback != NULL) {
        char *buf = NULL;

        if (message != NULL) {
            va_list args;
            va_start(args, message);
            if (glvnd_vasprintf(&buf, message, args) < 0) {
                buf = NULL;
            }
            va_end(args);
        }
        callback(error, command, type, __eglGetThreadLabel(),
                objectLabel, buf);
        free(buf);
    }

    if (type == EGL_DEBUG_MSG_CRITICAL_KHR || type == EGL_DEBUG_MSG_ERROR_KHR) {
        __eglSetError(error);
    }
}