/*
* Copyright (C) 2011 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.
*/

#include "ProgramData.h"
#include "apigen-codec-common/glUtils.h"

#include "aemu/base/containers/Lookup.h"
#include "aemu/base/files/StreamSerializing.h"
#include "ANGLEShaderParser.h"
#include "GLcommon/GLutils.h"
#include "GLcommon/GLESmacros.h"
#include "GLcommon/ShareGroup.h"

#include <GLES3/gl31.h>
#include <string.h>
#include <unordered_set>

GLUniformDesc::GLUniformDesc(const char* name, GLint location, GLsizei count, GLboolean transpose,
            GLenum type, GLsizei size, unsigned char* val)
        : mCount(count), mTranspose(transpose), mType(type)
        , mVal(val, val + size), mGuestName(name) { }

GLUniformDesc::GLUniformDesc(android::base::Stream* stream) {
    mCount = stream->getBe32();
    mTranspose = stream->getByte();
    mType = stream->getBe32();
    loadBuffer(stream, &mVal);
    mGuestName = stream->getString();
}

void GLUniformDesc::onSave(android::base::Stream* stream) const {
    stream->putBe32(mCount);
    stream->putByte(mTranspose);
    stream->putBe32(mType);
    saveBuffer(stream, mVal);
    stream->putString(mGuestName);
}

static int s_glShaderType2ShaderType(GLenum type) {
    switch (type) {
    case GL_VERTEX_SHADER:
        return ProgramData::VERTEX;
        break;
    case GL_FRAGMENT_SHADER:
        return ProgramData::FRAGMENT;
        break;
    case GL_COMPUTE_SHADER:
        return ProgramData::COMPUTE;
        break;
    default:
        assert(0);
        break;
    }
    return ProgramData::NUM_SHADER_TYPE;
}

ProgramData::ProgramData(int glesMaj, int glesMin)
    : ObjectData(PROGRAM_DATA),
      ValidateStatus(false),
      LinkStatus(false),
      HostLinkStatus(false),
      IsInUse(false),
      DeleteStatus(false),
      mGlesMajorVersion(glesMaj),
      mGlesMinorVersion(glesMin) {}

ProgramData::ProgramData(android::base::Stream* stream) :
    ObjectData(stream) {
    auto loadAttribLocs = [](android::base::Stream* stream) {
                std::string attrib = stream->getString();
                GLuint loc = stream->getBe32();
                return std::make_pair(std::move(attrib), loc);
            };
    loadCollection(stream, &boundAttribLocs, loadAttribLocs);
    loadCollection(stream, &linkedAttribLocs, loadAttribLocs);

    loadCollection(stream, &uniforms, [](android::base::Stream* stream) {
       GLuint loc = stream->getBe32();
       GLUniformDesc desc(stream);
       return std::make_pair(loc, std::move(desc));
    });
    loadCollection(stream, &mUniformBlockBinding,
            [](android::base::Stream* stream) {
                GLuint block = stream->getBe32();
                GLuint binding = stream->getBe32();
                return std::make_pair(block, binding);
    });
    int transformFeedbackCount = stream->getBe32();
    mTransformFeedbacks.resize(transformFeedbackCount);
    for (auto& feedback : mTransformFeedbacks) {
        feedback = stream->getString();
    }
    mTransformFeedbackBufferMode = stream->getBe32();

    for (auto& s : attachedShaders) {
        s.localName = stream->getBe32();
        s.linkedSource = stream->getString();
    }
    validationInfoLog = stream->getString();
    infoLog = stream->getString();

    stream->getBe16(); /* padding to maintain snapshot file compatibility */
    ValidateStatus = stream->getByte();
    LinkStatus = stream->getByte();
    IsInUse = stream->getByte();
    DeleteStatus = stream->getByte();

    mGlesMajorVersion = stream->getByte();
    mGlesMinorVersion = stream->getByte();
    loadCollection(stream, &mUniNameToGuestLoc,
            [](android::base::Stream* stream) {
        std::string name = stream->getString();
        int loc = stream->getBe32();
        return std::make_pair(name, loc);
    });
}

void ProgramData::getUniformValue(const GLchar *name, GLenum type,
        std::unordered_map<GLuint, GLUniformDesc> &uniformsOnSave) const {
    alignas(double) unsigned char val[256];     //Large enought to hold MAT4x4
    GLDispatch& dispatcher = GLEScontext::dispatcher();

    GLint location = dispatcher.glGetUniformLocation(ProgramName, name);
    if (location < 0) {
        return;
    }
    switch(type) {
    case GL_FLOAT:
    case GL_FLOAT_VEC2:
    case GL_FLOAT_VEC3:
    case GL_FLOAT_VEC4:
    case GL_FLOAT_MAT2:
    case GL_FLOAT_MAT3:
    case GL_FLOAT_MAT4:
    case GL_FLOAT_MAT2x3:
    case GL_FLOAT_MAT2x4:
    case GL_FLOAT_MAT3x2:
    case GL_FLOAT_MAT3x4:
    case GL_FLOAT_MAT4x2:
    case GL_FLOAT_MAT4x3:
        dispatcher.glGetUniformfv(ProgramName, location, (GLfloat *)val);
        break;
    case GL_INT:
    case GL_INT_VEC2:
    case GL_INT_VEC3:
    case GL_INT_VEC4:
    case GL_BOOL:
    case GL_BOOL_VEC2:
    case GL_BOOL_VEC3:
    case GL_BOOL_VEC4:
    case GL_SAMPLER_2D:
    case GL_SAMPLER_3D:
    case GL_SAMPLER_CUBE:
    case GL_SAMPLER_2D_SHADOW:
    case GL_SAMPLER_2D_ARRAY:
    case GL_SAMPLER_2D_ARRAY_SHADOW:
    case GL_SAMPLER_CUBE_SHADOW:
    case GL_INT_SAMPLER_2D:
    case GL_INT_SAMPLER_3D:
    case GL_INT_SAMPLER_CUBE:
    case GL_INT_SAMPLER_2D_ARRAY:
    case GL_UNSIGNED_INT_SAMPLER_2D:
    case GL_UNSIGNED_INT_SAMPLER_3D:
    case GL_UNSIGNED_INT_SAMPLER_CUBE:
    case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
        dispatcher.glGetUniformiv(ProgramName, location, (GLint *)val);
        break;
    case GL_UNSIGNED_INT:
    case GL_UNSIGNED_INT_VEC2:
    case GL_UNSIGNED_INT_VEC3:
    case GL_UNSIGNED_INT_VEC4:
        dispatcher.glGetUniformuiv(ProgramName, location, (GLuint *)val);
        break;
    default:
        fprintf(stderr, "ProgramData::gtUniformValue: warning: "
                "unsupported uniform type 0x%x\n", type);
        return;
    }
    GLUniformDesc uniformDesc(name, location, 1, 0, /*transpose*/
        type, glSizeof(type), val);

    if (!isGles2Gles()) {
        uniformDesc.mGuestName = getDetranslatedName(uniformDesc.mGuestName);
    }

    uniformsOnSave[location] = std::move(uniformDesc);
}

static std::string getBaseName(const std::string& name) {
    std::string baseName;
    int length = name.length();
    if (length < 3) return name;
    if (name.compare(length - 3, 1, "[") == 0) {
        baseName = name.substr(0, length - 3);
    } else {
        baseName = name;
    }
    return baseName;
}

// Query uniform variables from driver
std::unordered_map<GLuint, GLUniformDesc> ProgramData::collectUniformInfo() const {
    GLint uniform_count = 0;
    GLint nameLength = 0;
    std::unordered_map<GLuint, GLUniformDesc> uniformsOnSave;
    GLDispatch& dispatcher = GLEScontext::dispatcher();
    dispatcher.glGetProgramiv(ProgramName, GL_ACTIVE_UNIFORM_MAX_LENGTH, &nameLength);
    if (nameLength == 0) {
        // No active uniform variables exist.
        return uniformsOnSave;
    }
    dispatcher.glGetProgramiv(ProgramName, GL_ACTIVE_UNIFORMS, &uniform_count);
    std::vector<char> name(nameLength, 0);
    for (int i = 0; i < uniform_count; i++) {
        GLint size;
        GLenum type;
        GLsizei length;
        dispatcher.glGetActiveUniform(ProgramName, i, nameLength, &length,
                &size, &type, name.data());
        if (size > 1) {
            // Uniform array, drivers may return 'arrayName' or 'arrayName[0]'
            // as the name of the array.
            // Need to append '[arrayIndex]' after 'arrayName' to query the
            // value for each array member.
            std::string baseName = getBaseName(std::string(name.data()));
            for (int arrayIndex = 0; arrayIndex < size; arrayIndex++) {
                std::ostringstream oss;
                oss << baseName << '[' << arrayIndex << ']';
                std::string toSaveName = oss.str();
                getUniformValue(toSaveName.c_str(), type, uniformsOnSave);
            }
        }
        else {
            getUniformValue(name.data(), type, uniformsOnSave);
        }
    }
    return uniformsOnSave;
}

static std::unordered_map<GLuint, GLuint> collectUniformBlockInfo(GLuint pname) {
    GLint uniformBlockCount = 0;
    std::unordered_map<GLuint, GLuint> uniformBlocks;
    GLDispatch& dispatcher = GLEScontext::dispatcher();
    dispatcher.glGetProgramiv(pname, GL_ACTIVE_UNIFORM_BLOCKS,
            &uniformBlockCount);
    for (int i = 0; i < uniformBlockCount; i++) {
        GLint binding = 0;
        dispatcher.glGetActiveUniformBlockiv(pname, i, GL_UNIFORM_BLOCK_BINDING,
                &binding);
        uniformBlocks.emplace(i, binding);
    }
    return uniformBlocks;
}

static std::vector<std::string> collectTransformFeedbackInfo(GLuint pname) {
    GLint transformFeedbackCount = 0;
    GLint transformFeedbakMaxLength = 0;
    GLDispatch& dispatcher = GLEScontext::dispatcher();
    dispatcher.glGetProgramiv(pname, GL_TRANSFORM_FEEDBACK_VARYINGS,
            &transformFeedbackCount);
    dispatcher.glGetProgramiv(pname, GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH,
            &transformFeedbakMaxLength);

    std::vector<std::string> transformFeedbacks(transformFeedbackCount);
    std::unique_ptr<char[]> nameBuffer(new char [transformFeedbakMaxLength]);

    for (int i = 0; i < transformFeedbackCount; i++) {
        GLsizei size;
        GLenum type;

        dispatcher.glGetTransformFeedbackVarying(pname, i,
                transformFeedbakMaxLength, nullptr, &size, &type,
                nameBuffer.get());
        transformFeedbacks[i] = nameBuffer.get();
    }
    return transformFeedbacks;
}

void ProgramData::onSave(android::base::Stream* stream, unsigned int globalName) const {
    // The first byte is used to distinguish between program and shader object.
    // It will be loaded outside of this class
    stream->putByte(LOAD_PROGRAM);
    ObjectData::onSave(stream, globalName);
    auto saveAttribLocs = [](android::base::Stream* stream,
            const std::pair<std::string, GLuint>& attribLoc) {
                stream->putString(attribLoc.first);
                stream->putBe32(attribLoc.second);
            };
    saveCollection(stream, boundAttribLocs, saveAttribLocs);
    saveCollection(stream, linkedAttribLocs, saveAttribLocs);

    auto saveUniform = [](android::base::Stream* stream,
                const std::pair<const GLuint, GLUniformDesc>& uniform) {
            stream->putBe32(uniform.first);
            uniform.second.onSave(stream);
        };
    auto saveUniformBlock = [](android::base::Stream* stream,
                const std::pair<const GLuint, GLuint>& uniformBlock) {
            stream->putBe32(uniformBlock.first);
            stream->putBe32(uniformBlock.second);
        };
    auto saveTransformFeedbacks = [](android::base::Stream* stream,
                const std::vector<std::string>& transformFeedbacks) {
            stream->putBe32((int)transformFeedbacks.size());
            for (const auto& feedback : transformFeedbacks) {
                stream->putString(feedback);
            }
        };
    if (needRestore()) {
        saveCollection(stream, uniforms, saveUniform);
        saveCollection(stream, mUniformBlockBinding, saveUniformBlock);
        saveTransformFeedbacks(stream, mTransformFeedbacks);
        stream->putBe32(mTransformFeedbackBufferMode);
    } else {
        std::unordered_map<GLuint, GLUniformDesc> uniformsOnSave =
                collectUniformInfo();
        std::unordered_map<GLuint, GLuint> uniformBlocks;
        std::vector<std::string> transformFeedbacks;
        if (mGlesMajorVersion >= 3) {
            uniformBlocks = collectUniformBlockInfo(ProgramName);
            transformFeedbacks = collectTransformFeedbackInfo(ProgramName);
            GLEScontext::dispatcher().glGetProgramiv(ProgramName,
                    GL_TRANSFORM_FEEDBACK_BUFFER_MODE,
                    (GLint*)&mTransformFeedbackBufferMode);
        }

        saveCollection(stream, uniformsOnSave, saveUniform);
        saveCollection(stream, uniformBlocks, saveUniformBlock);
        saveTransformFeedbacks(stream, transformFeedbacks);
        stream->putBe32(mTransformFeedbackBufferMode);
    }

    for (const auto& s : attachedShaders) {
        stream->putBe32(s.localName);
        stream->putString(s.linkedSource);
        // s.linkedInfo will be regenerated on restore
        // This is for compatibility over different rendering backends
    }
    stream->putString(validationInfoLog);
    stream->putString(infoLog);

    stream->putBe16(0 /* padding to maintain snapshot file compatibility */);
    stream->putByte(ValidateStatus);
    stream->putByte(LinkStatus);

    stream->putByte(IsInUse);
    stream->putByte(DeleteStatus);

    stream->putByte(mGlesMajorVersion);
    stream->putByte(mGlesMinorVersion);
    saveCollection(stream, mUniNameToGuestLoc, [](android::base::Stream* stream,
                const std::pair<std::string, int>& uniNameLoc) {
        stream->putString(uniNameLoc.first);
        stream->putBe32(uniNameLoc.second);
    });
}

void ProgramData::postLoad(const getObjDataPtr_t& getObjDataPtr) {
    for (auto& s : attachedShaders) {
        if (s.localName) {
            s.shader = (ShaderParser*)getObjDataPtr(
                    NamedObjectType::SHADER_OR_PROGRAM, s.localName).get();
        }
    }
}

void ProgramData::restore(ObjectLocalName localName,
           const getGlobalName_t& getGlobalName) {
    ObjectData::restore(localName, getGlobalName);
    int globalName = getGlobalName(NamedObjectType::SHADER_OR_PROGRAM,
            localName);
    assert(globalName);
    ProgramName = globalName;
    GLDispatch& dispatcher = GLEScontext::dispatcher();
    mGuestLocToHostLoc.add(-1, -1);
    bool shoudLoadLinked = LinkStatus;
#if defined(TOLERATE_PROGRAM_LINK_ERROR) && TOLERATE_PROGRAM_LINK_ERROR == 1
    shoudLoadLinked = 1;
#endif
    if (shoudLoadLinked) {
        // Really, each program name corresponds to 2 programs:
        // the one that is already linked, and the one that is not yet linked.
        // We need to restore both.
        GLint tmpShaders[NUM_SHADER_TYPE];
        for (int i = 0; i < NUM_SHADER_TYPE; i++) {
            AttachedShader& s = attachedShaders[i];
            if (s.linkedSource.empty()) {
                tmpShaders[i] = 0;
                continue;
            }
            GLenum type = 0;
            switch (i) {
            case VERTEX:
                type = GL_VERTEX_SHADER;
                break;
            case FRAGMENT:
                type = GL_FRAGMENT_SHADER;
                break;
            case COMPUTE:
                type = GL_COMPUTE_SHADER;
                break;
            default:
                assert(0);
            }
            tmpShaders[i] = dispatcher.glCreateShader(type);
            const GLchar* src = (const GLchar *)s.linkedSource.c_str();
            std::string parsedSrc;
            if (!isGles2Gles()) {
#ifdef USE_ANGLE_SHADER_PARSER
                std::string infoLog;
                ANGLEShaderParser::translate(
                            isCoreProfile(),
                            src,
                            type,
                            &infoLog,
                            &parsedSrc,
                            &s.linkInfo);
                src = parsedSrc.c_str();
#endif
            }
            dispatcher.glShaderSource(tmpShaders[i], 1, &src, NULL);
            dispatcher.glCompileShader(tmpShaders[i]);
            dispatcher.glAttachShader(globalName, tmpShaders[i]);
        }
        for (const auto& attribLocs : linkedAttribLocs) {
            // Prefix "gl_" is reserved, we should skip those.
            // https://www.khronos.org/registry/OpenGL-Refpages/es3.0/html/glBindAttribLocation.xhtml
            if  (strncmp(attribLocs.first.c_str(), "gl_", 3) == 0) {
                continue;
            }
            dispatcher.glBindAttribLocation(globalName, attribLocs.second,
                    attribLocs.first.c_str());
        }
        if (mGlesMajorVersion >= 3) {
            std::vector<const char*> varyings;
            varyings.resize(mTransformFeedbacks.size());
            for (size_t i = 0; i < mTransformFeedbacks.size(); i++) {
                varyings[i] = mTransformFeedbacks[i].c_str();
            }
            dispatcher.glTransformFeedbackVaryings(
                    globalName, mTransformFeedbacks.size(), varyings.data(),
                    mTransformFeedbackBufferMode);
            mTransformFeedbacks.clear();
        }
        dispatcher.glLinkProgram(globalName);
        dispatcher.glUseProgram(globalName);
#ifdef DEBUG
        for (const auto& attribLocs : linkedAttribLocs) {
            assert(dispatcher.glGetAttribLocation(globalName,
                attribLocs.first.c_str()) == attribLocs.second);
        }
#endif // DEBUG
        for (const auto& uniform : mUniNameToGuestLoc) {
            GLint hostLoc = dispatcher.glGetUniformLocation(
                    globalName, getTranslatedName(uniform.first).c_str());
            if (hostLoc != -1) {
                mGuestLocToHostLoc.add(uniform.second, hostLoc);
            }
        }
        for (const auto& uniformEntry : uniforms) {
            const auto& uniform = uniformEntry.second;
            GLint location = dispatcher.glGetUniformLocation(
                    globalName, getTranslatedName(uniform.mGuestName).c_str());
            if (location == -1) {
                // Location changed after loading from a snapshot.
                // likely loading from different GPU backend (and they
                // optimize out different stuff)
                continue;
            }

            switch (uniform.mType) {
                case GL_FLOAT:
                    dispatcher.glUniform1fv(location, uniform.mCount,
                            (const GLfloat*)uniform.mVal.data());
                    break;
                case GL_FLOAT_VEC2:
                    dispatcher.glUniform2fv(location, uniform.mCount,
                            (const GLfloat*)uniform.mVal.data());
                    break;
                case GL_FLOAT_VEC3:
                    dispatcher.glUniform3fv(location, uniform.mCount,
                            (const GLfloat*)uniform.mVal.data());
                    break;
                case GL_FLOAT_VEC4:
                    dispatcher.glUniform4fv(location, uniform.mCount,
                            (const GLfloat*)uniform.mVal.data());
                    break;
                case GL_BOOL:
                case GL_INT:
                case GL_SAMPLER_2D:
                case GL_SAMPLER_3D:
                case GL_SAMPLER_CUBE:
                case GL_SAMPLER_2D_SHADOW:
                case GL_SAMPLER_2D_ARRAY:
                case GL_SAMPLER_2D_ARRAY_SHADOW:
                case GL_SAMPLER_CUBE_SHADOW:
                case GL_INT_SAMPLER_2D:
                case GL_INT_SAMPLER_3D:
                case GL_INT_SAMPLER_CUBE:
                case GL_INT_SAMPLER_2D_ARRAY:
                case GL_UNSIGNED_INT_SAMPLER_2D:
                case GL_UNSIGNED_INT_SAMPLER_3D:
                case GL_UNSIGNED_INT_SAMPLER_CUBE:
                case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
                    dispatcher.glUniform1iv(location, uniform.mCount,
                            (const GLint*)uniform.mVal.data());
                    break;
                case GL_BOOL_VEC2:
                case GL_INT_VEC2:
                    dispatcher.glUniform2iv(location, uniform.mCount,
                            (const GLint*)uniform.mVal.data());
                    break;
                case GL_BOOL_VEC3:
                case GL_INT_VEC3:
                    dispatcher.glUniform3iv(location, uniform.mCount,
                            (const GLint*)uniform.mVal.data());
                    break;
                case GL_BOOL_VEC4:
                case GL_INT_VEC4:
                    dispatcher.glUniform4iv(location, uniform.mCount,
                            (const GLint*)uniform.mVal.data());
                    break;
                case GL_UNSIGNED_INT:
                    dispatcher.glUniform1uiv(location, uniform.mCount,
                            (const GLuint*)uniform.mVal.data());
                    break;
                case GL_UNSIGNED_INT_VEC2:
                    dispatcher.glUniform2uiv(location, uniform.mCount,
                            (const GLuint*)uniform.mVal.data());
                    break;
                case GL_UNSIGNED_INT_VEC3:
                    dispatcher.glUniform3uiv(location, uniform.mCount,
                            (const GLuint*)uniform.mVal.data());
                    break;
                case GL_UNSIGNED_INT_VEC4:
                    dispatcher.glUniform4uiv(location, uniform.mCount,
                            (const GLuint*)uniform.mVal.data());
                    break;
                case GL_FLOAT_MAT2:
                    dispatcher.glUniformMatrix2fv(location,
                            uniform.mCount, uniform.mTranspose,
                            (const GLfloat*)uniform.mVal.data());
                    break;
                case GL_FLOAT_MAT3:
                    dispatcher.glUniformMatrix3fv(location,
                            uniform.mCount, uniform.mTranspose,
                            (const GLfloat*)uniform.mVal.data());
                    break;
                case GL_FLOAT_MAT4:
                    dispatcher.glUniformMatrix4fv(location,
                            uniform.mCount, uniform.mTranspose,
                            (const GLfloat*)uniform.mVal.data());
                    break;
                case GL_FLOAT_MAT2x3:
                    dispatcher.glUniformMatrix2x3fv(location,
                            uniform.mCount, uniform.mTranspose,
                            (const GLfloat*)uniform.mVal.data());
                    break;
                case GL_FLOAT_MAT2x4:
                    dispatcher.glUniformMatrix2x4fv(location,
                            uniform.mCount, uniform.mTranspose,
                            (const GLfloat*)uniform.mVal.data());
                    break;
                case GL_FLOAT_MAT3x2:
                    dispatcher.glUniformMatrix3x2fv(location,
                            uniform.mCount, uniform.mTranspose,
                            (const GLfloat*)uniform.mVal.data());
                    break;
                case GL_FLOAT_MAT3x4:
                    dispatcher.glUniformMatrix3x4fv(location,
                            uniform.mCount, uniform.mTranspose,
                            (const GLfloat*)uniform.mVal.data());
                    break;
                case GL_FLOAT_MAT4x2:
                    dispatcher.glUniformMatrix4x2fv(location,
                            uniform.mCount, uniform.mTranspose,
                            (const GLfloat*)uniform.mVal.data());
                    break;
                case GL_FLOAT_MAT4x3:
                    dispatcher.glUniformMatrix4x3fv(location,
                            uniform.mCount, uniform.mTranspose,
                            (const GLfloat*)uniform.mVal.data());
                    break;
                default:
                    fprintf(stderr, "ProgramData::restore: warning: "
                            "unsupported uniform type 0x%x\n", uniform.mType);
            }
        }
        for (const auto& uniformBlock : mUniformBlockBinding) {
            dispatcher.glUniformBlockBinding(globalName, uniformBlock.first,
                    uniformBlock.second);
        }
        for (auto s : tmpShaders) {
            if (s != 0) {
                dispatcher.glDetachShader(globalName, s);
                dispatcher.glDeleteShader(s);
            }
        }
    }
    uniforms.clear();
    mUniformBlockBinding.clear();
    // We are done with the "linked" program, now we handle the one
    // that is yet to compile
    for (const auto& s : attachedShaders) {
        if (s.localName) {
            int shaderGlobalName = getGlobalName(
                    NamedObjectType::SHADER_OR_PROGRAM, s.localName);
            assert(shaderGlobalName);
            dispatcher.glAttachShader(globalName, shaderGlobalName);
        }
    }
    for (const auto& attribLocs : boundAttribLocs) {
        dispatcher.glBindAttribLocation(globalName, attribLocs.second,
                attribLocs.first.c_str());
    }
}

GenNameInfo ProgramData::getGenNameInfo() const {
    return GenNameInfo(ShaderProgramType::PROGRAM);
}

void ProgramData::setErrInfoLog() {
    infoLog.clear();
    infoLog = std::string(validationInfoLog);
}

void ProgramData::setInfoLog(const GLchar* log) {
    infoLog = std::string(log);
}

const GLchar* ProgramData::getInfoLog() const {
    return infoLog.c_str();
}

GLuint ProgramData::getAttachedVertexShader() const {
    return attachedShaders[VERTEX].localName;
}

GLuint ProgramData::getAttachedFragmentShader() const {
    return attachedShaders[FRAGMENT].localName;
}

GLuint ProgramData::getAttachedComputeShader() const {
    return attachedShaders[COMPUTE].localName;
}

GLuint ProgramData::getAttachedShader(GLenum type) const {
    return attachedShaders[s_glShaderType2ShaderType(type)].localName;
}

std::string
ProgramData::getTranslatedName(const std::string& userVarName) const {
    if (isGles2Gles()) {
        return userVarName;
    }
    // TODO: translate uniform array names
#ifdef USE_ANGLE_SHADER_PARSER
    for (int i = 0; i < NUM_SHADER_TYPE; i++) {
        if (const auto name = android::base::find(
                attachedShaders[i].linkInfo.nameMap, userVarName)) {
            return *name;
        }
    }
#endif
    return userVarName;
}

std::string
ProgramData::getDetranslatedName(const std::string& driverName) const {
    if (isGles2Gles()) {
        return driverName;
    }

#ifdef USE_ANGLE_SHADER_PARSER
    // TODO: detranslate uniform array names
    for (int i = 0; i < NUM_SHADER_TYPE; i++) {
        if (const auto name = android::base::find(
                attachedShaders[i].linkInfo.nameMapReverse, driverName)) {
            return *name;
        }
    }
#endif
    return driverName;
}

bool ProgramData::attachShader(GLuint shader, ShaderParser* shaderData,
        GLenum type) {
    AttachedShader& s = attachedShaders[s_glShaderType2ShaderType(type)];
    if (s.localName == 0) {
        s.localName = shader;
        s.shader = shaderData;
        return true;
    }
    return false;
}

bool ProgramData::isAttached(GLuint shader) const {
    for (const auto& s : attachedShaders) {
        if (s.localName == shader) return true;
    }
    return false;
}

bool ProgramData::detachShader(GLuint shader) {
    for (auto& s : attachedShaders) {
        if (s.localName == shader) {
            s.localName = 0;
            s.shader = nullptr;
            return true;
        }
    }
    return false;
}

void ProgramData::bindAttribLocation(const std::string& var, GLuint loc) {
    boundAttribLocs[var] = loc;
}

void ProgramData::linkedAttribLocation(const std::string& var, GLuint loc) {
    linkedAttribLocs[var] = loc;
}

// Link-time validation
void ProgramData::appendValidationErrMsg(std::ostringstream& ss) {
    validationInfoLog += "Error: " + ss.str() + "\n";
}

#ifdef USE_ANGLE_SHADER_PARSER
static bool sCheckUndecl(ProgramData* pData,
                         const ANGLEShaderParser::ShaderLinkInfo& fragLinkInfo,
                         const ANGLEShaderParser::ShaderLinkInfo& vertLinkInfo);
static bool sCheckLimits(ProgramData* pData,
                         const ST_BuiltInResources& resources,
                         const ANGLEShaderParser::ShaderLinkInfo& fragLinkInfo,
                         const ANGLEShaderParser::ShaderLinkInfo& vertLinkInfo);
static bool sCheckVariables(ProgramData* pData,
                            const ANGLEShaderParser::ShaderLinkInfo& a,
                            const ANGLEShaderParser::ShaderLinkInfo& b);
static void sInitializeUniformLocs(ProgramData* pData,
                                   const std::vector<ST_ShaderVariable>& uniforms);
#endif

bool ProgramData::validateLink(ShaderParser* frag, ShaderParser* vert) {
    bool res = true;

#ifdef USE_ANGLE_SHADER_PARSER
    const ANGLEShaderParser::ShaderLinkInfo& fragLinkInfo =
        frag->getShaderLinkInfo();
    const ANGLEShaderParser::ShaderLinkInfo& vertLinkInfo =
        vert->getShaderLinkInfo();


    res = res && sCheckUndecl(this, fragLinkInfo, vertLinkInfo);
    res = res && sCheckLimits(this, ANGLEShaderParser::kResources,
                              fragLinkInfo, vertLinkInfo);
    res = res && sCheckVariables(this, fragLinkInfo, vertLinkInfo);
#endif

    return res;
}

void ProgramData::setHostLinkStatus(GLint status) {
    HostLinkStatus = (status == GL_FALSE) ? false : true;
}

void ProgramData::setLinkStatus(GLint status) {
    LinkStatus = (status == GL_FALSE) ? false : true;
    mUniNameToGuestLoc.clear();
    mGuestLocToHostLoc.clear();
    mGuestLocToHostLoc.add(-1, -1);
#if defined(TOLERATE_PROGRAM_LINK_ERROR) && TOLERATE_PROGRAM_LINK_ERROR == 1
    status = 1;
#endif
    if (status && HostLinkStatus) {
        bool is310 = false;

#ifdef USE_ANGLE_SHADER_PARSER
	std::vector<ST_ShaderVariable> allUniforms;
#endif
        for (auto& s : attachedShaders) {
            if (s.localName) {
                assert(s.shader);
                s.linkedSource = s.shader->getOriginalSrc();
#ifdef USE_ANGLE_SHADER_PARSER
                s.linkInfo = s.shader->getShaderLinkInfo();
                is310 = is310 || (s.linkInfo.esslVersion == 310);
                for (const auto& var: s.linkInfo.uniforms) {
                    allUniforms.push_back(var);
                }
#endif
            }
        }

        if (is310 || isGles2Gles()) {
            mUseDirectDriverUniformInfo = true;
        } else {
#ifdef USE_ANGLE_SHADER_PARSER
            sInitializeUniformLocs(this, allUniforms);
#endif
        }
        for (const auto &attribLoc : boundAttribLocs) {
            // overwrite
            linkedAttribLocs[attribLoc.first] = attribLoc.second;
        }
    } else {
        for (auto& s : attachedShaders) {
            s.linkedSource.clear();
        }
    }
}

bool ProgramData::getLinkStatus() const {
    return LinkStatus;
}

static const char kDifferentPrecisionErr[] =
    "specified with different precision in different shaders.";
static const char kDifferentTypeErr[] =
    "specified with different type in different shaders.";
static const char kDifferentLayoutQualifierErr[] =
    "specified with different layout qualifiers in different shaders.";
static const char kExceededMaxVertexAttribs[] =
    "exceeded max vertex attribs.";
static const char kUsedUndeclaredErr[] =
    "used, but not declared.";
static const char kUniformQualifier[] = "uniform";
static const char kVaryingQualifier[] = "varying";
static const char kUnknownQualifier[] = "[unknown qualifier]";
enum ValidationQualifier {
    UNIFORM,
    VARYING,
};

static const char* sQualifierString(ValidationQualifier q) {
    switch (q) {
    case ValidationQualifier::UNIFORM:
        return kUniformQualifier;
    case ValidationQualifier::VARYING:
        return kVaryingQualifier;
    }
    return kUnknownQualifier;
}

#ifdef USE_ANGLE_SHADER_PARSER

static bool sVarCheck(ProgramData* pData,
                      ValidationQualifier qualifier,
                      const ST_ShaderVariable& a,
                      const ST_ShaderVariable& b) {
    bool res = true;

    if (qualifier == ValidationQualifier::UNIFORM &&
        a.precision != b.precision) {
        std::ostringstream err;
        err << sQualifierString(qualifier) << " " << a.name << " ";
        err << kDifferentPrecisionErr;
        pData->appendValidationErrMsg(err);
        res = false;
    }

    bool aIsStruct = a.fieldsCount > 0;
    bool bIsStruct = b.fieldsCount > 0;

    if (aIsStruct != bIsStruct ||
        a.type != b.type) {
        std::ostringstream err;
        err << sQualifierString(qualifier) << " " << a.name << " ";
        err << kDifferentTypeErr;
        pData->appendValidationErrMsg(err);
        res = false;
    }

    if (aIsStruct) {
        for (unsigned int i = 0; i < a.fieldsCount; ++i) {
            for (unsigned int j = 0; j < b.fieldsCount; ++j) {
                if (strcmp(a.pFields[i].name, b.pFields[j].name)) continue;
                res = res && sVarCheck(pData, qualifier, a.pFields[i], b.pFields[j]);
            }
        }
    }

    return res;
}

static bool sInterfaceBlockCheck(ProgramData* pData,
                                 const ST_InterfaceBlock& a,
                                 const ST_InterfaceBlock& b) {
    bool res = true;

    if (a.layout != b.layout ||
        a.isRowMajorLayout != b.isRowMajorLayout) {
        std::ostringstream err;
        err << "interface block " << a.name << " ";
        err << kDifferentLayoutQualifierErr;
        pData->appendValidationErrMsg(err);
        res = false;
    }

    if (a.fieldsCount != b.fieldsCount) {
        std::ostringstream err;
        err << "interface block " << a.name << " ";
        err << kDifferentTypeErr;
        pData->appendValidationErrMsg(err);
        res = false;
    }

    for (unsigned int i = 0; i < a.fieldsCount; ++i) {
        for (unsigned int j = 0; j < b.fieldsCount; ++j) {
            const auto afield = a.pFields[i];
            const auto bfield = b.pFields[j];

            if (strcmp(afield.name, bfield.name)) continue;
            res = res && sVarCheck(pData, ValidationQualifier::VARYING,
                    afield, bfield);
            if (afield.isRowMajorLayout != bfield.isRowMajorLayout) {
                std::ostringstream err;
                err << "interface block field ";
                err << a.name << "." << afield.name << " ";
                err << kDifferentLayoutQualifierErr;
                pData->appendValidationErrMsg(err);
                res = false;
            }
        }
    }

    return res;
}

static bool sIsBuiltInShaderVariable(const ST_ShaderVariable& var) {
    if (!var.name || strlen(var.name) < 4) return false;

    const char* name = var.name;
    return (name[0] == 'g' && name[1] == 'l' && name[2] == '_');
}

static bool sCheckUndecl(
        ProgramData* pData,
        const ANGLEShaderParser::ShaderLinkInfo& fragLinkInfo,
        const ANGLEShaderParser::ShaderLinkInfo& vertLinkInfo) {
    bool res = true;
    for (const auto& felt : fragLinkInfo.varyings) {
        if (sIsBuiltInShaderVariable(felt)) continue;

        bool declaredInVertShader = false;
        for (const auto& velt : vertLinkInfo.varyings) {
            if (!strcmp(velt.name, felt.name)) {
                declaredInVertShader = true;
                break;
            }
        }

        if (!declaredInVertShader && felt.staticUse) {
            std::ostringstream err;
            err << "varying " << felt.name << " ";
            err << kUsedUndeclaredErr;
            pData->appendValidationErrMsg(err);
            res = false;
        }
    }
    return res;
}

static bool sCheckLimits(
        ProgramData* pData,
        const ST_BuiltInResources& resources,
        const ANGLEShaderParser::ShaderLinkInfo& fragShaderLinkInfo,
        const ANGLEShaderParser::ShaderLinkInfo& vertShaderLinkInfo) {

    bool res = true;

    size_t maxAttribs = (size_t)resources.MaxVertexAttribs;

    std::unordered_set<GLuint> explicitlyBound;
    int numImplicitlyBound = 0;
    for (const auto& elt : vertShaderLinkInfo.attributes) {
        if (const auto loc = android::base::find(pData->boundAttribLocs, elt.name)) {
            explicitlyBound.insert(*loc);
        } else {
            numImplicitlyBound++;
        }
    }
    int numExplicitlyBound = explicitlyBound.size();

    if ((int)maxAttribs - numExplicitlyBound - numImplicitlyBound < 0) {
        std::ostringstream err;
        err << kExceededMaxVertexAttribs;
        err << " Wanted (from vertex shader): ";
        err << numExplicitlyBound + numImplicitlyBound << " ";
        err << " Limit: " << maxAttribs << " ";
        pData->appendValidationErrMsg(err);
        res = false;
    }

    return res;
}

static bool sCheckVariables(ProgramData* pData,
                            const ANGLEShaderParser::ShaderLinkInfo& a,
                            const ANGLEShaderParser::ShaderLinkInfo& b) {
    bool res = true;

    for (const auto& aelt : a.uniforms) {
        for (const auto& belt : b.uniforms) {
            if (strcmp(aelt.name, belt.name)) continue;
            res = res && sVarCheck(pData, ValidationQualifier::UNIFORM, aelt, belt);
        }
    }

    for (const auto& aelt : a.varyings) {
        for (const auto& belt : b.varyings) {
            if (strcmp(aelt.name, belt.name)) continue;
            res = res && sVarCheck(pData, ValidationQualifier::VARYING, aelt, belt);
        }
    }

    for (const auto& aelt : a.interfaceBlocks) {
        for (const auto& belt : b.interfaceBlocks) {
            if (strcmp(aelt.name, belt.name)) continue;
            res = res && sInterfaceBlockCheck(pData, aelt, belt);
        }
    }

    return res;
}

static void sRecursiveLocInitalize(ProgramData* pData, const std::string& keyBase, const ST_ShaderVariable& var) {
    // fprintf(stderr, "%s: call. name: %s\n", __func__, var.name);
    bool isArr = var.arraySizeCount > 0;
    int baseSize = isArr ? var.pArraySizes[0] : 1;
    bool isStruct = var.fieldsCount > 0;

    if (isStruct) {
        // fprintf(stderr, "%s: is struct\n", __func__);
        if (isArr) {
            // fprintf(stderr, "%s: is arr\n", __func__);
            for (int k = 0; k < var.pArraySizes[0]; k++) {
                for (uint32_t i = 0; i < var.fieldsCount; ++i) {
                    std::vector<char> keyBuf(keyBase.length() + strlen(var.pFields[i].name) + 20, 0);
                    snprintf(keyBuf.data(), keyBuf.size(), "%s[%d].%s", keyBase.c_str(), k, var.pFields[i].name);
                    sRecursiveLocInitalize(pData, std::string(keyBuf.data()), var.pFields[i]);
                }
            }
        } else {
            // fprintf(stderr, "%s: is plain struct\n", __func__);
            for (uint32_t i = 0; i < var.fieldsCount; ++i) {
                std::vector<char> keyBuf(keyBase.length() + strlen(var.pFields[i].name) + 20, 0);
                snprintf(keyBuf.data(), keyBuf.size(), "%s.%s", keyBase.c_str(), var.pFields[i].name);
                // fprintf(stderr, "%s: keyBuf: %s\n", __func__, keyBuf.data());
                sRecursiveLocInitalize(pData, std::string(keyBuf.data()), var.pFields[i]);
            }
        }
    } else {
        // fprintf(stderr, "%s: is not struct\n", __func__);
        for (int k = 0; k < baseSize; k++) {
            if (k == 0) {
                std::vector<char> keyBuf(keyBase.length() + 20, 0);
                std::vector<char> keyBuf2(keyBase.length() + 20, 0);
                snprintf(keyBuf.data(), keyBuf.size(), "%s", keyBase.c_str());
                snprintf(keyBuf2.data(), keyBuf.size(), "%s[%d]", keyBase.c_str(), k);
                // fprintf(stderr, "%s: initGuestUniformLocForKey. keyBuf2 %s\n", __func__, keyBuf2.data());
                pData->initGuestUniformLocForKey(keyBuf.data(), keyBuf2.data());
            } else {
                std::vector<char> keyBuf(keyBase.length() + 20, 0);
                snprintf(keyBuf.data(), keyBuf.size(), "%s[%d]", keyBase.c_str(), k);
                // fprintf(stderr, "%s: initGuestUniformLocForKey. keyBu2 %s\n", __func__, keyBuf.data());
                pData->initGuestUniformLocForKey(keyBuf.data());
            }
        }
    }
}

static void sInitializeUniformLocs(ProgramData* pData,
                                   const std::vector<ST_ShaderVariable>& uniforms) {
    // fprintf(stderr, "%s: call\n", __func__);
    // initialize in order of indices
    std::vector<std::string> orderedUniforms;
    GLint uniform_count;
    GLint nameLength;

    GLDispatch& gl = GLEScontext::dispatcher();
    gl.glGetProgramiv(pData->getProgramName(), GL_ACTIVE_UNIFORM_MAX_LENGTH, &nameLength);
    gl.glGetProgramiv(pData->getProgramName(), GL_ACTIVE_UNIFORMS, &uniform_count);

    std::vector<char> name(nameLength, 0);

    for (int i = 0; i < uniform_count; i++) {
        GLint size;
        GLenum type;
        GLsizei length;
        gl.glGetActiveUniform(pData->getProgramName(), i, nameLength, &length,
                &size, &type, name.data());
        // fprintf(stderr, "%s: host uniform: %s\n", __func__, name.data());
        orderedUniforms.push_back(pData->getDetranslatedName(name.data()));
        // fprintf(stderr, "%s: host uniform detranslated: %s\n", __func__, pData->getDetranslatedName(name.data()).str().c_str());
    }

    std::unordered_map<std::string, size_t> linkInfoUniformsByName;

    size_t i = 0;
    for (const auto& var : uniforms) {
        linkInfoUniformsByName[var.name] = i;
        i++;
    }

    for (const auto& str : orderedUniforms) {
        // fprintf(stderr, "%s: do ordered uniforms\n", __func__);
        if (linkInfoUniformsByName.find(str) != linkInfoUniformsByName.end()) {
            sRecursiveLocInitalize(pData, str, uniforms[linkInfoUniformsByName[str]]);
        } else {
            // fprintf(stderr, "%s: found in link info uniforms\n", __func__);
        }
    }

    for (const auto& var : uniforms) {
        sRecursiveLocInitalize(pData, var.name, var);
    }
}

#endif

void ProgramData::initGuestUniformLocForKey(const std::string& key) {
    // fprintf(stderr, "%s: for %s\n", __func__, key.str().c_str());
    if (mUniNameToGuestLoc.find(key) == mUniNameToGuestLoc.end()) {
        mUniNameToGuestLoc[key] = mCurrUniformBaseLoc;
        // Emplace host location beforehand to workaround Unreal bug
        // BUG: 120548998
        GLDispatch& dispatcher = GLEScontext::dispatcher();
        std::string translatedName = getTranslatedName(key);
        // fprintf(stderr, "%s: trname: %s\n", __func__, translatedName.c_str());
        int hostLoc = dispatcher.glGetUniformLocation(ProgramName,
                translatedName.c_str());
        if (hostLoc != -1) {
            mGuestLocToHostLoc.add(mCurrUniformBaseLoc, hostLoc);
        }

        mCurrUniformBaseLoc++;
    }
}

void ProgramData::initGuestUniformLocForKey(const std::string& key, const std::string& key2) {
    bool newUniform = false;
    if (mUniNameToGuestLoc.find(key) == mUniNameToGuestLoc.end()) {
        mUniNameToGuestLoc[key] = mCurrUniformBaseLoc;
        newUniform = true;
    }
    if (mUniNameToGuestLoc.find(key2) == mUniNameToGuestLoc.end()) {
        mUniNameToGuestLoc[key2] = mCurrUniformBaseLoc;
        newUniform = true;
    }

    if (newUniform) {
        // Emplace host location beforehand to workaround Unreal bug
        // BUG: 120548998
        GLDispatch& dispatcher = GLEScontext::dispatcher();
        std::string translatedName = getTranslatedName(key);
        int hostLoc = dispatcher.glGetUniformLocation(ProgramName,
                translatedName.c_str());
        if (hostLoc != -1) {
            mGuestLocToHostLoc.add(mCurrUniformBaseLoc, hostLoc);
        }

        mCurrUniformBaseLoc++;
    }
}

int ProgramData::getGuestUniformLocation(const char* uniName) {
    GLDispatch& dispatcher = GLEScontext::dispatcher();
    if (mUseUniformLocationVirtualization) {
        if (mUseDirectDriverUniformInfo) {
            int guestLoc;
            const auto& activeLoc = mUniNameToGuestLoc.find(uniName);
            // If using direct driver uniform info, don't overwrite any
            // previously known guest location.
            if (activeLoc != mUniNameToGuestLoc.end()) {
                guestLoc = activeLoc->second;
            } else {
                guestLoc =
                    dispatcher.glGetUniformLocation(ProgramName, uniName);
                if (guestLoc == -1) {
                    return -1;
                } else {
                    mUniNameToGuestLoc[uniName] = guestLoc;
                    mGuestLocToHostLoc.add(guestLoc, guestLoc);
                }
            }
            return guestLoc;
        } else {
            int guestLoc;

            const auto& activeLoc = mUniNameToGuestLoc.find(uniName);

            if (activeLoc != mUniNameToGuestLoc.end()) {
                guestLoc = activeLoc->second;
            } else {
                guestLoc = -1;
            }

            std::string translatedName = getTranslatedName(uniName);
            int hostLoc = dispatcher.glGetUniformLocation(ProgramName,
                    translatedName.c_str());
            if (hostLoc == -1) {
                return -1;
            }

            mGuestLocToHostLoc.add(guestLoc, hostLoc);
            return guestLoc;
        }
    } else {
        return dispatcher.glGetUniformLocation(
                ProgramName, getTranslatedName(uniName).c_str());
    }
}

int ProgramData::getHostUniformLocation(int guestLocation) {
    if (mUseUniformLocationVirtualization) {
        if (guestLocation == -1) return -1;

        auto locPtr = mGuestLocToHostLoc.get_const(guestLocation);
        if (!locPtr) return -2;
        return *locPtr;
    } else {
        return guestLocation;
    }
}