/* San Angeles Observation OpenGL ES version example
 * Copyright 2004-2005 Jetro Lauha
 * All rights reserved.
 * Web: http://iki.fi/jetro/
 *
 * This source is free software; you can redistribute it and/or
 * modify it under the terms of EITHER:
 *   (1) The GNU Lesser General Public License as published by the Free
 *       Software Foundation; either version 2.1 of the License, or (at
 *       your option) any later version. The text of the GNU Lesser
 *       General Public License is included with this source in the
 *       file LICENSE-LGPL.txt.
 *   (2) The BSD-style license that is included with this source in
 *       the file LICENSE-BSD.txt.
 *
 * This source 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 files
 * LICENSE-LGPL.txt and LICENSE-BSD.txt for more details.
 *
 * $Id: app-linux.c,v 1.4 2005/02/08 18:42:48 tonic Exp $
 * $Revision: 1.4 $
 *
 * Parts of this source file is based on test/example code from
 * GLESonGL implementation by David Blythe. Here is copy of the
 * license notice from that source:
 *
 * Copyright (C) 2003  David Blythe   All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * DAVID BLYTHE BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

// With regular OpenGL (instead of GLES), we use glx library functions to
// initialize and finalyze.

#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>

#ifdef SAN_ANGELES_OBSERVATION_GLES
#undef IMPORTGL_API
#undef IMPORTGL_FNPTRINIT
#include "importgl.h"
#else  // SAN_ANGELES_OBSERVATION_GLES
#include <GL/glx.h>
#undef IMPORTVBO_API
#undef IMPORTVBO_FNPTRINIT
#include "importvbo.h"
#endif  // SAN_ANGELES_OBSERVATION_GLES | !SAN_ANGELES_OBSERVATION_GLES

#include "app.h"


int gAppAlive = 1;
static Display *sDisplay;
static Window sWindow;
static int sWindowWidth = WINDOW_DEFAULT_WIDTH;
static int sWindowHeight = WINDOW_DEFAULT_HEIGHT;
#ifdef SAN_ANGELES_OBSERVATION_GLES
static const char sAppName[] =
    "San Angeles Observation OpenGL ES version example (Linux)";
static EGLDisplay sEglDisplay = EGL_NO_DISPLAY;
static EGLConfig sEglConfig = 0;
static EGLContext sEglContext = EGL_NO_CONTEXT;
static EGLSurface sEglSurface = EGL_NO_SURFACE;
#ifndef DISABLE_IMPORTGL
static char *sPathLibGLES = NULL;
static char *sPathLibEGL = NULL;
#endif  // !DISABLE_IMPORTGL
#else  // !SAN_ANGELES_OBSERVATION_GLES
static const char sAppName[] =
    "San Angeles Observation OpenGL version example (Linux)";
static GLXContext sContext;
#endif  // SAN_ANGELES_OBSERVATION_GLES | !SAN_ANGELES_OBSERVATION_GLES

static void checkGLErrors()
{
    GLenum error = glGetError();
    if (error != GL_NO_ERROR)
        fprintf(stderr, "Error: GL error code 0x%04x\n", (int)error);
}

#ifdef SAN_ANGELES_OBSERVATION_GLES

static void checkEGLErrors()
{
    EGLint error = eglGetError();
    // GLESonGL seems to be returning 0 when there is no errors?
    if (error && error != EGL_SUCCESS)
        fprintf(stderr, "Error: EGL error code 0x%04x\n", (int)error);
}

// Initializes and opens both X11 display and OpenGL ES.
static int initGraphics()
{
    static const EGLint configAttribs[] =
    {
        EGL_SURFACE_TYPE,     EGL_WINDOW_BIT,
        EGL_RENDERABLE_TYPE,  EGL_OPENGL_ES2_BIT,
        EGL_BUFFER_SIZE,      16,
        EGL_DEPTH_SIZE,       16,
        EGL_NONE
    };
    static const EGLint contextAttribs[] =
    {
        EGL_CONTEXT_CLIENT_VERSION,  2,
        EGL_NONE
    };
    EGLBoolean success;
    EGLint numConfigs = 0;
    EGLint majorVersion;
    EGLint minorVersion;

#ifndef DISABLE_IMPORTGL
    int importGLResult;
    importGLResult = importGLInit(sPathLibGLES, sPathLibEGL);
    if (!importGLResult)
        return 0;
#endif  // !DISABLE_IMPORTGL

    sDisplay = XOpenDisplay(NULL);
    if (sDisplay == NULL)
    {
        fprintf(stderr, "Error: XOpenDisplay failed\n");
        return 0;
    }
    int screen = XDefaultScreen(sDisplay);
    Window root_window = RootWindow(sDisplay, screen);
    int depth = DefaultDepth(sDisplay, screen);
    XVisualInfo *vi, tmp;
    vi = &tmp;
    XMatchVisualInfo(sDisplay, screen, depth, TrueColor, vi);
    if (vi == NULL)
    {
        fprintf(stderr, "Error: XMatchVisualInfo failed\n");
        return 0;
    }

    XSetWindowAttributes swa;
    swa.colormap = XCreateColormap(sDisplay, root_window, vi->visual,
                                   AllocNone);
    swa.event_mask = ExposureMask | StructureNotifyMask |
                     KeyPressMask | ButtonPressMask | ButtonReleaseMask;
    sWindow = XCreateWindow(sDisplay, root_window,
                            0, 0, sWindowWidth, sWindowHeight,
                            0, vi->depth, InputOutput, vi->visual,
                            CWBorderPixel | CWColormap | CWEventMask,
                            &swa);
    XMapWindow(sDisplay, sWindow);
    XSizeHints sh;
    sh.flags = PMinSize | PMaxSize;
    sh.min_width = sh.max_width = sWindowWidth;
    sh.min_height = sh.max_height = sWindowHeight;
    XSetStandardProperties(sDisplay, sWindow, sAppName, sAppName,
                           None, (void *)0, 0, &sh);
    XFlush(sDisplay);

    sEglDisplay = eglGetDisplay(sDisplay);
    success = eglInitialize(sEglDisplay, &majorVersion, &minorVersion);
    if (success == EGL_FALSE)
    {
        fprintf(stderr, "Error: eglInitialize failed\n");
        checkEGLErrors();
        return 0;
    }
    success = eglBindAPI(EGL_OPENGL_ES_API);
    if (success == EGL_FALSE)
    {
        fprintf(stderr, "Error: eglInitialize failed\n");
        checkEGLErrors();
        return 0;
    }
    success = eglChooseConfig(sEglDisplay, configAttribs,
                              &sEglConfig, 1, &numConfigs);
    if (success == EGL_FALSE || numConfigs != 1)
    {
        fprintf(stderr, "Error: eglChooseConfig failed\n");
        checkEGLErrors();
        return 0;
    }
    sEglContext = eglCreateContext(sEglDisplay, sEglConfig, NULL,
                                   contextAttribs);
    if (sEglContext == EGL_NO_CONTEXT)
    {
        fprintf(stderr, "Error: eglCreateContext failed\n");
        checkEGLErrors();
        return 0;
    }
    sEglSurface = eglCreateWindowSurface(sEglDisplay, sEglConfig,
                                         (NativeWindowType)sWindow, NULL);
    if (sEglSurface == EGL_NO_SURFACE)
    {
        fprintf(stderr, "Error: eglCreateWindowSurface failed\n");
        checkEGLErrors();
        return 0;
    }
    success = eglMakeCurrent(sEglDisplay, sEglSurface,
                             sEglSurface, sEglContext);
    if (success == EGL_FALSE)
    {
        fprintf(stderr, "Error: eglMakeCurrent failed\n");
        checkEGLErrors();
        return 0;
    }
    return 1;
}

static void deinitGraphics()
{
    eglMakeCurrent(sEglDisplay, NULL, NULL, NULL);
    eglDestroyContext(sEglDisplay, sEglContext);
    eglDestroySurface(sEglDisplay, sEglSurface);
    eglTerminate(sEglDisplay);
#ifndef DISABLE_IMPORTGL
    importGLDeinit();
#endif  // !DISABLE_IMPORTGL
}

#else  // !SAN_ANGELES_OBSERVATION_GLES

// Initializes and opens both X11 display and OpenGL.
static int initGraphics()
{
    sDisplay = XOpenDisplay(NULL);
    if(sDisplay == NULL)
    {
        fprintf(stderr, "Error: XOpenDisplay failed\n");
        return 0;
    }
    Window root_window = DefaultRootWindow(sDisplay);
    GLint att[] = { GLX_RGBA,
                    GLX_DEPTH_SIZE,
                    24,
                    GLX_DOUBLEBUFFER,
                    None };
    XVisualInfo *vi = glXChooseVisual(sDisplay, 0, att);
    if (vi == NULL)
    {
        fprintf(stderr, "Error: glXChooseVisual failed\n");
        return 0;
    }

    XSetWindowAttributes swa;
    swa.colormap = XCreateColormap(sDisplay,
                                   root_window,
                                   vi->visual,
                                   AllocNone);
    XSizeHints sh;
    sh.flags = PMinSize | PMaxSize;
    sh.min_width = sh.max_width = sWindowWidth;
    sh.min_height = sh.max_height = sWindowHeight;
    swa.border_pixel = 0;
    swa.event_mask = ExposureMask | StructureNotifyMask |
                     KeyPressMask | ButtonPressMask | ButtonReleaseMask;
    sWindow = XCreateWindow(sDisplay, root_window,
                            0, 0, sWindowWidth, sWindowHeight,
                            0, vi->depth, InputOutput, vi->visual,
                            CWBorderPixel | CWColormap | CWEventMask,
                            &swa);
    XMapWindow(sDisplay, sWindow);
    XSetStandardProperties(sDisplay, sWindow, sAppName, sAppName,
                           None, (void *)0, 0, &sh);

    sContext = glXCreateContext(sDisplay, vi, NULL, GL_TRUE);
    glXMakeCurrent(sDisplay, sWindow, sContext);

    glEnable(GL_DEPTH_TEST);

    XFree(vi);
    int rt = 1;
#ifndef SAN_ANGELES_OBSERVATION_GLES
    rt = loadVBOProcs();
#endif  // !SAN_ANGELES_OBSERVATION_GLES
    return rt;
}

static void deinitGraphics()
{
    glXMakeCurrent(sDisplay, None, NULL);
    glXDestroyContext(sDisplay, sContext);
    XDestroyWindow(sDisplay, sWindow);
    XCloseDisplay(sDisplay);
}

#endif  // SAN_ANGELES_OBSERVATION_GLES | !SAN_ANGELES_OBSERVATION_GLES

int main(int argc, char *argv[])
{
    // not referenced:
    argc = argc;
    argv = argv;

#ifdef SAN_ANGELES_OBSERVATION_GLES
#ifndef DISABLE_IMPORTGL
    if (argc != 3)
    {
        fprintf(stderr, "Usage: SanOGLES libGLESxx.so libEGLxx.so\n");
        return EXIT_FAILURE;
    }
    sPathLibGLES = argv[1];
    sPathLibEGL = argv[2];
#endif  // !DISABLE_IMPORTGL
#endif  // SAN_ANGELES_OBSERVATION_GLES

    if (!initGraphics())
    {
        fprintf(stderr, "Error: Graphics initialization failed.\n");
        return EXIT_FAILURE;
    }

    if (!appInit())
    {
        fprintf(stderr, "Error: Application initialization failed.\n");
        return EXIT_FAILURE;
    }

    double total_time = 0.0;
    int num_frames = 0;

    while (gAppAlive)
    {
        while (XPending(sDisplay))
        {
            XEvent ev;
            XNextEvent(sDisplay, &ev);
            switch (ev.type)
            {
            case KeyPress:
                {
                    unsigned int keycode, keysym;
                    keycode = ((XKeyEvent *)&ev)->keycode;
                    keysym = XKeycodeToKeysym(sDisplay, keycode, 0);
                    if (keysym == XK_Return || keysym == XK_Escape)
                        gAppAlive = 0;
                }
                break;
            }
        }

        if (gAppAlive)
        {
            struct timeval timeNow, timeAfter;

            gettimeofday(&timeNow, NULL);
            appRender(timeNow.tv_sec * 1000 + timeNow.tv_usec / 1000,
                      sWindowWidth, sWindowHeight);
            gettimeofday(&timeAfter, NULL);
#ifdef SAN_ANGELES_OBSERVATION_GLES
            checkGLErrors();
            eglSwapBuffers(sEglDisplay, sEglSurface);
            checkEGLErrors();
#else  // !SAN_ANGELES_OBSERVATION_GLES
            glXSwapBuffers(sDisplay, sWindow);
            checkGLErrors();
#endif  // SAN_ANGELES_OBSERVATION_GLES | !SAN_ANGELES_OBSERVATION_GLES
            total_time += (timeAfter.tv_sec - timeNow.tv_sec) +
                          (timeAfter.tv_usec - timeNow.tv_usec) / 1000000.0;
            num_frames++;
        }
    }

    appDeinit();
    deinitGraphics();

    fprintf(stdout, "frame_rate = %.1f\n", num_frames / total_time);

    return EXIT_SUCCESS;
}