/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES Utilities
 * ------------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief OpenGL ES context wrapper that uses FBO as default framebuffer.
 *//*--------------------------------------------------------------------*/

#include "gluFboRenderContext.hpp"
#include "gluContextFactory.hpp"
#include "gluRenderConfig.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "tcuCommandLine.hpp"
#include "gluTextureUtil.hpp"
#include "tcuTextureUtil.hpp"

#include <sstream>

namespace glu
{

static int getNumDepthBits (const tcu::TextureFormat& format)
{
	if (format.order == tcu::TextureFormat::DS)
	{
		const tcu::TextureFormat	depthOnlyFormat		= tcu::getEffectiveDepthStencilTextureFormat(format, tcu::Sampler::MODE_DEPTH);
		return tcu::getTextureFormatBitDepth(depthOnlyFormat).x();
	}
	else if (format.order == tcu::TextureFormat::D)
		return tcu::getTextureFormatBitDepth(format).x();
	else
		return 0;
}

static int getNumStencilBits (const tcu::TextureFormat& format)
{
	if (format.order == tcu::TextureFormat::DS)
	{
		const tcu::TextureFormat	stencilOnlyFormat		= tcu::getEffectiveDepthStencilTextureFormat(format, tcu::Sampler::MODE_STENCIL);
		return tcu::getTextureFormatBitDepth(stencilOnlyFormat).x();
	}
	else if (format.order == tcu::TextureFormat::S)
		return tcu::getTextureFormatBitDepth(format).x();
	else
		return 0;
}

static tcu::PixelFormat getPixelFormat (deUint32 colorFormat)
{
	const tcu::IVec4 bits = tcu::getTextureFormatBitDepth(glu::mapGLInternalFormat(colorFormat));
	return tcu::PixelFormat(bits[0], bits[1], bits[2], bits[3]);
}

static void getDepthStencilBits (deUint32 depthStencilFormat, int* depthBits, int* stencilBits)
{
	const tcu::TextureFormat	combinedFormat	= glu::mapGLInternalFormat(depthStencilFormat);

	*depthBits		= getNumDepthBits(combinedFormat);
	*stencilBits	= getNumStencilBits(combinedFormat);
}

deUint32 chooseColorFormat (const glu::RenderConfig& config)
{
	static const deUint32 s_formats[] =
	{
		GL_RGBA8,
		GL_RGB8,
		GL_RG8,
		GL_R8,
		GL_RGBA4,
		GL_RGB5_A1,
		GL_RGB565,
		GL_RGB5
	};

	for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(s_formats); fmtNdx++)
	{
		const deUint32		format	= s_formats[fmtNdx];
		const tcu::IVec4	bits	= tcu::getTextureFormatBitDepth(glu::mapGLInternalFormat(format));

		if (config.redBits != glu::RenderConfig::DONT_CARE &&
			config.redBits != bits[0])
			continue;

		if (config.greenBits != glu::RenderConfig::DONT_CARE &&
			config.greenBits != bits[1])
			continue;

		if (config.blueBits != glu::RenderConfig::DONT_CARE &&
			config.blueBits != bits[2])
			continue;

		if (config.alphaBits != glu::RenderConfig::DONT_CARE &&
			config.alphaBits != bits[3])
			continue;

		return format;
	}

	return 0;
}

deUint32 chooseDepthStencilFormat (const glu::RenderConfig& config)
{
	static const deUint32 s_formats[] =
	{
		GL_DEPTH32F_STENCIL8,
		GL_DEPTH24_STENCIL8,
		GL_DEPTH_COMPONENT32F,
		GL_DEPTH_COMPONENT24,
		GL_DEPTH_COMPONENT16,
		GL_STENCIL_INDEX8
	};

	for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(s_formats); fmtNdx++)
	{
		const deUint32				format			= s_formats[fmtNdx];
		const tcu::TextureFormat	combinedFormat	= glu::mapGLInternalFormat(format);
		const int					depthBits		= getNumDepthBits(combinedFormat);
		const int					stencilBits		= getNumStencilBits(combinedFormat);

		if (config.depthBits != glu::RenderConfig::DONT_CARE &&
			config.depthBits != depthBits)
			continue;

		if (config.stencilBits != glu::RenderConfig::DONT_CARE &&
			config.stencilBits != stencilBits)
			continue;

		return format;
	}

	return 0;
}

FboRenderContext::FboRenderContext (RenderContext* context, const RenderConfig& config)
	: m_context				(context)
	, m_framebuffer			(0)
	, m_colorBuffer			(0)
	, m_depthStencilBuffer	(0)
	, m_renderTarget		()
{
	try
	{
		createFramebuffer(config);
	}
	catch (...)
	{
		destroyFramebuffer();
		throw;
	}
}

FboRenderContext::FboRenderContext (const ContextFactory& factory, const RenderConfig& config, const tcu::CommandLine& cmdLine)
	: m_context				(DE_NULL)
	, m_framebuffer			(0)
	, m_colorBuffer			(0)
	, m_depthStencilBuffer	(0)
	, m_renderTarget		()
{
	try
	{
		RenderConfig nativeRenderConfig;
		nativeRenderConfig.type				= config.type;
		nativeRenderConfig.windowVisibility	= config.windowVisibility;
		// \note All other properties are defaults, mostly DONT_CARE
		m_context = factory.createContext(nativeRenderConfig, cmdLine, DE_NULL);
		createFramebuffer(config);
	}
	catch (...)
	{
		delete m_context;
		throw;
	}
}

FboRenderContext::~FboRenderContext (void)
{
	// \todo [2013-04-08 pyry] Do we want to destry FBO before destroying context?
	delete m_context;
}

void FboRenderContext::postIterate (void)
{
	// \todo [2012-11-27 pyry] Blit to default framebuffer in ES3?
	m_context->getFunctions().finish();
}

void FboRenderContext::makeCurrent(void)
{
	m_context->makeCurrent();
}

void FboRenderContext::createFramebuffer (const RenderConfig& config)
{
	DE_ASSERT(m_framebuffer == 0 && m_colorBuffer == 0 && m_depthStencilBuffer == 0);

	const glw::Functions&	gl					= m_context->getFunctions();
	const deUint32			colorFormat			= chooseColorFormat(config);
	const deUint32			depthStencilFormat	= chooseDepthStencilFormat(config);
	int						width				= config.width;
	int						height				= config.height;
	tcu::PixelFormat		pixelFormat;
	int						depthBits			= 0;
	int						stencilBits			= 0;

	if (config.numSamples > 0 && !gl.renderbufferStorageMultisample)
		throw tcu::NotSupportedError("Multisample FBO is not supported");

	if (colorFormat == 0)
		throw tcu::NotSupportedError("Unsupported color attachment format");

	if (width == glu::RenderConfig::DONT_CARE || height == glu::RenderConfig::DONT_CARE)
	{
		int maxSize = 0;
		gl.getIntegerv(GL_MAX_RENDERBUFFER_SIZE, &maxSize);

		width	= (width	== glu::RenderConfig::DONT_CARE) ? maxSize : width;
		height	= (height	== glu::RenderConfig::DONT_CARE) ? maxSize : height;
	}

	{
		pixelFormat = getPixelFormat(colorFormat);

		gl.genRenderbuffers(1, &m_colorBuffer);
		gl.bindRenderbuffer(GL_RENDERBUFFER, m_colorBuffer);

		if (config.numSamples > 0)
			gl.renderbufferStorageMultisample(GL_RENDERBUFFER, config.numSamples, colorFormat, width, height);
		else
			gl.renderbufferStorage(GL_RENDERBUFFER, colorFormat, width, height);

		gl.bindRenderbuffer(GL_RENDERBUFFER, 0);
		GLU_EXPECT_NO_ERROR(gl.getError(), "Creating color renderbuffer");
	}

	if (depthStencilFormat != GL_NONE)
	{
		getDepthStencilBits(depthStencilFormat, &depthBits, &stencilBits);

		gl.genRenderbuffers(1, &m_depthStencilBuffer);
		gl.bindRenderbuffer(GL_RENDERBUFFER, m_depthStencilBuffer);

		if (config.numSamples > 0)
			gl.renderbufferStorageMultisample(GL_RENDERBUFFER, config.numSamples, depthStencilFormat, width, height);
		else
			gl.renderbufferStorage(GL_RENDERBUFFER, depthStencilFormat, width, height);

		gl.bindRenderbuffer(GL_RENDERBUFFER, 0);
		GLU_EXPECT_NO_ERROR(gl.getError(), "Creating depth / stencil renderbuffer");
	}

	gl.genFramebuffers(1, &m_framebuffer);
	gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);

	if (m_colorBuffer)
		gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_colorBuffer);

	if (m_depthStencilBuffer)
	{
		if (depthBits > 0)
			gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer);

		if (stencilBits > 0)
			gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer);
	}

	GLU_EXPECT_NO_ERROR(gl.getError(), "Creating framebuffer");

	if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
		throw tcu::NotSupportedError("Framebuffer is not complete");

	// Set up correct viewport for first test case.
	gl.viewport(0, 0, width, height);

	m_renderTarget = tcu::RenderTarget(width, height, pixelFormat, depthBits, stencilBits, config.numSamples);
}

void FboRenderContext::destroyFramebuffer (void)
{
	const glw::Functions& gl = m_context->getFunctions();

	if (m_framebuffer)
	{
		gl.deleteFramebuffers(1, &m_framebuffer);
		m_framebuffer = 0;
	}

	if (m_depthStencilBuffer)
	{
		gl.deleteRenderbuffers(1, &m_depthStencilBuffer);
		m_depthStencilBuffer = 0;
	}

	if (m_colorBuffer)
	{
		gl.deleteRenderbuffers(1, &m_colorBuffer);
		m_colorBuffer = 0;
	}
}

} // glu