/*
 * Copyright (C) 2023 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 <vector>
#include <math.h>

#define GL_GLEXT_PROTOTYPES
#define EGL_EGLEXT_PROTOTYPES
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#undef EGL_EGLEXT_PROTOTYPES
#undef GL_GLEXT_PROTOTYPES

#include "abc3d.h"
#include "debug.h"

namespace android {
namespace hardware {
namespace camera {
namespace provider {
namespace implementation {
namespace abc3d {
namespace {
constexpr char kTag[] = "abc3d";

float dot3(const float a3[], const float b3[]) {
    return a3[0] * b3[0] + a3[1] * b3[1] + a3[2] * b3[2];
}

/*
 * https://registry.khronos.org/OpenGL-Refpages/gl2.1/xhtml/gluLookAt.xml
 * https://registry.khronos.org/OpenGL-Refpages/gl2.1/xhtml/glTranslate.xml
 * This function takes `m44` (where zzz (assumed zero) and ooo (assumed one)
 * are ignored) and multiplies it by a translation matrix.
 *
 *           m44             translate
 *  [  s0  s1  s2 zzz ]   [ 1 0 0 -eyeX ]   [  s0  s1  s2 -dot3(m44[0:2],  eye3) ]
 *  [ up0 up1 up2 zzz ] * [ 0 1 0 -eyeY ] = [ up0 up1 up2 -dot3(m44[4:6],  eye3) ]
 *  [  b0  b1  b2 zzz ]   [ 0 0 1 -eyeZ ]   [  b0  b1  b2 -dot3(m44[8:10], eye3) ]
 *  [ zzz zzz zzz ooo ]   [ 0 0 0     1 ]   [   0   0   0                      1 ]
*/
void lookAtEyeCoordinates(float m44[], const float eye3[]) {
    m44[3]  = -dot3(&m44[0], eye3);
    m44[7]  = -dot3(&m44[4], eye3);
    m44[11] = -dot3(&m44[8], eye3);
    m44[12] = 0;
    m44[13] = 0;
    m44[14] = 0;
    m44[15] = 1;
}
}  // namespace

#define RETURN_CTOR_FAILED(S) \
    ALOGE("%s:%s:%d %s failed", kTag, __func__, __LINE__, S); return;

AutoImageKHR::AutoImageKHR(const EGLDisplay display, const EGLClientBuffer clientBuf)
        : mEglDisplay(display) {
    static const EGLint imageAttrs[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE};
    mEglImage = eglCreateImageKHR(
        display, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID, clientBuf, imageAttrs);
    if (mEglImage == EGL_NO_IMAGE_KHR) {
        RETURN_CTOR_FAILED("eglCreateImageKHR");
    }
}

AutoImageKHR::AutoImageKHR(AutoImageKHR&& rhs) noexcept
        : mEglDisplay(rhs.mEglDisplay)
        , mEglImage(std::exchange(rhs.mEglImage, EGL_NO_IMAGE_KHR)) {}

AutoImageKHR& AutoImageKHR::operator=(AutoImageKHR&& rhs) noexcept {
    if (this != &rhs) {
        mEglDisplay = rhs.mEglDisplay;
        mEglImage = std::exchange(rhs.mEglImage, EGL_NO_IMAGE_KHR);
    }
    return *this;
}

AutoImageKHR::~AutoImageKHR() {
    if (mEglImage != EGL_NO_IMAGE_KHR) {
        eglDestroyImageKHR(mEglDisplay, mEglImage);
    }
}

EglCurrentContext::EglCurrentContext(const EGLDisplay display)
        : mEglDisplay(display) {}

EglCurrentContext::EglCurrentContext(EglCurrentContext&& rhs) noexcept
        : mEglDisplay(std::exchange(rhs.mEglDisplay, EGL_NO_DISPLAY)) {}

EglCurrentContext& EglCurrentContext::operator=(EglCurrentContext&& rhs) noexcept {
    if (this != &rhs) {
        mEglDisplay = std::exchange(rhs.mEglDisplay, EGL_NO_DISPLAY);
    }
    return *this;
}

EglCurrentContext::~EglCurrentContext() {
    if (mEglDisplay != EGL_NO_DISPLAY) {
        LOG_ALWAYS_FATAL_IF(!eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE,
                                            EGL_NO_SURFACE, EGL_NO_CONTEXT));
    }
}

EglContext::EglContext(EglContext&& rhs) noexcept
        : mEglDisplay(std::exchange(rhs.mEglDisplay, EGL_NO_DISPLAY))
        , mEglContext(std::exchange(rhs.mEglContext, EGL_NO_CONTEXT))
        , mEglSurface(std::exchange(rhs.mEglSurface, EGL_NO_SURFACE)) {}

EglContext& EglContext::operator=(EglContext&& rhs) noexcept {
    if (this != &rhs) {
        mEglDisplay = std::exchange(rhs.mEglDisplay, EGL_NO_DISPLAY);
        mEglContext = std::exchange(rhs.mEglContext, EGL_NO_CONTEXT);
        mEglSurface = std::exchange(rhs.mEglSurface, EGL_NO_SURFACE);
    }
    return *this;
}

EglContext::~EglContext() {
    clear();
}

void EglContext::clear() {
    if (mEglSurface != EGL_NO_SURFACE) {
        eglDestroySurface(mEglDisplay, mEglSurface);
        mEglSurface = EGL_NO_SURFACE;
    }
    if (mEglContext != EGL_NO_CONTEXT) {
        eglDestroyContext(mEglDisplay, mEglContext);
        mEglContext = EGL_NO_CONTEXT;
    }
    if (mEglDisplay != EGL_NO_DISPLAY) {
        eglTerminate(mEglDisplay);
        mEglDisplay = EGL_NO_DISPLAY;
    }
}

EglCurrentContext EglContext::init() {
    if (mEglContext != EGL_NO_CONTEXT) {
        LOG_ALWAYS_FATAL_IF(!eglMakeCurrent(mEglDisplay, mEglSurface,
                                            mEglSurface, mEglContext));
        return EglCurrentContext(mEglDisplay);
    }

    const EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
    if (display == EGL_NO_DISPLAY) {
        return EglCurrentContext(FAILURE(EGL_NO_DISPLAY));
    }

    EGLint major, minor;
    if (!eglInitialize(display, &major, &minor)) {
        return EglCurrentContext(FAILURE(EGL_NO_DISPLAY));
    }
    ALOGD("%s:%d: Initialized EGL, version %d.%d", __func__, __LINE__,
          static_cast<int>(major), static_cast<int>(minor));

    static const EGLint configAttrs[] = {
        EGL_RENDERABLE_TYPE,    EGL_OPENGL_ES2_BIT,
        EGL_CONFIG_CAVEAT,      EGL_NONE,
        EGL_RED_SIZE,           8,
        EGL_GREEN_SIZE,         8,
        EGL_BLUE_SIZE,          8,
        EGL_ALPHA_SIZE,         8,
        EGL_NONE
    };

    EGLint numConfigs = 1;
    EGLConfig config = EGL_NO_CONFIG_KHR;
    if (!eglChooseConfig(display, configAttrs, &config, 1, &numConfigs) ||
            (config == EGL_NO_CONFIG_KHR) || (numConfigs != 1)) {
        eglTerminate(display);
        return EglCurrentContext(FAILURE(EGL_NO_DISPLAY));
    }

    static const EGLint contextAttrs[] = {
        EGL_CONTEXT_CLIENT_VERSION, 2,
        EGL_NONE
    };
    const EGLContext context = eglCreateContext(display, config,
                                                EGL_NO_CONTEXT, contextAttrs);
    if (context == EGL_NO_CONTEXT) {
        eglTerminate(display);
        return EglCurrentContext(FAILURE(EGL_NO_DISPLAY));
    }

    EGLSurface surface = EGL_NO_SURFACE;
    if (!eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, context)) {
        // EGL_KHR_surfaceless_context is not supported
        const EGLint surfaceAttrs[] = {
            EGL_WIDTH,  1,
            EGL_HEIGHT, 1,
            EGL_NONE
        };
        surface = eglCreatePbufferSurface(display, config, surfaceAttrs);
        if (surface == EGL_NO_SURFACE) {
            eglDestroyContext(display, context);
            eglTerminate(display);
            return EglCurrentContext(FAILURE(EGL_NO_DISPLAY));
        }

        if (!eglMakeCurrent(display, surface, surface, context)) {
            eglDestroySurface(display, surface);
            eglDestroyContext(display, context);
            eglTerminate(display);
            return EglCurrentContext(FAILURE(EGL_NO_DISPLAY));
        }
    }

    mEglDisplay = display;
    mEglContext = context;
    mEglSurface = surface;

    return EglCurrentContext(display);
}

EglCurrentContext EglContext::getCurrentContext() {
    if (mEglContext == EGL_NO_CONTEXT) {
        return EglCurrentContext(EGL_NO_DISPLAY);
    } else if (eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
        return EglCurrentContext(mEglDisplay);
    } else {
        return EglCurrentContext(FAILURE(EGL_NO_DISPLAY));
    }
}

AutoTexture::AutoTexture(const GLenum target) {
    glGenTextures(1, &mTex);
    if (mTex) {
        glBindTexture(target, mTex);
    } else {
        RETURN_CTOR_FAILED("glGenTextures");
    }
}

AutoTexture::AutoTexture(const GLenum target,
                         const GLint internalformat,
                         const GLsizei width,
                         const GLsizei height,
                         const GLenum format,
                         const GLenum type,
                         const void* data) {
    glGenTextures(1, &mTex);
    if (mTex) {
        glBindTexture(target, mTex);
        glTexImage2D(target, 0, internalformat, width, height, 0, format, type, data);
    } else {
        RETURN_CTOR_FAILED("glGenTextures");
    }
}

AutoTexture::AutoTexture(AutoTexture&& rhs) noexcept
        : mTex(std::exchange(rhs.mTex, 0)) {}

AutoTexture& AutoTexture::operator=(AutoTexture&& rhs) noexcept {
    if (this != &rhs) {
        mTex = std::exchange(rhs.mTex, 0);
    }
    return *this;
}

AutoTexture::~AutoTexture() {
    clear();
}

void AutoTexture::clear() {
    if (mTex) {
        glDeleteTextures(1, &mTex);
        mTex = 0;
    }
}

AutoFrameBuffer::AutoFrameBuffer() {
    glGenFramebuffers(1, &mFBO);
    if (mFBO) {
        glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
    } else {
        RETURN_CTOR_FAILED("glGenFramebuffers");
    }
}

AutoFrameBuffer::~AutoFrameBuffer() {
    if (mFBO) {
        glDeleteFramebuffers(1, &mFBO);
    }
}

AutoShader::AutoShader(AutoShader&& rhs) noexcept
        : mShader(std::exchange(rhs.mShader, 0)) {}

AutoShader& AutoShader::operator=(AutoShader&& rhs) noexcept {
    if (this != &rhs) {
        mShader = std::exchange(rhs.mShader, 0);
    }
    return *this;
}

AutoShader::~AutoShader() {
    if (mShader) {
        glDeleteShader(mShader);
    }
}

GLuint AutoShader::compile(const GLenum type, const char* text) {
    const GLuint shader = glCreateShader(type);
    if (!shader) {
        return FAILURE(0);
    }

    glShaderSource(shader, 1, &text, nullptr);
    glCompileShader(shader);
    GLint compiled = 0;
    glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
    if (!compiled) {
        GLint infoLen = 0;
        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
        if(infoLen > 1) {
            std::vector<char> msg(infoLen + 1);
            glGetShaderInfoLog(shader, infoLen, nullptr, msg.data());
            msg[infoLen] = 0;
            ALOGE("%s:%d: error compiling shader '%s' (type=%d): '%s'",
                  __func__, __LINE__, text, type, msg.data());
        }
        glDeleteShader(shader);
        return FAILURE(0);
    }

    if (mShader) {
        glDeleteShader(mShader);
    }

    mShader = shader;
    return shader;
}

AutoProgram::AutoProgram(AutoProgram&& rhs) noexcept
        : mProgram(std::exchange(rhs.mProgram, 0)) {}

AutoProgram& AutoProgram::operator=(AutoProgram&& rhs) noexcept {
    if (this != &rhs) {
        mProgram = std::exchange(rhs.mProgram, 0);
    }
    return *this;
}

AutoProgram::~AutoProgram() {
    clear();
}

void AutoProgram::clear() {
    if (mProgram) {
        glDeleteProgram(mProgram);
        mProgram = 0;
    }
}

bool AutoProgram::link(const GLuint vertexShader,
                       const GLuint fragmentShader) {
    const GLuint program = glCreateProgram();
    if (!program) {
        return FAILURE(false);
    }

    glAttachShader(program, vertexShader);
    glAttachShader(program, fragmentShader);
    glLinkProgram(program);

    GLint linked = 0;
    glGetProgramiv(program, GL_LINK_STATUS, &linked);
    if (!linked) {
        GLint infoLen = 0;
        glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLen);
        if(infoLen > 1) {
            std::vector<char> msg(infoLen + 1);
            glGetProgramInfoLog(program, infoLen, nullptr, msg.data());
            msg[infoLen] = 0;
            ALOGE("%s:%d: error linking shaders: '%s'",
                  __func__, __LINE__, msg.data());
        }

        glDeleteProgram(program);
        return FAILURE(false);
    }

    if (mProgram) {
        glDeleteProgram(mProgram);
    }

    mProgram = program;
    return true;
}

GLint AutoProgram::getAttribLocation(const char* name) const {
    if (mProgram > 0) {
        const GLint result = glGetAttribLocation(mProgram, name);
        return (result >= 0) ? result : FAILURE(-1);
    } else {
        return FAILURE(-1);
    }
}

GLint AutoProgram::getUniformLocation(const char* name) const {
    if (mProgram > 0) {
        const GLint result = glGetUniformLocation(mProgram, name);
        return (result >= 0) ? result : FAILURE(-1);
    } else {
        return FAILURE(-1);
    }
}

// https://registry.khronos.org/OpenGL-Refpages/gl2.1/xhtml/glFrustum.xml
void frustum(float m44[],
             const double left, const double right,
             const double bottom, const double top,
             const double near, const double far) {
    const double invWidth = 1.0 / (right - left);
    const double invHeight = 1.0 / (top - bottom);
    const double invDepth = 1.0 / (far - near);
    const double near2 = 2 * near;

    m44[0] = near2 * invWidth;
    m44[1] = 0;
    m44[2] = (right + left) * invWidth;
    m44[3] = 0;

    m44[4] = 0;
    m44[5] = near2 * invHeight;
    m44[6] = (top + bottom) * invHeight;
    m44[7] = 0;

    m44[8] = 0;
    m44[9] = 0;
    m44[10] = -(far + near) * invDepth;
    m44[11] = -far * near2 * invDepth;

    m44[12] = 0;
    m44[13] = 0;
    m44[14] = -1;
    m44[15] = 0;
}

/*
 * https://registry.khronos.org/OpenGL-Refpages/gl2.1/xhtml/gluLookAt.xml
 * https://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations
 *
 * Here we calculate {Side, Up, Backwards} from Euler angles in the XYZ order:
 *
 * [ 1,    0,     0 ]   [  cosY, 0, sinY ]   [ cosZ, -sinZ, 0 ]   [ sx, ux, bx ]
 * [ 0, cosX, -sinX ] * [     0, 1,    0 ] * [ sinZ,  cosZ, 0 ] = [ sy, uy, by ]
 * [ 0, sinX,  cosX ]   [ -sinY, 0, cosY ]   [    0,     0, 1 ]   [ sz, uz, bz ]
 *
 * We calculate `backwards` because the camera looks into the negative Z
 * direction, so instead of calculating camera's forward and negating it twice,
 * let's call it `backwards`.
 *
 * After multiplying the first two:
 * [         cosY,    0,         sinY ]
 * [  sinX * sinY, cosX, -sinX * cosY ]
 * [ -cosX * sinY, sinX,  cosX * cosY ]
 *
 * The final result:
 * [                       cosY * cosZ,                      -cosY * sinZ,         sinY ]
 * [  sinX * sinY * cosZ + cosX * sinZ, -sinX * sinY * sinZ + cosX * cosZ, -sinX * cosY ]
 * [ -cosX * sinY * cosZ + sinX * sinZ,  cosX * sinY * sinZ + sinX * cosZ,  cosX * cosY ]
 *
 * {Side, Up, Backwards} are the columns in the matrix above.
 */
void lookAtXyzRot(float m44[], const float eye3[], const float rot3[]) {
    const double sinX = sin(rot3[0]);
    const double cosX = cos(rot3[0]);
    const double sinY = sin(rot3[1]);
    const double cosY = cos(rot3[1]);
    const double sinZ = sin(rot3[2]);
    const double cosZ = cos(rot3[2]);

    m44[0]  = cosY * cosZ;
    m44[1]  = sinX * sinY * cosZ + cosX * sinZ;
    m44[2]  = -cosX * sinY * cosZ + sinX * sinZ;
    m44[4]  = -cosY * sinZ;
    m44[5]  = -sinX * sinY * sinZ + cosX * cosZ;
    m44[6]  = cosX * sinY * sinZ + sinX * cosZ;
    m44[8]  = sinY;
    m44[9]  = -sinX * cosY;
    m44[10] = cosX * cosY;
    lookAtEyeCoordinates(m44, eye3);
}

void mulM44(float m44[], const float lhs44[], const float rhs44[]) {
    m44[0] = lhs44[0] * rhs44[0] + lhs44[1] * rhs44[4] + lhs44[2] * rhs44[8] + lhs44[3] * rhs44[12];
    m44[1] = lhs44[0] * rhs44[1] + lhs44[1] * rhs44[5] + lhs44[2] * rhs44[9] + lhs44[3] * rhs44[13];
    m44[2] = lhs44[0] * rhs44[2] + lhs44[1] * rhs44[6] + lhs44[2] * rhs44[10] + lhs44[3] * rhs44[14];
    m44[3] = lhs44[0] * rhs44[3] + lhs44[1] * rhs44[7] + lhs44[2] * rhs44[11] + lhs44[3] * rhs44[15];

    m44[4] = lhs44[4] * rhs44[0] + lhs44[5] * rhs44[4] + lhs44[6] * rhs44[8] + lhs44[7] * rhs44[12];
    m44[5] = lhs44[4] * rhs44[1] + lhs44[5] * rhs44[5] + lhs44[6] * rhs44[9] + lhs44[7] * rhs44[13];
    m44[6] = lhs44[4] * rhs44[2] + lhs44[5] * rhs44[6] + lhs44[6] * rhs44[10] + lhs44[7] * rhs44[14];
    m44[7] = lhs44[4] * rhs44[3] + lhs44[5] * rhs44[7] + lhs44[6] * rhs44[11] + lhs44[7] * rhs44[15];

    m44[8] = lhs44[8] * rhs44[0] + lhs44[9] * rhs44[4] + lhs44[10] * rhs44[8] + lhs44[11] * rhs44[12];
    m44[9] = lhs44[8] * rhs44[1] + lhs44[9] * rhs44[5] + lhs44[10] * rhs44[9] + lhs44[11] * rhs44[13];
    m44[10] = lhs44[8] * rhs44[2] + lhs44[9] * rhs44[6] + lhs44[10] * rhs44[10] + lhs44[11] * rhs44[14];
    m44[11] = lhs44[8] * rhs44[3] + lhs44[9] * rhs44[7] + lhs44[10] * rhs44[11] + lhs44[11] * rhs44[15];

    m44[12] = lhs44[12] * rhs44[0] + lhs44[13] * rhs44[4] + lhs44[14] * rhs44[8] + lhs44[15] * rhs44[12];
    m44[13] = lhs44[12] * rhs44[1] + lhs44[13] * rhs44[5] + lhs44[14] * rhs44[9] + lhs44[15] * rhs44[13];
    m44[14] = lhs44[12] * rhs44[2] + lhs44[13] * rhs44[6] + lhs44[14] * rhs44[10] + lhs44[15] * rhs44[14];
    m44[15] = lhs44[12] * rhs44[3] + lhs44[13] * rhs44[7] + lhs44[14] * rhs44[11] + lhs44[15] * rhs44[15];
}

}  // namespace abc3d
}  // namespace implementation
}  // namespace provider
}  // namespace camera
}  // namespace hardware
}  // namespace android