/* 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:
 *
 */

#ifndef _EGLSTATE_H_
#define _EGLSTATE_H_

#include <EGL/egl.h>
#include "eglInternal.h"
#include <vector>

class CEGLDisplay;
class CEGLProcess;
class CEGLConfig;
class CEGLSurface;
struct SurfaceDescriptor;

class CEGLState : public RefCountingObject, public IVGtoEGLInterface, public IGLEStoEGLInterface
{
public:
	CEGLState(void);
	~CEGLState(void);

public:
    bool Initialize();
    EGLint SupportedApis() const { return m_supportedApis; }
    inline bool IsInitialized() const { return m_initialized; }
    CEGLDisplay* AddDisplay( EGLINativeDisplayType nativeType, EGLint processId );
    void RemoveDisplay( EGLDisplay displayId );
    CEGLDisplay* GetDisplayByNativeType( EGLINativeDisplayType nativeType, EGLint processId ) const;
    CEGLDisplay* GetDisplay( EGLDisplay displayId ) const;
	EGLINativeDisplayType DefaultDisplay() const { return m_defaultDisplay; }

    CEGLProcess* AddProcess( EGLint processId, bool setCurrent);
    void RemoveProcess( EGLint processId );
    CEGLProcess* GetProcess( EGLint processId ) const ;
    inline CEGLProcess* GetCurrentProcess() const { return m_currentProcess; }
    void SetCurrentProcessThread( EGLint processId, EGLI_THREAD_ID threadId );

    inline EGLint ConfigCount() const { return m_configs.size(); }
    void FillConfigs( EGLConfig* configs, EGLint size ) const;
    CEGLConfig* FindConfigById( EGLint id ) const;
    EGLint MatchConfigs( CEGLConfig* filter, EGLConfig* configs, EGLint maxCount ) const;
    CEGLConfig* GetConfig( EGLConfig config ) const;
    
    inline IEGLtoVGInterface* VGInterface() const { return m_VGInterface; }
	IEGLtoGLESInterface* GLESInterface( EGLint clientVersion ) const;

	bool SyncSurface( EGLenum api, EGLint apiVersion, CEGLSurface* surface, CEGLSurface* currentGLESReadSurface );

public: // from IVGtoEGLInterface and IGLEStoEGLInterface
	void GetDescForImage( void* image, SurfaceDescriptor& ImageDesc );
    void* GetDataForImage( void* image );
	void RegisterImageTarget( void* image, EImageTarget target, void* buffer );
	void UnregisterImageTarget( void* image, EImageTarget target, void* buffer );
	void UpdateImageSiblings( void* image, EImageTarget target, void* buffer );

public: // from IVGtoEGLInterface
    void* GetVGContext();
    bool IsImageInUse( void* image );
    bool LockVGSurface( bool read, bool write );
    bool UnlockVGSurface();

public: // from IGLEStoEGLInterface
	void* GetGLESContext();
	void* GetHostProcAddress(const char* proc);
    bool LockGLESSurface( bool read, bool write );
    bool UnlockGLESSurface();
	void ReleaseTexImage(void* surface, int name, int level);

private:
    bool CreateConfigs();
    bool LockSurface( EGLenum api, bool read, bool write );
    bool UnlockSurface( EGLenum api );

private:
    bool                        m_initialized;
    std::vector<CEGLDisplay*>   m_displays;
    std::vector<CEGLProcess*>   m_processes;
    std::vector<CEGLConfig*>    m_configs;
    CEGLProcess*                m_currentProcess;
    EGLILibraryHandle           m_VGLib;
    IEGLtoVGInterface*          m_VGInterface;
    EGLILibraryHandle           m_GLES1Lib;
    IEGLtoGLESInterface*        m_GLES1Interface;
    EGLILibraryHandle           m_GLES2Lib;
    IEGLtoGLES2Interface*       m_GLES2Interface;
	EGLILibraryHandle			m_hostGL;
    EGLint                      m_supportedApis;
	EGLINativeDisplayType       m_defaultDisplay;
    EGLINativeWindowType        m_dummyWindow;
};
#endif //_EGLSTATE_H_