/*

 * Copyright (c) 2019, 2019, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

#ifndef HEADLESS

#include <stdlib.h>

#include <Foundation/NSObjCRuntime.h>

#include "sun_java2d_pipe_BufferedOpCodes.h"

#include "jlong.h"

//#include "OGLBlitLoops.h"

//#include "OGLBufImgOps.h"

//#include "OGLContext.h"

//#include "OGLMaskBlit.h"

//#include "OGLMaskFill.h"

//#include "OGLPaints.h"

//#include "OGLRenderQueue.h"

//#include "OGLRenderer.h"

//#include "OGLSurfaceData.h"

//#include "OGLTextRenderer.h"

//#include "OGLVertexCache.h"

#include "MetalRenderer.h"

#include "MetalRenderQueue.h"

#include "Trace.h"

#include "MetalSurfaceData.h"

/**

 * Used to track whether we are in a series of a simple primitive operations

 * or texturing operations.  This variable should be controlled only via

 * the INIT/CHECK/RESET_PREVIOUS_OP() macros.  See the

 * OGLRenderQueue_CheckPreviousOp() method below for more information.

 */

//jint previousOp;

/**

 * References to the "current" context and destination surface.

 */

//static MetalContext *mtlc = NULL;

static MetalSDOps *dstOps = NULL;

static MetalContext *mtlc = NULL;

/**

 * The following methods are implemented in the windowing system (i.e. GLX

 * and WGL) source files.

 */

//extern OGLContext *OGLSD_SetScratchSurface(JNIEnv *env, jlong pConfigInfo);

//extern void OGLGC_DestroyOGLGraphicsConfig(jlong pConfigInfo);

//extern void OGLSD_SwapBuffers(JNIEnv *env, jlong window);

//extern void OGLSD_Flush(JNIEnv *env);

JNIEXPORT jlong JNICALL

Java_sun_java2d_metal_MetalRenderQueue_flushBuffer(JNIEnv *env, jobject mtlrq, jlong buf, jint limit)

{

    jboolean sync = JNI_FALSE;

    unsigned char *b, *end;

    J2dTraceLn1(J2D_TRACE_INFO,

                "MetalRenderQueue_flushBuffer: limit=%d", limit);

    NSLog(@"Java_sun_java2d_metal_MetalRenderQueue_flushBuffer :");

    b = (unsigned char *)jlong_to_ptr(buf);

    if (b == NULL) {

        /*J2dRlsTraceLn(J2D_TRACE_ERROR,

            "MetalRenderQueue_flushBuffer: cannot get direct buffer address");*/

        return 0;

    }

    //INIT_PREVIOUS_OP();

    end = b + limit;

    while (b < end) {

        jint opcode = NEXT_INT(b);

        fprintf(stdout, "MetalRenderQueue_flushBuffer_opcode : %d\n", opcode);fflush(stdout);

        switch (opcode) {

        // draw ops

        case sun_java2d_pipe_BufferedOpCodes_DRAW_LINE:

            {

                jint x1 = NEXT_INT(b);

                jint y1 = NEXT_INT(b);

                jint x2 = NEXT_INT(b);

                jint y2 = NEXT_INT(b);

                MetalRenderer_DrawLine(mtlc, x1, y1, x2, y2);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_DRAW_RECT:

            {

                jint x = NEXT_INT(b);

                jint y = NEXT_INT(b);

                jint w = NEXT_INT(b);

                jint h = NEXT_INT(b);

                MetalRenderer_DrawRect(mtlc, x, y, w, h);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_DRAW_POLY:

            {

                jint nPoints      = NEXT_INT(b);

                jboolean isClosed = NEXT_BOOLEAN(b);

                jint transX       = NEXT_INT(b);

                jint transY       = NEXT_INT(b);

                /*jint *xPoints = (jint *)b;

                jint *yPoints = ((jint *)b) + nPoints;

                OGLRenderer_DrawPoly(oglc, nPoints, isClosed,

                                     transX, transY,

                                     xPoints, yPoints);*/

                SKIP_BYTES(b, nPoints * BYTES_PER_POLY_POINT);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_DRAW_PIXEL:

            {

                jint x = NEXT_INT(b);

                jint y = NEXT_INT(b);

                // Note that we could use GL_POINTS here, but the common

                // use case for DRAW_PIXEL is when rendering a Path2D,

                // which will consist of a mix of DRAW_PIXEL and DRAW_LINE

                // calls.  So to improve batching we use GL_LINES here,

                // even though it requires an extra vertex per pixel.

                /*CONTINUE_IF_NULL(oglc);

                CHECK_PREVIOUS_OP(GL_LINES);

                j2d_glVertex2i(x, y);

                j2d_glVertex2i(x+1, y+1);*/

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_DRAW_SCANLINES:

            {

                jint count = NEXT_INT(b);

                //OGLRenderer_DrawScanlines(oglc, count, (jint *)b);

                SKIP_BYTES(b, count * BYTES_PER_SCANLINE);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_DRAW_PARALLELOGRAM:

            {

                jfloat x11 = NEXT_FLOAT(b);

                jfloat y11 = NEXT_FLOAT(b);

                jfloat dx21 = NEXT_FLOAT(b);

                jfloat dy21 = NEXT_FLOAT(b);

                jfloat dx12 = NEXT_FLOAT(b);

                jfloat dy12 = NEXT_FLOAT(b);

                jfloat lwr21 = NEXT_FLOAT(b);

                jfloat lwr12 = NEXT_FLOAT(b);

                MetalRenderer_DrawParallelogram(mtlc,

                                              x11, y11,

                                              dx21, dy21,

                                              dx12, dy12,

                                              lwr21, lwr12);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_DRAW_AAPARALLELOGRAM:

            {

                jfloat x11 = NEXT_FLOAT(b);

                jfloat y11 = NEXT_FLOAT(b);

                jfloat dx21 = NEXT_FLOAT(b);

                jfloat dy21 = NEXT_FLOAT(b);

                jfloat dx12 = NEXT_FLOAT(b);

                jfloat dy12 = NEXT_FLOAT(b);

                jfloat lwr21 = NEXT_FLOAT(b);

                jfloat lwr12 = NEXT_FLOAT(b);

                /*OGLRenderer_DrawAAParallelogram(oglc, dstOps,

                                                x11, y11,

                                                dx21, dy21,

                                                dx12, dy12,

                                                lwr21, lwr12);*/

            }

            break;

        // fill ops

        case sun_java2d_pipe_BufferedOpCodes_FILL_RECT:

            {

                jint x = NEXT_INT(b);

                jint y = NEXT_INT(b);

                jint w = NEXT_INT(b);

                jint h = NEXT_INT(b);

                MetalRenderer_FillRect(mtlc, x, y, w, h);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_FILL_SPANS:

            {

                jint count = NEXT_INT(b);

                //OGLRenderer_FillSpans(oglc, count, (jint *)b);

                SKIP_BYTES(b, count * BYTES_PER_SPAN);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_FILL_PARALLELOGRAM:

            {

                jfloat x11 = NEXT_FLOAT(b);

                jfloat y11 = NEXT_FLOAT(b);

                jfloat dx21 = NEXT_FLOAT(b);

                jfloat dy21 = NEXT_FLOAT(b);

                jfloat dx12 = NEXT_FLOAT(b);

                jfloat dy12 = NEXT_FLOAT(b);

                MetalRenderer_FillParallelogram(mtlc,

                                              x11, y11,

                                              dx21, dy21,

                                              dx12, dy12);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_FILL_AAPARALLELOGRAM:

            {

                jfloat x11 = NEXT_FLOAT(b);

                jfloat y11 = NEXT_FLOAT(b);

                jfloat dx21 = NEXT_FLOAT(b);

                jfloat dy21 = NEXT_FLOAT(b);

                jfloat dx12 = NEXT_FLOAT(b);

                jfloat dy12 = NEXT_FLOAT(b);

                /*OGLRenderer_FillAAParallelogram(oglc, dstOps,

                                                x11, y11,

                                                dx21, dy21,

                                                dx12, dy12);*/

            }

            break;

        // text-related ops

        case sun_java2d_pipe_BufferedOpCodes_DRAW_GLYPH_LIST:

            {

                jint numGlyphs        = NEXT_INT(b);

                jint packedParams     = NEXT_INT(b);

                jfloat glyphListOrigX = NEXT_FLOAT(b);

                jfloat glyphListOrigY = NEXT_FLOAT(b);

                /*jboolean usePositions = EXTRACT_BOOLEAN(packedParams,

                                                        OFFSET_POSITIONS);

                jboolean subPixPos    = EXTRACT_BOOLEAN(packedParams,

                                                        OFFSET_SUBPIXPOS);

                jboolean rgbOrder     = EXTRACT_BOOLEAN(packedParams,

                                                        OFFSET_RGBORDER);

                jint lcdContrast      = EXTRACT_BYTE(packedParams,

                                                     OFFSET_CONTRAST);

                unsigned char *images = b;

                unsigned char *positions;

                jint bytesPerGlyph;

                if (usePositions) {

                    positions = (b + numGlyphs * BYTES_PER_GLYPH_IMAGE);

                    bytesPerGlyph = BYTES_PER_POSITIONED_GLYPH;

                } else {

                    positions = NULL;

                    bytesPerGlyph = BYTES_PER_GLYPH_IMAGE;

                }

                OGLTR_DrawGlyphList(env, oglc, dstOps,

                                    numGlyphs, usePositions,

                                    subPixPos, rgbOrder, lcdContrast,

                                    glyphListOrigX, glyphListOrigY,

                                    images, positions);

                SKIP_BYTES(b, numGlyphs * bytesPerGlyph);*/

            }

            break;

        // copy-related ops

        case sun_java2d_pipe_BufferedOpCodes_COPY_AREA:

            {

                jint x  = NEXT_INT(b);

                jint y  = NEXT_INT(b);

                jint w  = NEXT_INT(b);

                jint h  = NEXT_INT(b);

                jint dx = NEXT_INT(b);

                jint dy = NEXT_INT(b);

                /*OGLBlitLoops_CopyArea(env, oglc, dstOps,

                                      x, y, w, h, dx, dy);*/

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_BLIT:

            {

                jint packedParams = NEXT_INT(b);

                jint sx1          = NEXT_INT(b);

                jint sy1          = NEXT_INT(b);

                jint sx2          = NEXT_INT(b);

                jint sy2          = NEXT_INT(b);

                jdouble dx1       = NEXT_DOUBLE(b);

                jdouble dy1       = NEXT_DOUBLE(b);

                jdouble dx2       = NEXT_DOUBLE(b);

                jdouble dy2       = NEXT_DOUBLE(b);

                jlong pSrc        = NEXT_LONG(b);

                jlong pDst        = NEXT_LONG(b);

                /*jint hint         = EXTRACT_BYTE(packedParams, OFFSET_HINT);

                jboolean texture  = EXTRACT_BOOLEAN(packedParams,

                                                    OFFSET_TEXTURE);

                jboolean rtt      = EXTRACT_BOOLEAN(packedParams,

                                                    OFFSET_RTT);

                jboolean xform    = EXTRACT_BOOLEAN(packedParams,

                                                    OFFSET_XFORM);

                jboolean isoblit  = EXTRACT_BOOLEAN(packedParams,

                                                    OFFSET_ISOBLIT);

                if (isoblit) {

                    OGLBlitLoops_IsoBlit(env, oglc, pSrc, pDst,

                                         xform, hint, texture, rtt,

                                         sx1, sy1, sx2, sy2,

                                         dx1, dy1, dx2, dy2);

                } else {

                    jint srctype = EXTRACT_BYTE(packedParams, OFFSET_SRCTYPE);

                    OGLBlitLoops_Blit(env, oglc, pSrc, pDst,

                                      xform, hint, srctype, texture,

                                      sx1, sy1, sx2, sy2,

                                      dx1, dy1, dx2, dy2);

                }*/

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_SURFACE_TO_SW_BLIT:

            {

                jint sx      = NEXT_INT(b);

                jint sy      = NEXT_INT(b);

                jint dx      = NEXT_INT(b);

                jint dy      = NEXT_INT(b);

                jint w       = NEXT_INT(b);

                jint h       = NEXT_INT(b);

                jint dsttype = NEXT_INT(b);

                jlong pSrc   = NEXT_LONG(b);

                jlong pDst   = NEXT_LONG(b);

                /*OGLBlitLoops_SurfaceToSwBlit(env, oglc,

                                             pSrc, pDst, dsttype,

                                             sx, sy, dx, dy, w, h);*/

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_MASK_FILL:

            {

                jint x        = NEXT_INT(b);

                jint y        = NEXT_INT(b);

                jint w        = NEXT_INT(b);

                jint h        = NEXT_INT(b);

                jint maskoff  = NEXT_INT(b);

                jint maskscan = NEXT_INT(b);

                jint masklen  = NEXT_INT(b);

                unsigned char *pMask = (masklen > 0) ? b : NULL;

                /*OGLMaskFill_MaskFill(oglc, x, y, w, h,

                                     maskoff, maskscan, masklen, pMask);*/

                SKIP_BYTES(b, masklen);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_MASK_BLIT:

            {

                jint dstx     = NEXT_INT(b);

                jint dsty     = NEXT_INT(b);

                jint width    = NEXT_INT(b);

                jint height   = NEXT_INT(b);

                jint masklen  = width * height * sizeof(jint);

                /*OGLMaskBlit_MaskBlit(env, oglc,

                                     dstx, dsty, width, height, b);*/

                SKIP_BYTES(b, masklen);

            }

            break;

        // state-related ops

        case sun_java2d_pipe_BufferedOpCodes_SET_RECT_CLIP:

            {

                jint x1 = NEXT_INT(b);

                jint y1 = NEXT_INT(b);

                jint x2 = NEXT_INT(b);

                jint y2 = NEXT_INT(b);

                //OGLContext_SetRectClip(oglc, dstOps, x1, y1, x2, y2);

                MetalRenderer_SetRectClip(mtlc, x1, y1, x2, y2);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_BEGIN_SHAPE_CLIP:

            {

                //OGLContext_BeginShapeClip(oglc);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_SET_SHAPE_CLIP_SPANS:

            {

                jint count = NEXT_INT(b);

                //OGLRenderer_FillSpans(oglc, count, (jint *)b);

                SKIP_BYTES(b, count * BYTES_PER_SPAN);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_END_SHAPE_CLIP:

            {

                //OGLContext_EndShapeClip(oglc, dstOps);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_RESET_CLIP:

            {

                //OGLContext_ResetClip(oglc);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_SET_ALPHA_COMPOSITE:

            {

                jint rule         = NEXT_INT(b);

                jfloat extraAlpha = NEXT_FLOAT(b);

                jint flags        = NEXT_INT(b);

                //OGLContext_SetAlphaComposite(oglc, rule, extraAlpha, flags);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_SET_XOR_COMPOSITE:

            {

                jint xorPixel = NEXT_INT(b);

                //OGLContext_SetXorComposite(oglc, xorPixel);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_RESET_COMPOSITE:

            {

                //OGLContext_ResetComposite(oglc);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_SET_TRANSFORM:

            {

                jdouble m00 = NEXT_DOUBLE(b);

                jdouble m10 = NEXT_DOUBLE(b);

                jdouble m01 = NEXT_DOUBLE(b);

                jdouble m11 = NEXT_DOUBLE(b);

                jdouble m02 = NEXT_DOUBLE(b);

                jdouble m12 = NEXT_DOUBLE(b);

                //OGLContext_SetTransform(oglc, m00, m10, m01, m11, m02, m12);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_RESET_TRANSFORM:

            {

                //OGLContext_ResetTransform(oglc);

            }

            break;

        // context-related ops

        case sun_java2d_pipe_BufferedOpCodes_SET_SURFACES:

            {

                //fprintf(stdout, "MetalRenderQueue_flushBuffer_SetSurfaces\n");fflush(stdout);

                jlong pSrc = NEXT_LONG(b);

                jlong pDst = NEXT_LONG(b);

                /*if (oglc != NULL) {

                    RESET_PREVIOUS_OP();

                }

                oglc = OGLContext_SetSurfaces(env, pSrc, pDst);*/

                dstOps = (MetalSDOps *)jlong_to_ptr(pDst);

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_SET_SCRATCH_SURFACE:

            {

                jlong pConfigInfo = NEXT_LONG(b);

                /*if (oglc != NULL) {

                    RESET_PREVIOUS_OP();

                }

                oglc = OGLSD_SetScratchSurface(env, pConfigInfo);

                dstOps = NULL;*/

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_FLUSH_SURFACE:

            {

                jlong pData = NEXT_LONG(b);

                /*OGLSDOps *oglsdo = (OGLSDOps *)jlong_to_ptr(pData);

                if (oglsdo != NULL) {

                    CONTINUE_IF_NULL(oglc);

                    RESET_PREVIOUS_OP();

                    OGLSD_Delete(env, oglsdo);

                }*/

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_DISPOSE_SURFACE:

            {

                jlong pData = NEXT_LONG(b);

                /*OGLSDOps *oglsdo = (OGLSDOps *)jlong_to_ptr(pData);

                if (oglsdo != NULL) {

                    CONTINUE_IF_NULL(oglc);

                    RESET_PREVIOUS_OP();

                    OGLSD_Delete(env, oglsdo);

                    if (oglsdo->privOps != NULL) {

                        free(oglsdo->privOps);

                    }

                }*/

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_DISPOSE_CONFIG:

            {

                jlong pConfigInfo = NEXT_LONG(b);

                /*CONTINUE_IF_NULL(oglc);

                RESET_PREVIOUS_OP();

                OGLGC_DestroyOGLGraphicsConfig(pConfigInfo);

                // the previous method will call glX/wglMakeCurrent(None),

                // so we should nullify the current oglc and dstOps to avoid

                // calling glFlush() (or similar) while no context is current

                oglc = NULL;

                dstOps = NULL;*/

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_INVALIDATE_CONTEXT:

            {

                // flush just in case there are any pending operations in

                // the hardware pipe

                /*if (oglc != NULL) {

                    RESET_PREVIOUS_OP();

                    j2d_glFlush();

                }

                // invalidate the references to the current context and

                // destination surface that are maintained at the native level

                oglc = NULL;

                dstOps = NULL;*/

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_SAVE_STATE:

            {

                /*j2d_glPushAttrib(GL_ALL_ATTRIB_BITS);

                j2d_glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);

                j2d_glMatrixMode(GL_MODELVIEW);

                j2d_glPushMatrix();

                j2d_glMatrixMode(GL_PROJECTION);

                j2d_glPushMatrix();

                j2d_glMatrixMode(GL_TEXTURE);

                j2d_glPushMatrix();*/

            }

            break;

        case sun_java2d_pipe_BufferedOpCodes_RESTORE_STATE:

            {

                /*j2d_glPopAttrib();

                j2d_glPopClientAttrib();

                j2d_glMatrixMode(GL_MODELVIEW);

                j2d_glPopMatrix();

                j2d_glMatrixMode(GL_PROJECTION);

                j2d_glPopMatrix();