/* 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 "EGLDisplay.h"

#include "EGLContext.h"

#include "EGLConfig.h"

#include "EGLSurface.h"

#include "EGLImage.h"

#include "EGLWindowSurface.h"

#include "EGLPbufferSurface.h"

#include "ColorDescriptor.h"

#include "EGLOs.h"

#include "EGLUtils.h"

#include "EGLState.h"

#include "EGLProcess.h"

#include "EGLThread.h"

CEGLDisplay::CEGLDisplay( EGLINativeDisplayType nativeType, EGLint processId ) :

    m_nativeType( nativeType ),

    m_initialized( EGL_FALSE ),

    m_processId( processId )

    {

    }

CEGLDisplay::~CEGLDisplay(void)

    {

    DestroyPointerVector<CEGLContext>( m_contexts );

    DestroyPointerVector<CEGLSurface>( m_surfaces );

    DestroyPointerVector<CEGLImage>( m_images );

    }

CEGLContext* CEGLDisplay::AddContext( CEGLContext* context )

    {

    if( context )

        {

        AddObject<CEGLContext>( m_contexts, context );

        }

    return context;

    }

void CEGLDisplay::RemoveContext( EGLContext context )

    {

    DeleteObjectByPointer<CEGLContext>( m_contexts, context );

    }

CEGLContext* CEGLDisplay::GetContext( EGLContext context ) const

    {

    CEGLContext* ret = FindObjectByPointer<CEGLContext>( m_contexts, context, NULL );

    if( ret && ret->IsTerminated() ) ret = NULL;

    return ret;

    }

CEGLSurface* CEGLDisplay::AddSurface( CEGLSurface* surface )

    {

    if( surface )

        {

        AddObject<CEGLSurface>( m_surfaces, surface );

        }

    return surface;

    }

void CEGLDisplay::RemoveSurface( EGLSurface surfaceId )

    {

    DeleteObjectByPointer<CEGLSurface>( m_surfaces, surfaceId );

    }

CEGLSurface* CEGLDisplay::GetSurface( EGLSurface surfaceId ) const

    {

    CEGLSurface* ret = FindObjectByPointer<CEGLSurface>( m_surfaces, surfaceId, NULL );

    if( ret && ret->IsTerminated() ) ret = NULL;

    return ret;

    }

CEGLSurface* CEGLDisplay::GetSurfaceByNativeType( EGLINativeWindowType nativeType ) const

    {

    CEGLSurface* ret = NULL;

    std::vector<CEGLSurface*>::const_iterator iter = m_surfaces.begin();

    while( iter != m_surfaces.end() )

        {

        if( (*iter)->Type() == CEGLSurface::WINDOW_SURFACE )

            {

            if( ((CEGLWindowSurface*)(*iter))->NativeType() == nativeType  && !((*iter)->IsTerminated()) )

                {

                ret = (*iter);

                break;

                }

            }

        iter++;

        }

    return ret;

    }

CEGLSurface* CEGLDisplay::FindSurfaceByClientSurface( void* clientSurface, EGLenum api, EGLint apiVersion ) const

    {

    CEGLSurface* ret = NULL;

    std::vector<CEGLSurface*>::const_iterator iter = m_surfaces.begin();

    while( iter != m_surfaces.end() )

        {

        switch( api )

            {

            case EGL_OPENVG_API:

                {

                if( (*iter)->VGClientSurface() == clientSurface )

                    {

                    ret = (*iter);

                    break;

                    }

                }

            case EGL_OPENGL_ES_API:

                {

                if( (*iter)->GLESClientSurface() == clientSurface )

                    {

                    ret = (*iter);

                    break;

                    }

                }

            }

        iter++;

        }

    return ret;

    }

CEGLSurface* CEGLDisplay::FindSurfaceByClientBuffer( void* clientBuffer ) const

    {

    CEGLSurface* ret = NULL;

    std::vector<CEGLSurface*>::const_iterator iter = m_surfaces.begin();

    while( iter != m_surfaces.end() )

        {

        if( (*iter)->Type() == CEGLSurface::PBUFFER_SURFACE &&

            ((CEGLPbufferSurface*)(*iter))->ClientBuffer() == clientBuffer )

            {

            ret = (*iter);

            break;

            }

        iter++;

        }

    return ret;

    }

EGLINativeDisplayType CEGLDisplay::NativeType() const

    {

    return m_nativeType; 

#else

    return m_nativeType; 

#endif

    }

EGLBoolean CEGLDisplay::Initialize()

    {

    m_initialized = EGL_TRUE;

    return m_initialized;

    }

bool CEGLDisplay::TerminateDisplay()

    {

    //m_initialized = EGL_FALSE;

    bool ret = true;

    std::vector<CEGLSurface*> boundSurfaces;

    std::vector<CEGLSurface*>::iterator sIter = m_surfaces.begin();

    CEGLState* state = getState();

    CEGLThread* thread = state->GetCurrentProcess()->CurrentThread();

    while( sIter != m_surfaces.end() )

        {

        if( (*sIter)->IsTerminated() || !((*sIter)->RemoveRef()) )

            {

            (*sIter)->Terminate();

            boundSurfaces.push_back( (*sIter) );

            sIter = m_surfaces.erase( sIter );

            }

        else

            {

            sIter++;

            }

        }

    DestroyPointerVector<CEGLSurface>(m_surfaces);

    m_surfaces.swap( boundSurfaces );

    boundSurfaces.clear();

    std::vector<CEGLContext*> boundContexts;

    std::vector<CEGLContext*>::iterator cIter = m_contexts.begin();

    while( cIter != m_contexts.end() )

        {

        if( (*cIter)->IsTerminated() || !((*cIter)->RemoveRef()) )

            {

            (*cIter)->Terminate();

            boundContexts.push_back( (*cIter) );

            cIter = m_contexts.erase( cIter );

            }

        else

            {

            cIter++;

            }

        }

    DestroyPointerVector<CEGLContext>(m_contexts);

    m_contexts.swap( boundContexts );

    ret = (m_contexts.size() <= 0 && m_surfaces.size() <= 0);

    Terminate();

    return ret;

    //TODO

    //EGLI_ASSERT( false );

    }

CEGLImage* CEGLDisplay::AddEGLImage( CEGLImage* image )

    {

    if( image )

        {

        AddObject<CEGLImage>( m_images, image );

        }

    return image;

    }

void CEGLDisplay::RemoveEGLImage( EGLImageKHR image )

    {

    DeleteObjectByPointer<CEGLImage>( m_images, image );

    }

CEGLImage* CEGLDisplay::GetImage( EGLImageKHR image ) const

    {

    CEGLImage* ret = FindObjectByPointer<CEGLImage>( m_images, image, NULL );

    return ret;

    }