#include "ShaderProgramCompiler.h"

#include "GlRenderConstants.h"
#include "GlScopedObjects.h"
#include "GlShaderSources.h"

#include <cstring>
#include <vector>

namespace
{
void CopyErrorMessage(const std::string& message, int errorMessageSize, char* errorMessage)
{
	if (!errorMessage || errorMessageSize <= 0)
		return;

	strncpy_s(errorMessage, errorMessageSize, message.c_str(), _TRUNCATE);
}
}

ShaderProgramCompiler::ShaderProgramCompiler(OpenGLRenderer& renderer, RuntimeHost& runtimeHost, ShaderTextureBindings& textureBindings) :
	mRenderer(renderer),
	mRuntimeHost(runtimeHost),
	mTextureBindings(textureBindings)
{
}

bool ShaderProgramCompiler::CompileLayerProgram(const RuntimeRenderState& state, LayerProgram& layerProgram, int errorMessageSize, char* errorMessage)
{
	GLsizei errorBufferSize = 0;
	GLint compileResult = GL_FALSE;
	GLint linkResult = GL_FALSE;
	std::string fragmentShaderSource;
	std::string loadError;
	std::vector<LayerProgram::TextureBinding> textureBindings;
	const char* vertexSource = kFullscreenTriangleVertexShaderSource;

	if (!mRuntimeHost.BuildLayerFragmentShaderSource(state.layerId, fragmentShaderSource, loadError))
	{
		CopyErrorMessage(loadError, errorMessageSize, errorMessage);
		return false;
	}

	const char* fragmentSource = fragmentShaderSource.c_str();

	ScopedGlShader newVertexShader(glCreateShader(GL_VERTEX_SHADER));
	glShaderSource(newVertexShader.get(), 1, (const GLchar**)&vertexSource, NULL);
	glCompileShader(newVertexShader.get());
	glGetShaderiv(newVertexShader.get(), GL_COMPILE_STATUS, &compileResult);
	if (compileResult == GL_FALSE)
	{
		glGetShaderInfoLog(newVertexShader.get(), errorMessageSize, &errorBufferSize, errorMessage);
		return false;
	}

	ScopedGlShader newFragmentShader(glCreateShader(GL_FRAGMENT_SHADER));
	glShaderSource(newFragmentShader.get(), 1, (const GLchar**)&fragmentSource, NULL);
	glCompileShader(newFragmentShader.get());
	glGetShaderiv(newFragmentShader.get(), GL_COMPILE_STATUS, &compileResult);
	if (compileResult == GL_FALSE)
	{
		glGetShaderInfoLog(newFragmentShader.get(), errorMessageSize, &errorBufferSize, errorMessage);
		return false;
	}

	ScopedGlProgram newProgram(glCreateProgram());
	glAttachShader(newProgram.get(), newVertexShader.get());
	glAttachShader(newProgram.get(), newFragmentShader.get());
	glLinkProgram(newProgram.get());
	glGetProgramiv(newProgram.get(), GL_LINK_STATUS, &linkResult);
	if (linkResult == GL_FALSE)
	{
		glGetProgramInfoLog(newProgram.get(), errorMessageSize, &errorBufferSize, errorMessage);
		return false;
	}

	for (const ShaderTextureAsset& textureAsset : state.textureAssets)
	{
		LayerProgram::TextureBinding textureBinding;
		textureBinding.samplerName = textureAsset.id;
		textureBinding.sourcePath = textureAsset.path;
		if (!mTextureBindings.LoadTextureAsset(textureAsset, textureBinding.texture, loadError))
		{
			for (LayerProgram::TextureBinding& loadedTexture : textureBindings)
			{
				if (loadedTexture.texture != 0)
					glDeleteTextures(1, &loadedTexture.texture);
			}
			CopyErrorMessage(loadError, errorMessageSize, errorMessage);
			return false;
		}
		textureBindings.push_back(textureBinding);
	}

	std::vector<LayerProgram::TextBinding> textBindings;
	mTextureBindings.CreateTextBindings(state, textBindings);

	const GLuint globalParamsIndex = glGetUniformBlockIndex(newProgram.get(), "GlobalParams");
	if (globalParamsIndex != GL_INVALID_INDEX)
		glUniformBlockBinding(newProgram.get(), globalParamsIndex, kGlobalParamsBindingPoint);

	const unsigned historyCap = mRuntimeHost.GetMaxTemporalHistoryFrames();
	const GLuint shaderTextureBase = state.isTemporal ? kSourceHistoryTextureUnitBase + historyCap + historyCap : kSourceHistoryTextureUnitBase;
	glUseProgram(newProgram.get());
	const GLint videoInputLocation = glGetUniformLocation(newProgram.get(), "gVideoInput");
	if (videoInputLocation >= 0)
		glUniform1i(videoInputLocation, static_cast<GLint>(kDecodedVideoTextureUnit));
	for (unsigned index = 0; index < historyCap; ++index)
	{
		const std::string sourceSamplerName = "gSourceHistory" + std::to_string(index);
		const GLint sourceSamplerLocation = glGetUniformLocation(newProgram.get(), sourceSamplerName.c_str());
		if (sourceSamplerLocation >= 0)
			glUniform1i(sourceSamplerLocation, static_cast<GLint>(kSourceHistoryTextureUnitBase + index));

		const std::string temporalSamplerName = "gTemporalHistory" + std::to_string(index);
		const GLint temporalSamplerLocation = glGetUniformLocation(newProgram.get(), temporalSamplerName.c_str());
		if (temporalSamplerLocation >= 0)
			glUniform1i(temporalSamplerLocation, static_cast<GLint>(kSourceHistoryTextureUnitBase + historyCap + index));
	}
	for (std::size_t index = 0; index < textureBindings.size(); ++index)
	{
		const GLint textureSamplerLocation = mTextureBindings.FindSamplerUniformLocation(newProgram.get(), textureBindings[index].samplerName);
		if (textureSamplerLocation >= 0)
			glUniform1i(textureSamplerLocation, static_cast<GLint>(shaderTextureBase + static_cast<GLuint>(index)));
	}
	const GLuint textTextureBase = shaderTextureBase + static_cast<GLuint>(textureBindings.size());
	for (std::size_t index = 0; index < textBindings.size(); ++index)
	{
		const GLint textSamplerLocation = mTextureBindings.FindSamplerUniformLocation(newProgram.get(), textBindings[index].samplerName);
		if (textSamplerLocation >= 0)
			glUniform1i(textSamplerLocation, static_cast<GLint>(textTextureBase + static_cast<GLuint>(index)));
	}
	glUseProgram(0);

	layerProgram.layerId = state.layerId;
	layerProgram.shaderId = state.shaderId;
	layerProgram.shaderTextureBase = shaderTextureBase;
	layerProgram.program = newProgram.release();
	layerProgram.vertexShader = newVertexShader.release();
	layerProgram.fragmentShader = newFragmentShader.release();
	layerProgram.textureBindings.swap(textureBindings);
	layerProgram.textBindings.swap(textBindings);
	return true;
}

bool ShaderProgramCompiler::CompileDecodeShader(int errorMessageSize, char* errorMessage)
{
	GLsizei errorBufferSize = 0;
	GLint compileResult = GL_FALSE;
	GLint linkResult = GL_FALSE;
	const char* vertexSource = kFullscreenTriangleVertexShaderSource;
	const char* fragmentSource = kDecodeFragmentShaderSource;

	ScopedGlShader newVertexShader(glCreateShader(GL_VERTEX_SHADER));
	glShaderSource(newVertexShader.get(), 1, (const GLchar**)&vertexSource, NULL);
	glCompileShader(newVertexShader.get());
	glGetShaderiv(newVertexShader.get(), GL_COMPILE_STATUS, &compileResult);
	if (compileResult == GL_FALSE)
	{
		glGetShaderInfoLog(newVertexShader.get(), errorMessageSize, &errorBufferSize, errorMessage);
		return false;
	}

	ScopedGlShader newFragmentShader(glCreateShader(GL_FRAGMENT_SHADER));
	glShaderSource(newFragmentShader.get(), 1, (const GLchar**)&fragmentSource, NULL);
	glCompileShader(newFragmentShader.get());
	glGetShaderiv(newFragmentShader.get(), GL_COMPILE_STATUS, &compileResult);
	if (compileResult == GL_FALSE)
	{
		glGetShaderInfoLog(newFragmentShader.get(), errorMessageSize, &errorBufferSize, errorMessage);
		return false;
	}

	ScopedGlProgram newProgram(glCreateProgram());
	glAttachShader(newProgram.get(), newVertexShader.get());
	glAttachShader(newProgram.get(), newFragmentShader.get());
	glLinkProgram(newProgram.get());
	glGetProgramiv(newProgram.get(), GL_LINK_STATUS, &linkResult);
	if (linkResult == GL_FALSE)
	{
		glGetProgramInfoLog(newProgram.get(), errorMessageSize, &errorBufferSize, errorMessage);
		return false;
	}

	mRenderer.DestroyDecodeShaderProgram();
	mRenderer.SetDecodeShaderProgram(newProgram.release(), newVertexShader.release(), newFragmentShader.release());
	return true;
}