/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL (ES) Module
 * -----------------------------------------------
 *
 * 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 Utilities for framebuffer objects.
 *//*--------------------------------------------------------------------*/

#include "glsFboUtil.hpp"

#include "glwEnums.hpp"
#include "deUniquePtr.hpp"
#include "gluTextureUtil.hpp"
#include "gluStrUtil.hpp"
#include "deStringUtil.hpp"
#include "deSTLUtil.hpp"
#include <sstream>

using namespace glw;
using tcu::TestLog;
using tcu::TextureFormat;
using tcu::NotSupportedError;
using glu::TransferFormat;
using glu::mapGLInternalFormat;
using glu::mapGLTransferFormat;
using glu::getTextureFormatName;
using glu::getTypeName;
using glu::getFramebufferTargetName;
using glu::getFramebufferAttachmentName;
using glu::getFramebufferAttachmentTypeName;
using glu::getTextureTargetName;
using glu::getTransferFormat;
using glu::ContextInfo;
using glu::ContextType;
using glu::RenderContext;
using de::UniquePtr;
using de::toString;
using std::set;
using std::vector;
using std::string;
using std::istringstream;
using std::istream_iterator;

namespace deqp
{
namespace gls
{

namespace FboUtil
{

#if defined(DE_DEBUG)
static bool isFramebufferStatus (glw::GLenum fboStatus)
{
	return glu::getFramebufferStatusName(fboStatus) != DE_NULL;
}

static bool isErrorCode (glw::GLenum errorCode)
{
	return glu::getErrorName(errorCode) != DE_NULL;
}
#endif

std::ostream& operator<< (std::ostream& stream, const ImageFormat& format)
{
	if (format.unsizedType == GL_NONE)
	{
		// sized format
		return stream << glu::getTextureFormatStr(format.format);
	}
	else
	{
		// unsized format
		return stream << "(format = " << glu::getTextureFormatStr(format.format) << ", type = " << glu::getTypeStr(format.unsizedType) << ")";
	}
}

void FormatDB::addCoreFormat (ImageFormat format, FormatFlags newFlags)
{
	FormatFlags& flags = m_formatFlags[format];
	flags = FormatFlags(flags | newFlags);
}

void FormatDB::addExtensionFormat (ImageFormat format, FormatFlags newFlags, const std::set<std::string>& requiredExtensions)
{
	DE_ASSERT(!requiredExtensions.empty());

	{
		FormatFlags& flags = m_formatFlags[format];
		flags = FormatFlags(flags | newFlags);
	}

	{
		std::set<ExtensionInfo>&	extensionInfo	= m_formatExtensions[format];
		ExtensionInfo				extensionRecord;

		extensionRecord.flags				= newFlags;
		extensionRecord.requiredExtensions	= requiredExtensions;

		DE_ASSERT(!de::contains(extensionInfo, extensionRecord)); // extensions specified only once
		extensionInfo.insert(extensionRecord);
	}
}

// Not too fast at the moment, might consider indexing?
Formats FormatDB::getFormats (FormatFlags requirements) const
{
	Formats ret;
	for (FormatMap::const_iterator it = m_formatFlags.begin(); it != m_formatFlags.end(); it++)
	{
		if ((it->second & requirements) == requirements)
			ret.insert(it->first);
	}
	return ret;
}

bool FormatDB::isKnownFormat (ImageFormat format) const
{
	return de::contains(m_formatFlags, format);
}

FormatFlags FormatDB::getFormatInfo (ImageFormat format) const
{
	DE_ASSERT(de::contains(m_formatFlags, format));
	return de::lookup(m_formatFlags, format);
}

std::set<std::set<std::string> > FormatDB::getFormatFeatureExtensions (ImageFormat format, FormatFlags requirements) const
{
	DE_ASSERT(de::contains(m_formatExtensions, format));

	const std::set<ExtensionInfo>&		extensionInfo	= de::lookup(m_formatExtensions, format);
	std::set<std::set<std::string> >	ret;

	for (std::set<ExtensionInfo>::const_iterator it = extensionInfo.begin(); it != extensionInfo.end(); ++it)
	{
		if ((it->flags & requirements) == requirements)
			ret.insert(it->requiredExtensions);
	}

	return ret;
}

bool FormatDB::ExtensionInfo::operator< (const ExtensionInfo& other) const
{
	return (requiredExtensions < other.requiredExtensions) ||
		   ((requiredExtensions == other.requiredExtensions) && (flags < other.flags));
}

static bool detectGLESCompatibleContext (const RenderContext& ctx, int requiredMajor, int requiredMinor)
{
	const glw::Functions&	gl				= ctx.getFunctions();
	glw::GLint				majorVersion	= 0;
	glw::GLint				minorVersion	= 0;

	// Detect compatible GLES context by querying GL_MAJOR_VERSION.
	// This query does not exist on GLES2 so a failing query implies
	// GLES2 context.

	gl.getIntegerv(GL_MAJOR_VERSION, &majorVersion);
	if (gl.getError() != GL_NO_ERROR)
		majorVersion = 2;

	gl.getIntegerv(GL_MINOR_VERSION, &minorVersion);
	if (gl.getError() != GL_NO_ERROR)
		minorVersion = 0;

	return (majorVersion > requiredMajor) || (majorVersion == requiredMajor && minorVersion >= requiredMinor);
}

static bool checkExtensionSupport (const ContextInfo& ctxInfo, const RenderContext& ctx, const std::string& extension)
{
	if (de::beginsWith(extension, "GL_"))
		return ctxInfo.isExtensionSupported(extension.c_str());
	else if (extension == "DEQP_gles3_core_compatible")
		return detectGLESCompatibleContext(ctx, 3, 0);
	else if (extension == "DEQP_gles31_core_compatible")
		return detectGLESCompatibleContext(ctx, 3, 1);
	else
	{
		DE_ASSERT(false);
		return false;
	}
}

bool checkExtensionSupport (const RenderContext& ctx, const std::string& extension)
{
	const de::UniquePtr<ContextInfo> info(ContextInfo::create(ctx));
	return checkExtensionSupport(*info, ctx, extension);
}

std::string getExtensionDescription (const std::string& extension)
{
	if (de::beginsWith(extension, "GL_"))
		return extension;
	else if (extension == "DEQP_gles3_core_compatible")
		return "GLES3 compatible context";
	else if (extension == "DEQP_gles31_core_compatible")
		return "GLES3.1 compatible context";
	else
	{
		DE_ASSERT(false);
		return "";
	}
}

void addFormats (FormatDB& db, FormatEntries stdFmts)
{
	for (const FormatEntry* it = stdFmts.begin(); it != stdFmts.end(); it++)
	{
		for (const FormatKey* it2 = it->second.begin(); it2 != it->second.end(); it2++)
			db.addCoreFormat(formatKeyInfo(*it2), it->first);
	}
}

void addExtFormats (FormatDB& db, FormatExtEntries extFmts, const RenderContext* ctx)
{
	const UniquePtr<ContextInfo> ctxInfo(ctx != DE_NULL ? ContextInfo::create(*ctx) : DE_NULL);
	for (const FormatExtEntry* entryIt = extFmts.begin(); entryIt != extFmts.end(); entryIt++)
	{
		bool					supported			= true;
		std::set<std::string>	requiredExtensions;

		// parse required extensions
		{
			istringstream tokenStream(string(entryIt->extensions));
			istream_iterator<string> tokens((tokenStream)), end;

			while (tokens != end)
			{
				requiredExtensions.insert(*tokens);
				++tokens;
			}
		}

		// check support
		if (ctxInfo)
		{
			for (std::set<std::string>::const_iterator extIt = requiredExtensions.begin(); extIt != requiredExtensions.end(); ++extIt)
			{
				if (!checkExtensionSupport(*ctxInfo, *ctx, *extIt))
				{
					supported = false;
					break;
				}
			}
		}

		if (supported)
			for (const FormatKey* i2 = entryIt->formats.begin(); i2 != entryIt->formats.end(); i2++)
				db.addExtensionFormat(formatKeyInfo(*i2), FormatFlags(entryIt->flags), requiredExtensions);
	}
}

FormatFlags formatFlag (GLenum context)
{
	switch (context)
	{
		case GL_NONE:
			return FormatFlags(0);
		case GL_RENDERBUFFER:
			return RENDERBUFFER_VALID;
		case GL_TEXTURE:
			return TEXTURE_VALID;
		case GL_STENCIL_ATTACHMENT:
			return STENCIL_RENDERABLE;
		case GL_DEPTH_ATTACHMENT:
			return DEPTH_RENDERABLE;
		default:
			DE_ASSERT(context >= GL_COLOR_ATTACHMENT0 && context <= GL_COLOR_ATTACHMENT15);
			return COLOR_RENDERABLE;
	}
}

static FormatFlags getAttachmentRenderabilityFlag (GLenum attachment)
{
	switch (attachment)
	{
		case GL_STENCIL_ATTACHMENT:			return STENCIL_RENDERABLE;
		case GL_DEPTH_ATTACHMENT:			return DEPTH_RENDERABLE;

		default:
			DE_ASSERT(attachment >= GL_COLOR_ATTACHMENT0 && attachment <= GL_COLOR_ATTACHMENT15);
			return COLOR_RENDERABLE;
	}
}

namespace config {

GLsizei	imageNumSamples	(const Image& img)
{
	if (const Renderbuffer* rbo = dynamic_cast<const Renderbuffer*>(&img))
		return rbo->numSamples;
	return 0;
}

static GLenum glTarget (const Image& img)
{
	if (dynamic_cast<const Renderbuffer*>(&img) != DE_NULL)
		return GL_RENDERBUFFER;
	if (dynamic_cast<const Texture2D*>(&img) != DE_NULL)
		return GL_TEXTURE_2D;
	if (dynamic_cast<const TextureCubeMap*>(&img) != DE_NULL)
		return GL_TEXTURE_CUBE_MAP;
	if (dynamic_cast<const Texture3D*>(&img) != DE_NULL)
		return GL_TEXTURE_3D;
	if (dynamic_cast<const Texture2DArray*>(&img) != DE_NULL)
		return GL_TEXTURE_2D_ARRAY;

	DE_FATAL("Impossible image type");
	return GL_NONE;
}

static void glInitFlat (const TextureFlat& cfg, GLenum target, const glw::Functions& gl)
{
	const TransferFormat format = transferImageFormat(cfg.internalFormat);
	GLint w = cfg.width;
	GLint h = cfg.height;
	for (GLint level = 0; level < cfg.numLevels; level++)
	{
		gl.texImage2D(target, level, cfg.internalFormat.format, w, h, 0,
					  format.format, format.dataType, DE_NULL);
		w = de::max(1, w / 2);
		h = de::max(1, h / 2);
	}
}

static void glInitLayered (const TextureLayered& cfg,
						   GLint depth_divider, const glw::Functions& gl)
{
	const TransferFormat format = transferImageFormat(cfg.internalFormat);
	GLint w = cfg.width;
	GLint h = cfg.height;
	GLint depth = cfg.numLayers;
	for (GLint level = 0; level < cfg.numLevels; level++)
	{
		gl.texImage3D(glTarget(cfg), level, cfg.internalFormat.format, w, h, depth, 0,
					  format.format, format.dataType, DE_NULL);
		w = de::max(1, w / 2);
		h = de::max(1, h / 2);
		depth = de::max(1, depth / depth_divider);
	}
}

static void glInit (const Texture& cfg, const glw::Functions& gl)
{
	if (const Texture2D* t2d = dynamic_cast<const Texture2D*>(&cfg))
		glInitFlat(*t2d, glTarget(*t2d), gl);
	else if (const TextureCubeMap* tcm = dynamic_cast<const TextureCubeMap*>(&cfg))
	{
		// \todo [2013-12-05 lauri]
		// move this to glu or someplace sensible (this array is already
		// present in duplicates)
		static const GLenum s_cubeMapFaces[] =
			{
				GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
				GL_TEXTURE_CUBE_MAP_POSITIVE_X,
				GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
				GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
				GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
				GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
			};
		const Range<GLenum> range = GLS_ARRAY_RANGE(s_cubeMapFaces);
		for (const GLenum* it = range.begin(); it != range.end(); it++)
			glInitFlat(*tcm, *it, gl);
	}
	else if (const Texture3D* t3d = dynamic_cast<const Texture3D*>(&cfg))
		glInitLayered(*t3d, 2, gl);
	else if (const Texture2DArray* t2a = dynamic_cast<const Texture2DArray*>(&cfg))
		glInitLayered(*t2a, 1, gl);
}

static GLuint glCreate (const Image& cfg, const glw::Functions& gl)
{
	GLuint ret = 0;
	if (const Renderbuffer* const rbo = dynamic_cast<const Renderbuffer*>(&cfg))
	{
		gl.genRenderbuffers(1, &ret);
		gl.bindRenderbuffer(GL_RENDERBUFFER, ret);

		if (rbo->numSamples == 0)
			gl.renderbufferStorage(GL_RENDERBUFFER, rbo->internalFormat.format,
								   rbo->width, rbo->height);
		else
			gl.renderbufferStorageMultisample(
				GL_RENDERBUFFER, rbo->numSamples, rbo->internalFormat.format,
				rbo->width, rbo->height);

		gl.bindRenderbuffer(GL_RENDERBUFFER, 0);
	}
	else if (const Texture* const tex = dynamic_cast<const Texture*>(&cfg))
	{
		gl.genTextures(1, &ret);
		gl.bindTexture(glTarget(*tex), ret);
		glInit(*tex, gl);
		gl.bindTexture(glTarget(*tex), 0);
	}
	else
		DE_FATAL("Impossible image type");
	return ret;
}

static void glDelete (const Image& cfg, GLuint img, const glw::Functions& gl)
{
	if (dynamic_cast<const Renderbuffer*>(&cfg) != DE_NULL)
		gl.deleteRenderbuffers(1, &img);
	else if (dynamic_cast<const Texture*>(&cfg) != DE_NULL)
		gl.deleteTextures(1, &img);
	else
		DE_FATAL("Impossible image type");
}

static void attachAttachment (const Attachment& att, GLenum attPoint,
							  const glw::Functions& gl)
{
	if (const RenderbufferAttachment* const rAtt =
		dynamic_cast<const RenderbufferAttachment*>(&att))
		gl.framebufferRenderbuffer(rAtt->target, attPoint,
								   rAtt->renderbufferTarget, rAtt->imageName);
	else if (const TextureFlatAttachment* const fAtt =
			 dynamic_cast<const TextureFlatAttachment*>(&att))
		gl.framebufferTexture2D(fAtt->target, attPoint,
								fAtt->texTarget, fAtt->imageName, fAtt->level);
	else if (const TextureLayerAttachment* const lAtt =
			 dynamic_cast<const TextureLayerAttachment*>(&att))
		gl.framebufferTextureLayer(lAtt->target, attPoint,
								   lAtt->imageName, lAtt->level, lAtt->layer);
	else
		DE_FATAL("Impossible attachment type");
}

GLenum attachmentType (const Attachment& att)
{
	if (dynamic_cast<const RenderbufferAttachment*>(&att) != DE_NULL)
		return GL_RENDERBUFFER;
	else if (dynamic_cast<const TextureAttachment*>(&att) != DE_NULL)
		return GL_TEXTURE;

	DE_FATAL("Impossible attachment type");
	return GL_NONE;
}

static GLsizei textureLayer (const TextureAttachment& tAtt)
{
	if (dynamic_cast<const TextureFlatAttachment*>(&tAtt) != DE_NULL)
		return 0;
	else if (const TextureLayerAttachment* const lAtt =
			 dynamic_cast<const TextureLayerAttachment*>(&tAtt))
		return lAtt->layer;

	DE_FATAL("Impossible attachment type");
	return 0;
}

static void checkAttachmentCompleteness (Checker& cctx, const Attachment& attachment,
										 GLenum attPoint, const Image* image,
										 const FormatDB& db)
{
	// GLES2 4.4.5 / GLES3 4.4.4, "Framebuffer attachment completeness"

	if (const TextureAttachment* const texAtt =
		dynamic_cast<const TextureAttachment*>(&attachment))
		if (const TextureLayered* const ltex = dynamic_cast<const TextureLayered*>(image))
		{
			// GLES3: "If the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is
			// TEXTURE and the value of FRAMEBUFFER_ATTACHMENT_OBJECT_NAME names a
			// three-dimensional texture, then the value of
			// FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER must be smaller than the depth
			// of the texture.
			//
			// GLES3: "If the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is
			// TEXTURE and the value of FRAMEBUFFER_ATTACHMENT_OBJECT_NAME names a
			// two-dimensional array texture, then the value of
			// FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER must be smaller than the
			// number of layers in the texture.

			if (textureLayer(*texAtt) >= ltex->numLayers)
				cctx.addFBOStatus(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT, "Attached layer index is larger than present");
		}

	// "The width and height of image are non-zero."
	if (image->width == 0 || image->height == 0)
		cctx.addFBOStatus(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT, "Width and height of an image are not non-zero");

	// Check for renderability
	if (db.isKnownFormat(image->internalFormat))
	{
		const FormatFlags flags = db.getFormatInfo(image->internalFormat);

		// If the format does not have the proper renderability flag, the
		// completeness check _must_ fail.
		if ((flags & getAttachmentRenderabilityFlag(attPoint)) == 0)
			cctx.addFBOStatus(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT, "Attachment format is not renderable in this attachment");
		// If the format is only optionally renderable, the completeness check _can_ fail.
		else if ((flags & REQUIRED_RENDERABLE) == 0)
			cctx.addPotentialFBOStatus(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT, "Attachment format is not required renderable");
	}
	else
		cctx.addFBOStatus(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT, "Attachment format is not legal");
}

} // namespace config

using namespace config;

Checker::Checker (const glu::RenderContext& ctx, const FormatDB& formats)
	: m_renderCtx(ctx), m_formats(formats)
{
	m_statusCodes.setAllowComplete(true);
}

void Checker::addGLError (glw::GLenum error, const char* description)
{
	m_statusCodes.addErrorCode(error, description);
	m_statusCodes.setAllowComplete(false);
}

void Checker::addPotentialGLError (glw::GLenum error, const char* description)
{
	m_statusCodes.addErrorCode(error, description);
}

void Checker::addFBOStatus (GLenum status, const char* description)
{
	m_statusCodes.addFBOErrorStatus(status, description);
	m_statusCodes.setAllowComplete(false);
}

void Checker::addPotentialFBOStatus (GLenum status, const char* description)
{
	m_statusCodes.addFBOErrorStatus(status, description);
}

FboVerifier::FboVerifier (const FormatDB& formats, CheckerFactory& factory, const glu::RenderContext& renderCtx)
	: m_formats		(formats)
	, m_factory		(factory)
	, m_renderCtx	(renderCtx)
{
}

/*--------------------------------------------------------------------*//*!
 * \brief Return acceptable framebuffer status codes.
 *
 * This function examines the framebuffer configuration descriptor `fboConfig`
 * and returns the set of status codes that `glCheckFramebufferStatus` is
 * allowed to return on a conforming implementation when given a framebuffer
 * whose configuration adheres to `fboConfig`.
 *
 * The returned set is guaranteed to be non-empty, but it may contain multiple
 * INCOMPLETE statuses (if there are multiple errors in the spec), or or a mix
 * of COMPLETE and INCOMPLETE statuses (if supporting a FBO with this spec is
 * optional). Furthermore, the statuses may contain GL error codes, which
 * indicate that trying to create a framebuffer configuration like this could
 * have failed with an error (if one was checked for) even before
 * `glCheckFramebufferStatus` was ever called.
 *
 *//*--------------------------------------------------------------------*/
ValidStatusCodes FboVerifier::validStatusCodes (const Framebuffer& fboConfig) const
{
	const AttachmentMap& atts = fboConfig.attachments;
	const UniquePtr<Checker> cctx(m_factory.createChecker(m_renderCtx, m_formats));

	for (TextureMap::const_iterator it = fboConfig.textures.begin();
		 it != fboConfig.textures.end(); it++)
	{
		std::string errorDescription;

		if (m_formats.isKnownFormat(it->second->internalFormat))
		{
			const FormatFlags flags = m_formats.getFormatInfo(it->second->internalFormat);

			if ((flags & TEXTURE_VALID) == 0)
				errorDescription = "Format " + de::toString(it->second->internalFormat) + " is not a valid format for a texture";
		}
		else if (it->second->internalFormat.unsizedType == GL_NONE)
		{
			// sized format
			errorDescription = "Format " + de::toString(it->second->internalFormat) + " does not exist";
		}
		else
		{
			// unsized type-format pair
			errorDescription = "Format " + de::toString(it->second->internalFormat) + " is not a legal format";
		}

		if (!errorDescription.empty())
		{
			cctx->addGLError(GL_INVALID_ENUM,		errorDescription.c_str());
			cctx->addGLError(GL_INVALID_OPERATION,	errorDescription.c_str());
			cctx->addGLError(GL_INVALID_VALUE,		errorDescription.c_str());
		}
	}

	for (RboMap::const_iterator it = fboConfig.rbos.begin(); it != fboConfig.rbos.end(); it++)
	{
		if (m_formats.isKnownFormat(it->second->internalFormat))
		{
			const FormatFlags flags = m_formats.getFormatInfo(it->second->internalFormat);
			if ((flags & RENDERBUFFER_VALID) == 0)
			{
				const std::string reason = "Format " + de::toString(it->second->internalFormat) + " is not a valid format for a renderbuffer";
				cctx->addGLError(GL_INVALID_ENUM, reason.c_str());
			}
		}
		else
		{
			const std::string reason = "Internal format " + de::toString(it->second->internalFormat) + " does not exist";
			cctx->addGLError(GL_INVALID_ENUM, reason.c_str());
		}
	}

	// "There is at least one image attached to the framebuffer."
	// \todo support XXX_framebuffer_no_attachments
	if (atts.empty())
		cctx->addFBOStatus(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT, "No images attached to the framebuffer");

	for (AttachmentMap::const_iterator it = atts.begin(); it != atts.end(); it++)
	{
		const GLenum attPoint = it->first;
		const Attachment& att = *it->second;
		const Image* const image = fboConfig.getImage(attachmentType(att), att.imageName);

		checkAttachmentCompleteness(*cctx, att, attPoint, image, m_formats);
		cctx->check(it->first, *it->second, image);
	}

	return cctx->getStatusCodes();
}


void Framebuffer::attach (glw::GLenum attPoint, const Attachment* att)
{
	if (att == DE_NULL)
		attachments.erase(attPoint);
	else
		attachments[attPoint] = att;
}

const Image* Framebuffer::getImage (GLenum type, glw::GLuint imgName) const
{
	switch (type)
	{
		case GL_TEXTURE:
			return de::lookupDefault(textures, imgName, DE_NULL);
		case GL_RENDERBUFFER:
			return de::lookupDefault(rbos, imgName, DE_NULL);
		default:
			DE_FATAL("Bad image type");
	}
	return DE_NULL; // shut up compiler warning
}

void Framebuffer::setTexture (glw::GLuint texName, const Texture& texCfg)
{
	textures[texName] = &texCfg;
}

void Framebuffer::setRbo (glw::GLuint rbName, const Renderbuffer& rbCfg)
{
	rbos[rbName] = &rbCfg;
}

static void logField (TestLog& log, const string& field, const string& value)
{
	log << TestLog::Message << field << ": " << value << TestLog::EndMessage;
}

static void logImage (const Image& img, TestLog& log, bool useType)
{
	const GLenum type = img.internalFormat.unsizedType;
	logField(log, "Internal format",	getTextureFormatName(img.internalFormat.format));
	if (useType && type != GL_NONE)
		logField(log, "Format type",	getTypeName(type));
	logField(log, "Width",				toString(img.width));
	logField(log, "Height",				toString(img.height));
}

static void logRenderbuffer (const Renderbuffer& rbo, TestLog& log)
{
	logImage(rbo, log, false);
	logField(log, "Samples",			toString(rbo.numSamples));
}

static void logTexture (const Texture& tex, TestLog& log)
{
	logField(log, "Type",				glu::getTextureTargetName(glTarget(tex)));
	logImage(tex, log, true);
	logField(log, "Levels",				toString(tex.numLevels));
	if (const TextureLayered* const lTex = dynamic_cast<const TextureLayered*>(&tex))
		logField(log, "Layers",				toString(lTex->numLayers));
}

static void logAttachment (const Attachment& att, TestLog& log)
{
	logField(log, "Target",				getFramebufferTargetName(att.target));
	logField(log, "Type",				getFramebufferAttachmentTypeName(attachmentType(att)));
	logField(log, "Image Name",			toString(att.imageName));
	if (const RenderbufferAttachment* const rAtt
		= dynamic_cast<const RenderbufferAttachment*>(&att))
	{
		DE_UNREF(rAtt); // To shut up compiler during optimized builds.
		DE_ASSERT(rAtt->renderbufferTarget == GL_RENDERBUFFER);
		logField(log, "Renderbuffer Target",	"GL_RENDERBUFFER");
	}
	else if (const TextureAttachment* const tAtt = dynamic_cast<const TextureAttachment*>(&att))
	{
		logField(log, "Mipmap Level",		toString(tAtt->level));
		if (const TextureFlatAttachment* const fAtt =
			dynamic_cast<const TextureFlatAttachment*>(tAtt))
			logField(log, "Texture Target",		getTextureTargetName(fAtt->texTarget));
		else if (const TextureLayerAttachment* const lAtt =
			dynamic_cast<const TextureLayerAttachment*>(tAtt))
			logField(log, "Layer",				toString(lAtt->level));
	}
}

void logFramebufferConfig (const Framebuffer& cfg, TestLog& log)
{
	log << TestLog::Section("Framebuffer", "Framebuffer configuration");

	for (RboMap::const_iterator it = cfg.rbos.begin(); it != cfg.rbos.end(); ++it)
	{
		const string				num			= toString(it->first);
		const tcu::ScopedLogSection	subsection	(log, num, "Renderbuffer " + num);

		logRenderbuffer(*it->second, log);
	}

	for (TextureMap::const_iterator it = cfg.textures.begin();
		it != cfg.textures.end(); ++it)
	{
		const string				num			= toString(it->first);
		const tcu::ScopedLogSection	subsection	(log, num, "Texture " + num);

		logTexture(*it->second, log);
	}

	const string attDesc = cfg.attachments.empty()
		? "Framebuffer has no attachments"
		: "Framebuffer attachments";
	log << TestLog::Section("Attachments", attDesc);
	for (AttachmentMap::const_iterator it = cfg.attachments.begin();
		 it != cfg.attachments.end(); it++)
	{
		const string attPointName = getFramebufferAttachmentName(it->first);
		log << TestLog::Section(attPointName, "Attachment point " + attPointName);
		logAttachment(*it->second, log);
		log << TestLog::EndSection;
	}
	log << TestLog::EndSection; // Attachments

	log << TestLog::EndSection; // Framebuffer
}

ValidStatusCodes::ValidStatusCodes (void)
	: m_allowComplete(false)
{
}

bool ValidStatusCodes::isFBOStatusValid (glw::GLenum fboStatus) const
{
	if (fboStatus == GL_FRAMEBUFFER_COMPLETE)
		return m_allowComplete;
	else
	{
		// rule violation exists?
		for (int ndx = 0; ndx < (int)m_errorStatuses.size(); ++ndx)
		{
			if (m_errorStatuses[ndx].errorCode == fboStatus)
				return true;
		}
		return false;
	}
}

bool ValidStatusCodes::isFBOStatusRequired (glw::GLenum fboStatus) const
{
	if (fboStatus == GL_FRAMEBUFFER_COMPLETE)
		return m_allowComplete && m_errorStatuses.empty();
	else
		// fboStatus is the only allowed error status and succeeding is forbidden
		return !m_allowComplete && m_errorStatuses.size() == 1 && m_errorStatuses.front().errorCode == fboStatus;
}

bool ValidStatusCodes::isErrorCodeValid (glw::GLenum errorCode) const
{
	if (errorCode == GL_NO_ERROR)
		return m_errorCodes.empty();
	else
	{
		// rule violation exists?
		for (int ndx = 0; ndx < (int)m_errorCodes.size(); ++ndx)
		{
			if (m_errorCodes[ndx].errorCode == errorCode)
				return true;
		}
		return false;
	}
}

bool ValidStatusCodes::isErrorCodeRequired (glw::GLenum errorCode) const
{
	if (m_errorCodes.empty() && errorCode == GL_NO_ERROR)
		return true;
	else
		// only this error code listed
		return m_errorCodes.size() == 1 && m_errorCodes.front().errorCode == errorCode;
}

void ValidStatusCodes::addErrorCode (glw::GLenum error, const char* description)
{
	DE_ASSERT(isErrorCode(error));
	DE_ASSERT(error != GL_NO_ERROR);
	addViolation(m_errorCodes, error, description);
}

void ValidStatusCodes::addFBOErrorStatus (glw::GLenum status, const char* description)
{
	DE_ASSERT(isFramebufferStatus(status));
	DE_ASSERT(status != GL_FRAMEBUFFER_COMPLETE);
	addViolation(m_errorStatuses, status, description);
}

void ValidStatusCodes::setAllowComplete (bool b)
{
	m_allowComplete = b;
}

void ValidStatusCodes::logLegalResults (tcu::TestLog& log) const
{
	tcu::MessageBuilder			msg				(&log);
	std::vector<std::string>	validResults;

	for (int ndx = 0; ndx < (int)m_errorCodes.size(); ++ndx)
		validResults.push_back(std::string(glu::getErrorName(m_errorCodes[ndx].errorCode)) + " (during FBO initialization)");

	for (int ndx = 0; ndx < (int)m_errorStatuses.size(); ++ndx)
		validResults.push_back(glu::getFramebufferStatusName(m_errorStatuses[ndx].errorCode));

	if (m_allowComplete)
		validResults.push_back("GL_FRAMEBUFFER_COMPLETE");

	msg << "Expected ";
	if (validResults.size() > 1)
		msg << "one of ";

	for (int ndx = 0; ndx < (int)validResults.size(); ++ndx)
	{
		const bool last			= ((ndx + 1) == (int)validResults.size());
		const bool secondToLast	= ((ndx + 2) == (int)validResults.size());

		msg << validResults[ndx];
		if (!last)
			msg << ((secondToLast) ? (" or ") : (", "));
	}

	msg << "." << TestLog::EndMessage;
}

void ValidStatusCodes::logRules (tcu::TestLog& log) const
{
	const tcu::ScopedLogSection section(log, "Rules", "Active rules");

	for (int ndx = 0; ndx < (int)m_errorCodes.size(); ++ndx)
		logRule(log, glu::getErrorName(m_errorCodes[ndx].errorCode), m_errorCodes[ndx].rules);

	for (int ndx = 0; ndx < (int)m_errorStatuses.size(); ++ndx)
		logRule(log, glu::getFramebufferStatusName(m_errorStatuses[ndx].errorCode), m_errorStatuses[ndx].rules);

	if (m_allowComplete)
	{
		std::set<std::string> defaultRule;
		defaultRule.insert("FBO is complete");
		logRule(log, "GL_FRAMEBUFFER_COMPLETE", defaultRule);
	}
}

void ValidStatusCodes::logRule (tcu::TestLog& log, const std::string& ruleName, const std::set<std::string>& rules) const
{
	if (!rules.empty())
	{
		const tcu::ScopedLogSection		section	(log, ruleName, ruleName);
		tcu::MessageBuilder				msg		(&log);

		msg << "Rules:\n";
		for (std::set<std::string>::const_iterator it = rules.begin(); it != rules.end(); ++it)
			msg << "\t * " << *it << "\n";
		msg << TestLog::EndMessage;
	}
}

void ValidStatusCodes::addViolation (std::vector<RuleViolation>& dst, glw::GLenum code, const char* description) const
{
	// rule violation already exists?
	for (int ndx = 0; ndx < (int)dst.size(); ++ndx)
	{
		if (dst[ndx].errorCode == code)
		{
			dst[ndx].rules.insert(std::string(description));
			return;
		}
	}

	// new violation
	{
		RuleViolation violation;

		violation.errorCode = code;
		violation.rules.insert(std::string(description));

		dst.push_back(violation);
	}
}

FboBuilder::FboBuilder (GLuint fbo, GLenum target, const glw::Functions& gl)
	: m_error	(GL_NO_ERROR)
	, m_target	(target)
	, m_gl		(gl)
{
	m_gl.bindFramebuffer(m_target, fbo);
}

FboBuilder::~FboBuilder (void)
{
	for (TextureMap::const_iterator it = textures.begin(); it != textures.end(); it++)
	{
		glDelete(*it->second, it->first, m_gl);
	}
	for (RboMap::const_iterator it = rbos.begin(); it != rbos.end(); it++)
	{
		glDelete(*it->second, it->first, m_gl);
	}
	m_gl.bindFramebuffer(m_target, 0);
	for (Configs::const_iterator it = m_configs.begin(); it != m_configs.end(); it++)
	{
		delete *it;
	}
}

void FboBuilder::checkError (void)
{
	const GLenum error = m_gl.getError();
	if (error != GL_NO_ERROR && m_error == GL_NO_ERROR)
		m_error = error;
}

void FboBuilder::glAttach (GLenum attPoint, const Attachment* att)
{
	if (att == NULL)
		m_gl.framebufferRenderbuffer(m_target, attPoint, GL_RENDERBUFFER, 0);
	else
		attachAttachment(*att, attPoint, m_gl);
	checkError();
	attach(attPoint, att);
}

GLuint FboBuilder::glCreateTexture (const Texture& texCfg)
{
	const GLuint texName = glCreate(texCfg, m_gl);
	checkError();
	setTexture(texName, texCfg);
	return texName;
}

GLuint FboBuilder::glCreateRbo (const Renderbuffer& rbCfg)
{
	const GLuint rbName = glCreate(rbCfg, m_gl);
	checkError();
	setRbo(rbName, rbCfg);
	return rbName;
}

TransferFormat transferImageFormat (const ImageFormat& imgFormat)
{
	if (imgFormat.unsizedType == GL_NONE)
		return getTransferFormat(mapGLInternalFormat(imgFormat.format));
	else
		return TransferFormat(imgFormat.format, imgFormat.unsizedType);
}

} // FboUtil
} // gls
} // deqp