/*-------------------------------------------------------------------------
 * drawElements Quality Program Random Shader Generator
 * ----------------------------------------------------
 *
 * 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 Shader generator.
 *//*--------------------------------------------------------------------*/

#include "rsgShaderGenerator.hpp"
#include "rsgFunctionGenerator.hpp"
#include "rsgToken.hpp"
#include "rsgPrettyPrinter.hpp"
#include "rsgUtils.hpp"
#include "deString.h"

#include <iterator>

using std::string;
using std::vector;

namespace rsg
{

ShaderGenerator::ShaderGenerator (GeneratorState& state)
	: m_state		(state)
	, m_varManager	(state.getNameAllocator())
{
	state.setVariableManager(m_varManager);
}

ShaderGenerator::~ShaderGenerator (void)
{
}

namespace
{

const char* getFragColorName (const GeneratorState& state)
{
	switch (state.getProgramParameters().version)
	{
		case VERSION_100:	return "gl_FragColor";
		case VERSION_300:	return "dEQP_FragColor";
		default:
			DE_ASSERT(DE_FALSE);
			return DE_NULL;
	}
}

void createAssignment (BlockStatement& block, const Variable* dstVar, const Variable* srcVar)
{
	VariableRead* varRead = new VariableRead(srcVar);
	try
	{
		block.addChild(new AssignStatement( dstVar, varRead));
	}
	catch (const std::exception&)
	{
		delete varRead;
		throw;
	}
}

const ValueEntry* findByName (VariableManager& varManager, const char* name)
{
	AnyEntry::Iterator	iter	= varManager.getBegin<AnyEntry>();
	AnyEntry::Iterator	end		= varManager.getEnd<AnyEntry>();
	for (; iter != end; iter++)
	{
		const ValueEntry* entry = *iter;
		if (deStringEqual(entry->getVariable()->getName(), name))
			return entry;
	}
	return DE_NULL;
}

void genVertexPassthrough (GeneratorState& state, Shader& shader)
{
	// Create copies from shader inputs to outputs
	vector<const ValueEntry*> entries;
	std::copy(state.getVariableManager().getBegin<AnyEntry>(), state.getVariableManager().getEnd<AnyEntry>(), std::inserter(entries, entries.begin()));

	for (vector<const ValueEntry*>::const_iterator i = entries.begin(); i != entries.end(); i++)
	{
		const ValueEntry*	entry		= *i;
		const Variable*		outVar		= entry->getVariable();
		std::string			inVarName;

		if (outVar->getStorage() != Variable::STORAGE_SHADER_OUT)
			continue;

		// Name: a_[name], remove v_ -prefix if such exists
		inVarName = "a_";
		if (deStringBeginsWith(outVar->getName(), "v_"))
			inVarName += (outVar->getName()+2);
		else
			inVarName += outVar->getName();

		Variable* inVar = state.getVariableManager().allocate(outVar->getType(), Variable::STORAGE_SHADER_IN, inVarName.c_str());

		// Update value range. This will be stored into shader input info.
		state.getVariableManager().setValue(inVar, entry->getValueRange());

		// Add assignment from input to output into main() body
		createAssignment(shader.getMain().getBody(), entry->getVariable(), inVar);
	}
}

void genFragmentPassthrough (GeneratorState& state, Shader& shader)
{
	// Add simple gl_FragColor = v_color; assignment
	const ValueEntry* fragColorEntry = findByName(state.getVariableManager(), getFragColorName(state));
	TCU_CHECK(fragColorEntry);

	Variable* inColorVariable = state.getVariableManager().allocate(fragColorEntry->getVariable()->getType(), Variable::STORAGE_SHADER_IN, "v_color");

	state.getVariableManager().setValue(inColorVariable, fragColorEntry->getValueRange());
	createAssignment(shader.getMain().getBody(), fragColorEntry->getVariable(), inColorVariable);
}

// Sets undefined (-inf..inf) components to some meaningful values. Used for sanitizing final shader input value ranges.
void fillUndefinedComponents (ValueRangeAccess valueRange)
{
	VariableType::Type baseType = valueRange.getType().getBaseType();
	TCU_CHECK(baseType == VariableType::TYPE_FLOAT	||
			  baseType == VariableType::TYPE_INT	||
			  baseType == VariableType::TYPE_BOOL);

	for (int elemNdx = 0; elemNdx < valueRange.getType().getNumElements(); elemNdx++)
	{
		if (isUndefinedValueRange(valueRange.component(elemNdx)))
		{
			ValueAccess min = valueRange.component(elemNdx).getMin();
			ValueAccess max = valueRange.component(elemNdx).getMax();

			switch (baseType)
			{
				case VariableType::TYPE_FLOAT:	min = 0.0f;		max = 1.0f;		break;
				case VariableType::TYPE_INT:	min = 0;		max = 1;		break;
				case VariableType::TYPE_BOOL:	min = false;	max = true;		break;
				default: DE_ASSERT(DE_FALSE);
			}
		}
	}
}

void fillUndefinedShaderInputs (vector<ShaderInput*>& inputs)
{
	for (vector<ShaderInput*>::iterator i = inputs.begin(); i != inputs.end(); i++)
	{
		if (!(*i)->getVariable()->getType().isSampler()) // Samplers are assigned at program-level.
			fillUndefinedComponents((*i)->getValueRange());
	}
}

} // anonymous

void ShaderGenerator::generate (const ShaderParameters& shaderParams, Shader& shader, const vector<ShaderInput*>& outputs)
{
	// Global scopes
	VariableScope&	globalVariableScope	= shader.getGlobalScope();
	ValueScope		globalValueScope;

	// Init state
	m_state.setShader(shaderParams, shader);
	DE_ASSERT(m_state.getExpressionFlags() == 0);

	// Reserve some scalars for gl_Position & dEQP_Position
	ReservedScalars reservedScalars;
	if (shader.getType() == Shader::TYPE_VERTEX)
		m_state.getVariableManager().reserve(reservedScalars, 4*2);

	// Push global scopes
	m_varManager.pushVariableScope(globalVariableScope);
	m_varManager.pushValueScope(globalValueScope);

	// Init shader outputs.
	{
		for (vector<ShaderInput*>::const_iterator i = outputs.begin(); i != outputs.end(); i++)
		{
			const ShaderInput*	input		= *i;
			Variable*			variable	= m_state.getVariableManager().allocate(input->getVariable()->getType(), Variable::STORAGE_SHADER_OUT, input->getVariable()->getName());

			m_state.getVariableManager().setValue(variable, input->getValueRange());
		}

		if (shader.getType() == Shader::TYPE_FRAGMENT)
		{
			// gl_FragColor
			// \todo [2011-11-22 pyry] Multiple outputs from fragment shader!
			Variable*	fragColorVar	= m_state.getVariableManager().allocate(VariableType(VariableType::TYPE_FLOAT, 4), Variable::STORAGE_SHADER_OUT, getFragColorName(m_state));
			ValueRange	valueRange(fragColorVar->getType());

			valueRange.getMin() = tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f);
			valueRange.getMax() = tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f);

			fragColorVar->setLayoutLocation(0); // Bind color output to location 0 (applies to GLSL ES 3.0 onwards).

			m_state.getVariableManager().setValue(fragColorVar, valueRange);
		}
	}

	// Construct shader code.
	{
		Function& main = shader.getMain();
		main.setReturnType(VariableType(VariableType::TYPE_VOID));

		if (shaderParams.randomize)
		{
			FunctionGenerator funcGen(m_state, main);

			// Mandate assignment into to all shader outputs in main()
			const vector<Variable*>& liveVars = globalVariableScope.getLiveVariables();
			for (vector<Variable*>::const_iterator i = liveVars.begin(); i != liveVars.end(); i++)
			{
				Variable* variable = *i;
				if (variable->getStorage() == Variable::STORAGE_SHADER_OUT)
					funcGen.requireAssignment(variable);
			}

			funcGen.generate();
		}
		else
		{
			if (shader.getType() == Shader::TYPE_VERTEX)
				genVertexPassthrough(m_state, shader);
			else
			{
				DE_ASSERT(shader.getType() == Shader::TYPE_FRAGMENT);
				genFragmentPassthrough(m_state, shader);
			}
		}

		if (shader.getType() == Shader::TYPE_VERTEX)
		{
			// Add gl_Position = dEQP_Position;
			m_state.getVariableManager().release(reservedScalars);

			Variable* glPosVariable = m_state.getVariableManager().allocate(VariableType(VariableType::TYPE_FLOAT, 4), Variable::STORAGE_SHADER_OUT, "gl_Position");
			Variable* qpPosVariable = m_state.getVariableManager().allocate(VariableType(VariableType::TYPE_FLOAT, 4), Variable::STORAGE_SHADER_IN, "dEQP_Position");

			ValueRange valueRange(glPosVariable->getType());

			valueRange.getMin() = tcu::Vec4(-1.0f, -1.0f, 0.0f, 1.0f);
			valueRange.getMax() = tcu::Vec4( 1.0f,  1.0f, 0.0f, 1.0f);

			m_state.getVariableManager().setValue(qpPosVariable, valueRange); // \todo [2011-05-24 pyry] No expression should be able to use gl_Position or dEQP_Position..

			createAssignment(main.getBody(), glPosVariable, qpPosVariable);
		}
	}

	// Declare live global variables.
	{
		vector<Variable*> liveVariables;
		std::copy(globalVariableScope.getLiveVariables().begin(), globalVariableScope.getLiveVariables().end(), std::inserter(liveVariables, liveVariables.begin()));

		vector<Variable*> createDeclarationStatementVars;

		for (vector<Variable*>::iterator i = liveVariables.begin(); i != liveVariables.end(); i++)
		{
			Variable*		variable	= *i;
			const char*		name		= variable->getName();
			bool			declare		= !deStringBeginsWith(name, "gl_"); // Do not declare built-in types.

			// Create input entries (store value range) if necessary
			vector<ShaderInput*>& inputs	= shader.getInputs();
			vector<ShaderInput*>& uniforms	= shader.getUniforms();

			switch (variable->getStorage())
			{
				case Variable::STORAGE_SHADER_IN:
				{
					const ValueEntry* value = m_state.getVariableManager().getValue(variable);

					inputs.reserve(inputs.size()+1);
					inputs.push_back(new ShaderInput(variable, value->getValueRange()));
					break;
				}

				case Variable::STORAGE_UNIFORM:
				{
					const ValueEntry* value = m_state.getVariableManager().getValue(variable);

					uniforms.reserve(uniforms.size()+1);
					uniforms.push_back(new ShaderInput(variable, value->getValueRange()));
					break;
				}

				default:
					break;
			}

			if (declare)
				createDeclarationStatementVars.push_back(variable);
			else
			{
				// Just move to global scope without declaration statement.
				m_state.getVariableManager().declareVariable(variable);
			}
		}

		// All global initializers must be constant expressions, no variable allocation is allowed
		DE_ASSERT(m_state.getExpressionFlags() == 0);
		m_state.pushExpressionFlags(CONST_EXPR|NO_VAR_ALLOCATION);

		// Create declaration statements
		for (vector<Variable*>::iterator i = createDeclarationStatementVars.begin(); i != createDeclarationStatementVars.end(); i++)
		{
			shader.getGlobalStatements().reserve(shader.getGlobalStatements().size());
			shader.getGlobalStatements().push_back(new DeclarationStatement(m_state, *i));
		}

		m_state.popExpressionFlags();
	}

	// Pop global scopes
	m_varManager.popVariableScope();
	m_varManager.popValueScope();

	// Fill undefined (unused) components in inputs with dummy values
	fillUndefinedShaderInputs(shader.getInputs());
	fillUndefinedShaderInputs(shader.getUniforms());

	// Tokenize shader and write source
	{
		TokenStream tokenStr;
		shader.tokenize(m_state, tokenStr);

		std::ostringstream	str;
		PrettyPrinter		printer(str);

		// Append #version if necessary.
		if (m_state.getProgramParameters().version == VERSION_300)
			str << "#version 300 es\n";

		printer.append(tokenStr);
		shader.setSource(str.str().c_str());
	}
}

} // rsg