/* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and /or associated documentation files

 * (the "Materials "), to deal in the Materials without restriction,

 * including without limitation the rights to use, copy, modify, merge,

 * publish, distribute, sublicense, and/or sell copies of the Materials,

 * and to permit persons to whom the Materials are 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 Materials.

 *

 * THE MATERIALS ARE 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 THE AUTHORS OR COPYRIGHT HOLDERS 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 MATERIALS OR

 * THE USE OR OTHER DEALINGS IN THE MATERIALS.

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description:

 *

 */

#include <string.h>

#include <algorithm>

#include <EGL/egl.h>

#include "eglDefinitions.h"

#include "eglInternal.h"

#include "EGLState.h"

#include "EGLProcess.h"

#include "EGLDisplay.h"

#include "EGLThread.h"

#include "EGLContext.h"

#include "EGLConfig.h"

#include "EGLWindowSurface.h"

#include "EGLPbufferSurface.h"

#include "ColorDescriptor.h"

#include "SurfaceDescriptor.h"

#include "EGLExtension.h"

#include "EGLOs.h"

#if defined(_WIN32)

#include <windows.h>

#else

    // \todo other platforms

#endif

#if defined(_WIN32) && !defined(EGLI_USE_SIMULATOR_EXTENSIONS)

static DWORD g_tlsIndex = TLS_OUT_OF_INDEXES;

#endif

static CEGLState* g_eglState = NULL;

#if !defined(EGLI_USE_SIMULATOR_EXTENSIONS)

static bool g_lockInitialized = false;

#endif

EGLI_LOCK g_eglLock;

CEGLState* getState()

    {

#if defined(EGLI_USE_SIMULATOR_EXTENSIONS)

    if( !g_eglState )

        {

        g_eglState = EGLI_NEW CEGLState();

        if( !g_eglState )

            {

            return NULL;

            }

        if( !(g_eglState->Initialize()) )

            {

            delete g_eglState;

            g_eglState = NULL;

            return NULL;

            }

        }

    return g_eglState;

#elif defined(_WIN32)

    CEGLOs::GetLock( &g_eglLock );

    if( !g_eglState )

        {

        g_eglState = EGLI_NEW CEGLState();

        if( !g_eglState )

            {

            CEGLOs::ReleaseLock( &g_eglLock );

            return NULL;

            }

        if( !(g_eglState->Initialize()) )

            {

            delete g_eglState;

            g_eglState = NULL;

            CEGLOs::ReleaseLock( &g_eglLock );

            return NULL;

            }

        }

    EGLI_ASSERT( g_tlsIndex != TLS_OUT_OF_INDEXES );

    if( g_tlsIndex == TLS_OUT_OF_INDEXES )

        {

        CEGLOs::ReleaseLock( &g_eglLock );

        return NULL;

        }

    CEGLThread* thread = (CEGLThread*)TlsGetValue( g_tlsIndex );

    if( g_eglState && !thread )

        {

        // \todo Remove CEGLProcess when Simulator extensions are not needed any more

        thread = g_eglState->GetCurrentProcess()->AddThread( GetCurrentThreadId(), true, g_eglState->SupportedApis() );

        if( !thread ) 

            {

            CEGLOs::ReleaseLock( &g_eglLock );

            return NULL;

            }

        if( !(TlsSetValue( g_tlsIndex, (void *)thread )) )

            {

            CEGLOs::ReleaseLock( &g_eglLock );

            return NULL;

            }

        g_eglState->AddRef();

        }

    CEGLOs::ReleaseLock( &g_eglLock );

    return g_eglState;

#else // Linux

    // \todo

    return NULL;

#endif

    }

static void releaseState()

    {

#if defined(EGLI_USE_SIMULATOR_EXTENSIONS)

    if( g_eglState )

        {

        if( g_eglState->RemoveRef() )

            {

            delete g_eglState;

            g_eglState = NULL;

            }

        }

#elif defined(_WIN32)

    CEGLOs::GetLock( &g_eglLock );

    if( g_eglState )

        {

        g_eglState->GetCurrentProcess()->RemoveThread( GetCurrentThreadId() );

        EGLI_ASSERT( g_tlsIndex != TLS_OUT_OF_INDEXES );

        if( g_tlsIndex != TLS_OUT_OF_INDEXES )

            {

            TlsSetValue( g_tlsIndex, 0 );

            }

        }

    if( g_eglState && g_eglState->RemoveRef() )

        {

        delete g_eglState;

        g_eglState = NULL;

        }

    CEGLOs::ReleaseLock( &g_eglLock );

#else // Linux

    // \todo

    EGLI_ASSERT( false );

#endif

    }

/*static*/ CEGLThread* getThread()

    {

#if defined(EGLI_USE_SIMULATOR_EXTENSIONS)

    CEGLState* state = getState();

    CEGLProcess* process = state->GetCurrentProcess();

    if( process )

        {

        return process->CurrentThread();

        }

    return NULL;

#elif defined(_WIN32)

    EGLI_ASSERT( g_tlsIndex != TLS_OUT_OF_INDEXES );

    if( g_tlsIndex == TLS_OUT_OF_INDEXES )

        return NULL;

    CEGLThread* thread = (CEGLThread*)TlsGetValue( g_tlsIndex );

    if( !thread && GetLastError() == ERROR_SUCCESS )

        {

        // TlsGetValue() succeeded but didn't have thread => create one now

        CEGLState* state = getState();

        if( state ) 

            {

            thread = (CEGLThread*)TlsGetValue( g_tlsIndex );

            }

        }

    return thread;

#else // Linux

    // \todo

    EGLI_ASSERT( false );

#endif

    } 

void setEGLError( EGLint error )

    {

    CEGLThread* thread = getThread();

    if( thread )

        {

        thread->SetError( error );

        }

    }

#define EGLI_GET_DISPLAY_RET(id,ret)\

    CEGLDisplay* display = state->GetDisplay( id );\

    if( !display )\

        {\

        EGLI_LEAVE_RET( ret, EGL_BAD_DISPLAY );\

        }\

    EGLI_ASSERT( display->ProcessId() == process->Id() );\

    if( !(display->IsInitialized()) )\

        {\

        EGLI_LEAVE_RET( ret, EGL_NOT_INITIALIZED );\

        }

#ifdef __cplusplus

extern "C" {

#endif

/*When there is no status to return (in other words, when eglGetError is called

as the first EGL call in a thread, or immediately after calling eglReleaseThread),

EGL_SUCCESS will be returned.*/

EGLAPI EGLint EGLAPIENTRY eglGetError(void)

    {

    EGLint err = EGL_SUCCESS;

    CEGLThread* thread = getThread();

    if( thread )

        {

        err = thread->Error();

        thread->SetError( EGL_SUCCESS );

        }

    else

        {

        err = EGL_BAD_ALLOC;

        }

    return err;

    }

EGLAPI EGLDisplay EGLAPIENTRY eglGetDisplay(EGLNativeDisplayType display_id)

    {

    EGLI_ENTER_RET( EGL_NO_DISPLAY );

	if( display_id == EGL_DEFAULT_DISPLAY )

		{

		display_id = (EGLNativeDisplayType)state->DefaultDisplay();

		}

    CEGLDisplay* display = state->GetDisplayByNativeType( (EGLINativeDisplayType)display_id, process->Id() );

    if( !display )

        {

        if( !(CEGLOs::IsValidNativeDisplay( (EGLINativeDisplayType)display_id )) )

            {

            EGLI_LEAVE_RET( EGL_NO_DISPLAY, EGL_BAD_PARAMETER );

            }

        display = state->AddDisplay( (EGLINativeDisplayType)display_id, process->Id() );

        if( !display )

            {

            EGLI_LEAVE_RET( EGL_NO_DISPLAY, EGL_BAD_ALLOC );

            }

		display->AddRef();

        }

    EGLI_LEAVE_RET( (EGLDisplay)display, EGL_SUCCESS );

    }

EGLAPI EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)

    {

    EGLI_ENTER_RET( EGL_FALSE );

    CEGLDisplay* display = state->GetDisplay( dpy );

    if( !display )

        {

        EGLI_LEAVE_RET( EGL_FALSE, EGL_BAD_DISPLAY );

        }

    if( !(display->IsInitialized()) && !(display->Initialize()) )

        {

        EGLI_LEAVE_RET( EGL_FALSE, EGL_NOT_INITIALIZED );

        }

    if( major ) *major = 1;

    if( minor ) *minor = 4;

    EGLI_LEAVE_RET( EGL_TRUE, EGL_SUCCESS );

    }

EGLAPI EGLBoolean EGLAPIENTRY eglTerminate(EGLDisplay dpy)

    {

    EGLI_ENTER_RET( EGL_FALSE );

    CEGLDisplay* display = state->GetDisplay( dpy );

#if defined(EGLI_USE_SIMULATOR_EXTENSIONS)

    if( display && display->ProcessId() != process->Id() )

        {

        EGLI_LEAVE_RET( EGL_FALSE, EGL_BAD_DISPLAY );

        }

#endif

    if( !display )

        {

        EGLI_LEAVE_RET( EGL_FALSE, EGL_BAD_DISPLAY );

        }

    if( !(display->IsInitialized()) )

        {

        EGLI_LEAVE_RET( EGL_TRUE, EGL_SUCCESS );

        }

    display->RemoveRef();

    if( display->TerminateDisplay() )

        {

        state->RemoveDisplay( display );

        }

    EGLI_LEAVE_RET( EGL_TRUE, EGL_SUCCESS );

    }

/*

    eglQueryString returns a pointer to a static, zero-terminated string describing

    some aspect of the EGL implementation running on the specified display. name

    may be one of EGL_CLIENT_APIS, EGL_EXTENSIONS, EGL_VENDOR, or EGL_-

    VERSION.

    The EGL_CLIENT_APIS string describes which client rendering APIs are

    supported. It is zero-terminated and contains a space-separated list of API

    names, which must include at least one of ‘‘OpenGL’’, ‘‘OpenGL_ES’’ or

    ‘‘OpenVG’’.

    The EGL_EXTENSIONS string describes which EGL extensions are supported

    by the EGL implementation running on the specified display. The string is zeroterminated

    and contains a space-separated list of extension names; extension names

    themselves do not contain spaces. If there are no extensions to EGL, then the empty

    string is returned.

    The format and contents of the EGL_VENDOR string is implementation dependent.

    The format of the EGL_VERSION string is:

    <major version.minor version><space><vendor specific info>

*/

EGLAPI const char * EGLAPIENTRY eglQueryString(EGLDisplay dpy, EGLint name)

    {

    EGLI_ENTER_RET( NULL );

    EGLI_GET_DISPLAY_RET( dpy, NULL );

    const char* ret = NULL;

    switch(name)

        {

        case EGL_CLIENT_APIS:

            {

            switch( state->SupportedApis() )

                {

                case EGL_OPENVG_BIT | EGL_OPENGL_ES_BIT | EGL_OPENGL_ES2_BIT:

                    {

                    ret = "OpenVG OpenGL_ES OpenGL_ES2";

                    break;

                    }

                case EGL_OPENVG_BIT | EGL_OPENGL_ES_BIT:

                    {

                    ret = "OpenVG OpenGL_ES";

                    break;

                    }

                case EGL_OPENVG_BIT | EGL_OPENGL_ES2_BIT:

                    {

                    ret = "OpenVG OpenGL_ES2";

                    break;

                    }

                case EGL_OPENVG_BIT:

                    {

                    ret = "OpenVG";

                    break;

                    }

                case EGL_OPENGL_ES_BIT | EGL_OPENGL_ES2_BIT:

                    {

                    ret = "OpenGL_ES OpenGL_ES2";

                    break;

                    }

                case EGL_OPENGL_ES_BIT:

                    {

                    ret = "OpenGL_ES";

                    break;

                    }

                case EGL_OPENGL_ES2_BIT:

                    {

                    ret = "OpenGL_ES2";

                    break;

                    }

                default:

                    {

                    ret = "";

                    break;

                    }

                }

            break;

            }

        case EGL_EXTENSIONS:

            {

            // TODO

            ret = "EGL_KHR_image_base";

            break;

            }

        case EGL_VENDOR:

            {

            ret = "Nokia";

            break;

            }

        case EGL_VERSION:

            {

            ret ="1.4 Simulator";

            break;

            }

        default:

            {

            EGLI_LEAVE_RET( NULL, EGL_BAD_PARAMETER );

            break;

            }

        }

    EGLI_LEAVE_RET( ret, EGL_SUCCESS );

    }

EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigs(EGLDisplay dpy, EGLConfig *configs,

			 EGLint config_size, EGLint *num_config)

    {

    EGLI_ENTER_RET( EGL_FALSE );

    if( !num_config )

        {

        EGLI_LEAVE_RET( EGL_FALSE, EGL_BAD_PARAMETER );

        }

    EGLI_GET_DISPLAY_RET( dpy, EGL_FALSE );

    EGLint configCount = state->ConfigCount();

    if( !configs )

        {

        *num_config = configCount;

        EGLI_LEAVE_RET( EGL_TRUE, EGL_SUCCESS );

        }

    *num_config = EGLI_MIN( configCount, config_size );

    state->FillConfigs( configs, *num_config );

    EGLI_LEAVE_RET( EGL_TRUE, EGL_SUCCESS );

    }

EGLAPI EGLBoolean EGLAPIENTRY eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list,

			   EGLConfig *configs, EGLint config_size,

			   EGLint *num_config)

    {

    EGLI_ENTER_RET( EGL_FALSE );

    EGLI_GET_DISPLAY_RET( dpy, EGL_FALSE );

    CColorDescriptor* colorDesc = EGLI_NEW CColorDescriptor( 0, 0, 0, 0, true, 0, false, 0, 0 );

    if( !colorDesc )

        {

        EGLI_LEAVE_RET( EGL_FALSE, EGL_BAD_ALLOC );

        }

    colorDesc->SetAttribute( EGL_COLOR_BUFFER_TYPE, EGL_RGB_BUFFER );

    CEGLConfig* filter = EGLI_NEW CEGLConfig(

                    *colorDesc,

                    (EGLBoolean)EGL_DONT_CARE,  

                    (EGLBoolean)EGL_DONT_CARE,

                    (EGLenum)EGL_DONT_CARE,

                    EGL_DONT_CARE,

                    0, 0, 0,

                    EGL_DONT_CARE,

                    EGL_DONT_CARE,

                    (EGLBoolean)EGL_DONT_CARE,

                    EGL_DONT_CARE,

                    EGL_OPENGL_ES_BIT,

                    0, 0, 0,

                    EGL_WINDOW_BIT,

                    NULL );          // transparent color    

    delete colorDesc;

    colorDesc = NULL;

    if( !filter )

        {

        EGLI_LEAVE_RET( EGL_FALSE, EGL_BAD_ALLOC );

        }

    EGLint configId = 0;

    EGLint matchPixmap = EGL_NONE;

    if( attrib_list && attrib_list[0] != EGL_NONE )

        {

        for( EGLint i=0; attrib_list[i] != EGL_NONE && configId == 0; i+=2 )

            {

            switch( attrib_list[i] )

                {

                case EGL_NATIVE_VISUAL_ID:

                case EGL_MAX_PBUFFER_HEIGHT:

                case EGL_MAX_PBUFFER_PIXELS:

                case EGL_MAX_PBUFFER_WIDTH:

                    {

                    // IGNORED

                    break;

                    }

                case EGL_CONFIG_ID:

                    {

                    configId = attrib_list[i+1];

                    break;

                    }

                case EGL_MATCH_NATIVE_PIXMAP:

                    {

                    matchPixmap = attrib_list[i+1];

                    break;

                    }

                default:

                    {

                    if( !(filter->SetAttribute(attrib_list[i], attrib_list[i+1])) )

                        {

                        delete filter;

                        filter = NULL;

                        EGLI_LEAVE_RET( EGL_FALSE, EGL_BAD_ATTRIBUTE );

                        }

                    }

                }

            }

        }

    if( configId > 0 )

        {

        CEGLConfig* config = state->FindConfigById( configId );

        if( !config )