/*
* Copyright (C) 2017 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 "PostWorker.h"

#include "ColorBuffer.h"
#include "DispatchTables.h"
#include "FrameBuffer.h"
#include "RenderThreadInfo.h"
#include "OpenGLESDispatch/EGLDispatch.h"
#include "OpenGLESDispatch/GLESv2Dispatch.h"
#include "host-common/misc.h"
#include <string.h>

#define POST_DEBUG 0
#if POST_DEBUG >= 1
#define DD(fmt, ...) \
    fprintf(stderr, "%s:%d| " fmt, __func__, __LINE__, ##__VA_ARGS__)
#else
#define DD(fmt, ...) (void)0
#endif

static void sDefaultRunOnUiThread(UiUpdateFunc f, void* data, bool wait) {
    (void)f;
    (void)data;
    (void)wait;
}

PostWorker::PostWorker(
        PostWorker::BindSubwinCallback&& cb,
        bool mainThreadPostingOnly,
        EGLContext eglContext,
        EGLSurface) :
    mFb(FrameBuffer::getFB()),
    mBindSubwin(cb),
    m_mainThreadPostingOnly(mainThreadPostingOnly),
    m_runOnUiThread(m_mainThreadPostingOnly ?
        emugl::get_emugl_window_operations().runOnUiThread :
        sDefaultRunOnUiThread),
    mContext(eglContext) {}

void PostWorker::fillMultiDisplayPostStruct(ComposeLayer* l,
                                            hwc_rect_t displayArea,
                                            hwc_frect_t cropArea,
                                            hwc_transform_t transform) {
    l->composeMode = HWC2_COMPOSITION_DEVICE;
    l->blendMode = HWC2_BLEND_MODE_NONE;
    l->transform = transform;
    l->alpha = 1.0;
    l->displayFrame = displayArea;
    l->crop = cropArea;
}

void PostWorker::postImpl(ColorBuffer* cb) {
    // bind the subwindow eglSurface
    if (!m_mainThreadPostingOnly && !m_initialized) {
        m_initialized = mBindSubwin();
    }
    float dpr = mFb->getDpr();
    int windowWidth = mFb->windowWidth();
    int windowHeight = mFb->windowHeight();
    float px = mFb->getPx();
    float py = mFb->getPy();
    int zRot = mFb->getZrot();
    hwc_transform_t rotation = (hwc_transform_t)0;

    cb->waitSync();

    // Find the x and y values at the origin when "fully scrolled."
    // Multiply by 2 because the texture goes from -1 to 1, not 0 to 1.
    // Multiply the windowing coordinates by DPR because they ignore
    // DPR, but the viewport includes DPR.
    float fx = 2.f * (m_viewportWidth  - windowWidth  * dpr) / (float)m_viewportWidth;
    float fy = 2.f * (m_viewportHeight - windowHeight * dpr) / (float)m_viewportHeight;

    // finally, compute translation values
    float dx = px * fx;
    float dy = py * fy;

    if (emugl::get_emugl_multi_display_operations().isMultiDisplayEnabled()) {
        uint32_t combinedW, combinedH;
        emugl::get_emugl_multi_display_operations().getCombinedDisplaySize(&combinedW, &combinedH);
        mFb->getTextureDraw()->prepareForDrawLayer();
        int32_t start_id = -1, x, y;
        uint32_t id, w, h, c;
        while(emugl::get_emugl_multi_display_operations().getNextMultiDisplay(start_id, &id,
                                                                              &x, &y, &w, &h,
                                                                              nullptr, nullptr,
                                                                              &c)) {
            if ((id != 0) && (w == 0 || h == 0 || c == 0)) {
                start_id = id;
                continue;
            }
            ColorBuffer* multiDisplayCb = id == 0 ? cb : mFb->findColorBuffer(c).get();
            if (multiDisplayCb == nullptr) {
                start_id = id;
                continue;
            }
            ComposeLayer l;
            hwc_rect_t displayArea = { .left = (int)x,
                                       .top = (int)y,
                                       .right = (int)(x + w),
                                       .bottom = (int)(y + h) };
            hwc_frect_t cropArea = { .left = 0.0,
                                     .top = (float)multiDisplayCb->getHeight(),
                                     .right = (float)multiDisplayCb->getWidth(),
                                     .bottom = 0.0 };
            fillMultiDisplayPostStruct(&l, displayArea, cropArea, rotation);
            multiDisplayCb->postLayer(&l, combinedW, combinedH);
            start_id = id;
        }
        mFb->getTextureDraw()->cleanupForDrawLayer();
    }
    else if (emugl::get_emugl_window_operations().isFolded()) {
        mFb->getTextureDraw()->prepareForDrawLayer();
        ComposeLayer l;
        int x, y, w, h;
        emugl::get_emugl_window_operations().getFoldedArea(&x, &y, &w, &h);
        hwc_rect_t displayArea = { .left = 0,
                                   .top = 0,
                                   .right = windowWidth,
                                   .bottom = windowHeight };
        hwc_frect_t cropArea = { .left = (float)x,
                                 .top = (float)(y + h),
                                 .right = (float)(x + w),
                                 .bottom = (float)y };
        switch ((int)zRot/90) {
            case 1:
                rotation = HWC_TRANSFORM_ROT_270;
                break;
            case 2:
                rotation = HWC_TRANSFORM_ROT_180;
                break;
            case 3:
                rotation = HWC_TRANSFORM_ROT_90;
                break;
            default: ;
        }

        fillMultiDisplayPostStruct(&l, displayArea, cropArea, rotation);
        cb->postLayer(&l, m_viewportWidth/dpr, m_viewportHeight/dpr);
        mFb->getTextureDraw()->cleanupForDrawLayer();
    }
    else {
        // render the color buffer to the window and apply the overlay
        GLuint tex = cb->scale();
        cb->postWithOverlay(tex, zRot, dx, dy);
    }

    s_egl.eglSwapBuffers(mFb->getDisplay(), mFb->getWindowSurface());
}

// Called whenever the subwindow needs a refresh (FrameBuffer::setupSubWindow).
// This rebinds the subwindow context (to account for
// when the refresh is a display change, for instance)
// and resets the posting viewport.
void PostWorker::viewportImpl(int width, int height) {
    // rebind the subwindow eglSurface unconditionally---
    // this could be from a display change
    if (!m_mainThreadPostingOnly) {
        m_initialized = mBindSubwin();
    }

    float dpr = mFb->getDpr();
    m_viewportWidth = width * dpr;
    m_viewportHeight = height * dpr;
    s_gles2.glViewport(0, 0, m_viewportWidth, m_viewportHeight);
}

// Called when the subwindow refreshes, but there is no
// last posted color buffer to show to the user. Instead of
// displaying whatever happens to be in the back buffer,
// clear() is useful for outputting consistent colors.
void PostWorker::clearImpl() {
#ifndef __linux__
    s_gles2.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT |
                    GL_STENCIL_BUFFER_BIT);
    s_egl.eglSwapBuffers(mFb->getDisplay(), mFb->getWindowSurface());
#endif
}

void PostWorker::composeImpl(ComposeDevice* p) {
    // bind the subwindow eglSurface
    if (!m_mainThreadPostingOnly && !m_initialized) {
        m_initialized = mBindSubwin();
    }
    ComposeLayer* l = (ComposeLayer*)p->layer;
    GLint vport[4] = { 0, };
    s_gles2.glGetIntegerv(GL_VIEWPORT, vport);
    s_gles2.glViewport(0, 0, mFb->getWidth(),mFb->getHeight());
    if (!m_composeFbo) {
        s_gles2.glGenFramebuffers(1, &m_composeFbo);
    }
    s_gles2.glBindFramebuffer(GL_FRAMEBUFFER, m_composeFbo);

    auto cbPtr = mFb->findColorBuffer(p->targetHandle);

    if (!cbPtr) {
        s_gles2.glBindFramebuffer(GL_FRAMEBUFFER, 0);
        s_gles2.glViewport(vport[0], vport[1], vport[2], vport[3]);
        return;
    }

    s_gles2.glFramebufferTexture2D(GL_FRAMEBUFFER,
                                   GL_COLOR_ATTACHMENT0_OES,
                                   GL_TEXTURE_2D,
                                   cbPtr->getTexture(),
                                   0);

    DD("worker compose %d layers\n", p->numLayers);
    mFb->getTextureDraw()->prepareForDrawLayer();
    for (int i = 0; i < p->numLayers; i++, l++) {
        DD("\tcomposeMode %d color %d %d %d %d blendMode "
               "%d alpha %f transform %d %d %d %d %d "
               "%f %f %f %f\n",
               l->composeMode, l->color.r, l->color.g, l->color.b,
               l->color.a, l->blendMode, l->alpha, l->transform,
               l->displayFrame.left, l->displayFrame.top,
               l->displayFrame.right, l->displayFrame.bottom,
               l->crop.left, l->crop.top, l->crop.right,
               l->crop.bottom);
        composeLayer(l, mFb->getWidth(), mFb->getHeight());
    }

    cbPtr->setSync();

    s_gles2.glBindFramebuffer(GL_FRAMEBUFFER, 0);
    s_gles2.glViewport(vport[0], vport[1], vport[2], vport[3]);
    mFb->getTextureDraw()->cleanupForDrawLayer();
}

void PostWorker::composev2Impl(ComposeDevice_v2* p) {
    // bind the subwindow eglSurface
    if (!m_mainThreadPostingOnly && !m_initialized) {
        m_initialized = mBindSubwin();
    }
    ComposeLayer* l = (ComposeLayer*)p->layer;
    GLint vport[4] = { 0, };
    s_gles2.glGetIntegerv(GL_VIEWPORT, vport);
    uint32_t w, h;
    emugl::get_emugl_multi_display_operations().getMultiDisplay(p->displayId,
                                                                nullptr,
                                                                nullptr,
                                                                &w,
                                                                &h,
                                                                nullptr,
                                                                nullptr,
                                                                nullptr);
    s_gles2.glViewport(0, 0, w, h);
    if (!m_composeFbo) {
        s_gles2.glGenFramebuffers(1, &m_composeFbo);
    }
    s_gles2.glBindFramebuffer(GL_FRAMEBUFFER, m_composeFbo);

    auto cbPtr = mFb->findColorBuffer(p->targetHandle);

    if (!cbPtr) {
        s_gles2.glBindFramebuffer(GL_FRAMEBUFFER, 0);
        s_gles2.glViewport(vport[0], vport[1], vport[2], vport[3]);
        return;
    }

    s_gles2.glFramebufferTexture2D(GL_FRAMEBUFFER,
                                   GL_COLOR_ATTACHMENT0_OES,
                                   GL_TEXTURE_2D,
                                   cbPtr->getTexture(),
                                   0);

    DD("worker compose %d layers\n", p->numLayers);
    mFb->getTextureDraw()->prepareForDrawLayer();
    for (int i = 0; i < p->numLayers; i++, l++) {
        DD("\tcomposeMode %d color %d %d %d %d blendMode "
               "%d alpha %f transform %d %d %d %d %d "
               "%f %f %f %f\n",
               l->composeMode, l->color.r, l->color.g, l->color.b,
               l->color.a, l->blendMode, l->alpha, l->transform,
               l->displayFrame.left, l->displayFrame.top,
               l->displayFrame.right, l->displayFrame.bottom,
               l->crop.left, l->crop.top, l->crop.right,
               l->crop.bottom);
        composeLayer(l, w, h);
    }

    cbPtr->setSync();
    s_gles2.glBindFramebuffer(GL_FRAMEBUFFER, 0);
    s_gles2.glViewport(vport[0], vport[1], vport[2], vport[3]);
    mFb->getTextureDraw()->cleanupForDrawLayer();
}

void PostWorker::bind() {
    if (m_mainThreadPostingOnly) {
        if (mFb->getDisplay() != EGL_NO_DISPLAY) {
            EGLint res = s_egl.eglMakeCurrent(mFb->getDisplay(), mFb->getWindowSurface(), mFb->getWindowSurface(), mContext);
            if (!res) fprintf(stderr, "%s: error in binding: 0x%x\n", __func__, s_egl.eglGetError());
        } else {
            fprintf(stderr, "%s: no display!\n", __func__);
        }
    } else {
        mBindSubwin();
    }
}

void PostWorker::unbind() {
    if (mFb->getDisplay() != EGL_NO_DISPLAY) {
        s_egl.eglMakeCurrent(mFb->getDisplay(), EGL_NO_SURFACE, EGL_NO_SURFACE,
                             EGL_NO_CONTEXT);
    }
}

void PostWorker::composeLayer(ComposeLayer* l, uint32_t w, uint32_t h) {
    if (l->composeMode == HWC2_COMPOSITION_DEVICE) {
        ColorBufferPtr cb = mFb->findColorBuffer(l->cbHandle);
        if (!cb) {
            // bad colorbuffer handle
            // ERR("%s: fail to find colorbuffer %d\n", __FUNCTION__, l->cbHandle);
            return;
        }
        cb->postLayer(l, w, h);
    }
    else {
        // no Colorbuffer associated with SOLID_COLOR mode
        mFb->getTextureDraw()->drawLayer(l, w, h, 1, 1, 0);
    }
}

void PostWorker::screenshot(
    ColorBuffer* cb,
    int width,
    int height,
    GLenum format,
    GLenum type,
    int rotation,
    void* pixels) {
    cb->readPixelsScaled(
        width, height, format, type, rotation, pixels);
}

PostWorker::~PostWorker() {
    if (mFb->getDisplay() != EGL_NO_DISPLAY) {
        s_egl.eglMakeCurrent(mFb->getDisplay(), EGL_NO_SURFACE, EGL_NO_SURFACE,
                             EGL_NO_CONTEXT);
    }
}

void PostWorker::post(ColorBuffer* cb) {
    if (m_mainThreadPostingOnly) {
        PostArgs args = {
            .postCb = cb,
        };

        m_toUiThread.send(args);

        m_runOnUiThread([](void* data) {
            PostWorker* p = (PostWorker*)data;
            PostArgs uiThreadArgs;
            p->m_toUiThread.receive(&uiThreadArgs);
            p->bind();
            p->postImpl(uiThreadArgs.postCb);
        },
        this,
        false /* no wait */);
    } else {
        postImpl(cb);
    }
}

void PostWorker::viewport(int width, int height) {
    if (m_mainThreadPostingOnly) {
        PostArgs args = {
            .width = width,
            .height = height,
        };

        m_toUiThread.send(args);

        m_runOnUiThread([](void* data) {
            PostWorker* p = (PostWorker*)data;
            PostArgs uiThreadArgs;
            p->m_toUiThread.receive(&uiThreadArgs);
            p->bind();
            p->viewportImpl(uiThreadArgs.width, uiThreadArgs.height);
        },
        this,
        false /* no wait */);
    } else {
        viewportImpl(width, height);
    }
}

void PostWorker::compose(ComposeDevice* p, uint32_t bufferSize) {
    if (m_mainThreadPostingOnly) {
        PostArgs args;
        std::vector<char> buffer(bufferSize, 0);
        memcpy(buffer.data(), p, bufferSize);
        args.composeBuffer = buffer;

        m_toUiThread.send(args);

        m_runOnUiThread([](void* data) {
            PostWorker* p = (PostWorker*)data;
            PostArgs uiThreadArgs;
            p->m_toUiThread.receive(&uiThreadArgs);
            p->bind();
            p->composeImpl((ComposeDevice*)uiThreadArgs.composeBuffer.data());
        },
        this,
        false /* no wait */);
    } else {
        composeImpl(p);
    }
}

void PostWorker::compose(ComposeDevice_v2* p, uint32_t bufferSize) {
    if (m_mainThreadPostingOnly) {
        PostArgs args;
        std::vector<char> buffer(bufferSize, 0);
        memcpy(buffer.data(), p, bufferSize);
        args.composeBuffer = buffer;

        m_toUiThread.send(args);

        m_runOnUiThread([](void* data) {
            PostWorker* p = (PostWorker*)data;
            PostArgs uiThreadArgs;
            p->m_toUiThread.receive(&uiThreadArgs);
            p->bind();
            p->composev2Impl((ComposeDevice_v2*)uiThreadArgs.composeBuffer.data());
        },
        this,
        false /* no wait */);
    } else {
        composev2Impl(p);
    }
}

void PostWorker::clear() {
    if (m_mainThreadPostingOnly) {
        PostArgs args = {
            .postCb = 0,
        };

        m_toUiThread.send(args);

        m_runOnUiThread([](void* data) {
            PostWorker* p = (PostWorker*)data;
            PostArgs uiThreadArgs;
            p->m_toUiThread.receive(&uiThreadArgs);
            p->bind();
            p->clearImpl();
        },
        this,
        false /* no wait */);
    } else {
        clearImpl();
    }
}