/*
 ** Copyright 2010, The Android Open Source Project
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */

#if EGL_TRACE

#include <stdarg.h>
#include <stdlib.h>

#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <GLES/gl.h>
#include <GLES/glext.h>

#include <cutils/log.h>

#include "hooks.h"

// ----------------------------------------------------------------------------
namespace android {
// ----------------------------------------------------------------------------

struct GLenumString {
    GLenum e;
    const char* s;
};

#undef GL_ENUM
#define GL_ENUM(VAL,NAME) {VAL, #NAME},

static GLenumString g_enumnames[] = {
#include "enums.in"
};
#undef GL_ENUM

static int compareGLEnum(const void* a, const void* b) {
    return ((const GLenumString*) a)->e - ((const GLenumString*) b)->e;
}

static const char* GLEnumToString(GLenum e) {
    GLenumString key = {e, ""};
    const GLenumString* result = (const GLenumString*) bsearch(
        &key, g_enumnames,
        sizeof(g_enumnames) / sizeof(g_enumnames[0]),
        sizeof(g_enumnames[0]), compareGLEnum);
    if (result) {
        return result->s;
    }
    return NULL;
}

static const char* GLbooleanToString(GLboolean arg) {
    return arg ? "GL_TRUE" : "GL_FALSE";
}

static GLenumString g_bitfieldNames[] = {
    {0x00004000, "GL_COLOR_BUFFER_BIT"},
    {0x00000400, "GL_STENCIL_BUFFER_BIT"},
    {0x00000100, "GL_DEPTH_BUFFER_BIT"}
};

class StringBuilder {
    static const int lineSize = 500;
    char line[lineSize];
    int line_index;
public:
    StringBuilder() {
        line_index = 0;
        line[0] = '\0';
    }
    void append(const char* fmt, ...) {
        va_list argp;
        va_start(argp, fmt);
        line_index += vsnprintf(line + line_index, lineSize-line_index, fmt, argp);
        va_end(argp);
    }
    const char* getString() {
        line_index = 0;
        line[lineSize-1] = '\0';
        return line;
    }
};


static void TraceGLShaderSource(GLuint shader, GLsizei count,
    const GLchar** string, const GLint* length) {
    LOGD("const char* shaderSrc[] = {");
    for (GLsizei i = 0; i < count; i++) {
        const char* comma = i < count-1 ? "," : "";
        const GLchar* s = string[i];
        if (length) {
            GLint len = length[i];
            LOGD("    \"%*s\"%s", len, s, comma);
        } else {
            LOGD("    \"%s\"%s", s, comma);
        }
    }
    LOGD("};");
    if (length) {
        LOGD("const GLint* shaderLength[] = {");
        for (GLsizei i = 0; i < count; i++) {
            const char* comma = i < count-1 ? "," : "";
            GLint len = length[i];
            LOGD("    \"%d\"%s", len, comma);
        }
        LOGD("};");
        LOGD("glShaderSource(%u, %u, shaderSrc, shaderLength);",
            shader, count);
    } else {
        LOGD("glShaderSource(%u, %u, shaderSrc, (const GLint*) 0);",
            shader, count);
    }
}

static void TraceValue(int elementCount, char type,
        GLsizei chunkCount, GLsizei chunkSize, const void* value) {
    StringBuilder stringBuilder;
    GLsizei count = chunkCount * chunkSize;
    bool isFloat = type == 'f';
    const char* typeString = isFloat ? "GLfloat" : "GLint";
    LOGD("const %s value[] = {", typeString);
    for (GLsizei i = 0; i < count; i++) {
        StringBuilder builder;
        builder.append("    ");
        for (int e = 0; e < elementCount; e++) {
            const char* comma = ", ";
            if (e == elementCount-1) {
                if (i == count - 1) {
                    comma = "";
                } else {
                    comma = ",";
                }
            }
            if (isFloat) {
                builder.append("%g%s", * (GLfloat*) value, comma);
                value = (void*) (((GLfloat*) value) + 1);
            } else {
                builder.append("%d%s", * (GLint*) value, comma);
                value = (void*) (((GLint*) value) + 1);
            }
        }
        LOGD("%s", builder.getString());
        if (chunkSize > 1 && i < count-1
                && (i % chunkSize) == (chunkSize-1)) {
            LOGD("%s", ""); // Print a blank line.
        }
    }
    LOGD("};");
}

static void TraceUniformv(int elementCount, char type,
        GLuint location, GLsizei count, const void* value) {
    TraceValue(elementCount, type, count, 1, value);
    LOGD("glUniform%d%c(%u, %u, value);", elementCount, type, location, count);
}

static void TraceUniformMatrix(int matrixSideLength,
        GLuint location, GLsizei count, GLboolean transpose, const void* value) {
    TraceValue(matrixSideLength, 'f', count, matrixSideLength, value);
    LOGD("glUniformMatrix%dfv(%u, %u, %s, value);", matrixSideLength, location, count,
            GLbooleanToString(transpose));
}

static void TraceGL(const char* name, int numArgs, ...) {
    va_list argp;
    va_start(argp, numArgs);
    int nameLen = strlen(name);

    // glShaderSource
    if (nameLen == 14 && strcmp(name, "glShaderSource") == 0) {
        va_arg(argp, const char*);
        GLuint shader = va_arg(argp, GLuint);
        va_arg(argp, const char*);
        GLsizei count = va_arg(argp, GLsizei);
        va_arg(argp, const char*);
        const GLchar** string = (const GLchar**) va_arg(argp, void*);
        va_arg(argp, const char*);
        const GLint* length = (const GLint*) va_arg(argp, void*);
        va_end(argp);
        TraceGLShaderSource(shader, count, string, length);
        return;
    }

    // glUniformXXv

    if (nameLen == 12 && strncmp(name, "glUniform", 9) == 0 && name[11] == 'v') {
        int elementCount = name[9] - '0'; // 1..4
        char type = name[10]; // 'f' or 'i'
        va_arg(argp, const char*);
        GLuint location = va_arg(argp, GLuint);
        va_arg(argp, const char*);
        GLsizei count = va_arg(argp, GLsizei);
        va_arg(argp, const char*);
        const void* value = (const void*) va_arg(argp, void*);
        va_end(argp);
        TraceUniformv(elementCount, type, location, count, value);
        return;
    }

    // glUniformMatrixXfv

    if (nameLen == 18 && strncmp(name, "glUniformMatrix", 15) == 0
            && name[16] == 'f' && name[17] == 'v') {
        int matrixSideLength = name[15] - '0'; // 2..4
        va_arg(argp, const char*);
        GLuint location = va_arg(argp, GLuint);
        va_arg(argp, const char*);
        GLsizei count = va_arg(argp, GLsizei);
        va_arg(argp, const char*);
        GLboolean transpose = (GLboolean) va_arg(argp, int);
        va_arg(argp, const char*);
        const void* value = (const void*) va_arg(argp, void*);
        va_end(argp);
        TraceUniformMatrix(matrixSideLength, location, count, transpose, value);
        return;
    }

    StringBuilder builder;
    builder.append("%s(", name);
    for (int i = 0; i < numArgs; i++) {
        if (i > 0) {
            builder.append(", ");
        }
        const char* type = va_arg(argp, const char*);
        bool isPtr = type[strlen(type)-1] == '*'
            || strcmp(type, "GLeglImageOES") == 0;
        if (isPtr) {
            const void* arg = va_arg(argp, const void*);
            builder.append("(%s) 0x%08x", type, (size_t) arg);
        } else if (strcmp(type, "GLbitfield") == 0) {
            size_t arg = va_arg(argp, size_t);
            bool first = true;
            for (size_t i = 0; i < sizeof(g_bitfieldNames) / sizeof(g_bitfieldNames[0]); i++) {
                const GLenumString* b = &g_bitfieldNames[i];
                if (b->e & arg) {
                    if (first) {
                        first = false;
                    } else {
                        builder.append(" | ");
                    }
                    builder.append("%s", b->s);
                    arg &= ~b->e;
                }
            }
            if (first || arg != 0) {
                if (!first) {
                    builder.append(" | ");
                }
                builder.append("0x%08x", arg);
            }
        } else if (strcmp(type, "GLboolean") == 0) {
            GLboolean arg = va_arg(argp, int);
            builder.append("%s", GLbooleanToString(arg));
        } else if (strcmp(type, "GLclampf") == 0) {
            double arg = va_arg(argp, double);
            builder.append("%g", arg);
        } else if (strcmp(type, "GLenum") == 0) {
            GLenum arg = va_arg(argp, int);
            const char* s = GLEnumToString(arg);
            if (s) {
                builder.append("%s", s);
            } else {
                builder.append("0x%x", arg);
            }
        } else if (strcmp(type, "GLfixed") == 0) {
            int arg = va_arg(argp, int);
            builder.append("0x%08x", arg);
        } else if (strcmp(type, "GLfloat") == 0) {
            double arg = va_arg(argp, double);
            builder.append("%g", arg);
        } else if (strcmp(type, "GLint") == 0) {
            int arg = va_arg(argp, int);
            const char* s = NULL;
            if (strcmp(name, "glTexParameteri") == 0) {
                s = GLEnumToString(arg);
            }
            if (s) {
                builder.append("%s", s);
            } else {
                builder.append("%d", arg);
            }
        } else if (strcmp(type, "GLintptr") == 0) {
            int arg = va_arg(argp, unsigned int);
            builder.append("%u", arg);
        } else if (strcmp(type, "GLsizei") == 0) {
            int arg = va_arg(argp, size_t);
            builder.append("%u", arg);
        } else if (strcmp(type, "GLsizeiptr") == 0) {
            int arg = va_arg(argp, size_t);
            builder.append("%u", arg);
        } else if (strcmp(type, "GLuint") == 0) {
            int arg = va_arg(argp, unsigned int);
            builder.append("%u", arg);
        } else {
            builder.append("/* ??? %s */", type);
            break;
        }
    }
    builder.append(");");
    LOGD("%s", builder.getString());
    va_end(argp);
}

#undef TRACE_GL_VOID
#undef TRACE_GL

#define TRACE_GL_VOID(_api, _args, _argList, ...)                         \
static void Tracing_ ## _api _args {                                      \
    TraceGL(#_api, __VA_ARGS__);                                          \
    gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;  \
    _c->_api _argList;                                                    \
}

#define TRACE_GL(_type, _api, _args, _argList, ...)                       \
static _type Tracing_ ## _api _args {                                     \
    TraceGL(#_api, __VA_ARGS__);                                          \
    gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;  \
    return _c->_api _argList;                                             \
}

extern "C" {
#include "../trace.in"
}
#undef TRACE_GL_VOID
#undef TRACE_GL

#define GL_ENTRY(_r, _api, ...) Tracing_ ## _api,

EGLAPI gl_hooks_t gHooksTrace = {
    {
        #include "entries.in"
    },
    {
        {0}
    }
};
#undef GL_ENTRY

// ----------------------------------------------------------------------------
}; // namespace android
// ----------------------------------------------------------------------------

#endif // EGL_TRACE
