/* Copyright (C) 2012 Wildfire Games.
 * This file is part of 0 A.D.
 *
 * 0 A.D. is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * 0 A.D. is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "precompiled.h"

#include "ShaderDefines.h"

#include "maths/Vector4D.h"
#include "ps/ThreadUtil.h"

#include <sstream>

size_t hash_value(const CStrIntern& v)
{
	return v.GetHash();
}

size_t hash_value(const CVector4D& v)
{
	size_t hash = 0;
	boost::hash_combine(hash, v.X);
	boost::hash_combine(hash, v.Y);
	boost::hash_combine(hash, v.Z);
	boost::hash_combine(hash, v.W);
	return hash;
}

size_t hash_value(const CShaderParams<CStrIntern>::SItems& items)
{
	return items.hash;
}

size_t hash_value(const CShaderParams<CVector4D>::SItems& items)
{
	return items.hash;
}

bool operator==(const CShaderParams<CStrIntern>::SItems& a, const CShaderParams<CStrIntern>::SItems& b)
{
	return a.items == b.items;
}

bool operator==(const CShaderParams<CVector4D>::SItems& a, const CShaderParams<CVector4D>::SItems& b)
{
	return a.items == b.items;
}

template<typename value_t>
struct ItemNameCmp
{
	typedef typename CShaderParams<value_t>::SItems::Item Item;

	typedef Item first_argument_type;
	typedef Item second_argument_type;
	bool operator()(const Item& a, const Item& b) const
	{
		return a.first < b.first;
	}
};

template<typename value_t>
struct ItemNameGeq
{
	typedef typename CShaderParams<value_t>::SItems::Item Item;

	bool operator()(const Item& a, const Item& b) const
	{
		return !(b.first < a.first);
	}
};

template<typename value_t>
typename CShaderParams<value_t>::SItems* CShaderParams<value_t>::GetInterned(const SItems& items)
{
	ENSURE(ThreadUtil::IsMainThread()); // s_InternedItems is not thread-safe

	typename InternedItems_t::iterator it = s_InternedItems.find(items);
	if (it != s_InternedItems.end())
		return it->second.get();

	// Sanity test: the items list is meant to be sorted by name.
	// This is a reasonable place to verify that, since this will be called once per distinct SItems.
	typedef ItemNameCmp<value_t> Cmp;
	ENSURE(std::adjacent_find(items.items.begin(), items.items.end(), std::binary_negate<Cmp>(Cmp())) == items.items.end());

	shared_ptr<SItems> ptr(new SItems(items));
	s_InternedItems.insert(std::make_pair(items, ptr));
	return ptr.get();
}

template<typename value_t>
CShaderParams<value_t>::CShaderParams()
{
	SItems items;
	items.RecalcHash();
	m_Items = GetInterned(items);
}

template<typename value_t>
void CShaderParams<value_t>::Set(CStrIntern name, const value_t& value)
{
	SItems items = *m_Items;

	typename SItems::Item addedItem = std::make_pair(name, value);

	// Add the new item in a way that preserves the sortedness and uniqueness of item names
	for (typename std::vector<typename SItems::Item>::iterator it = items.items.begin(); ; ++it)
	{
		if (it == items.items.end() || addedItem.first < it->first)
		{
			items.items.insert(it, addedItem);
			break;
		}
		else if (addedItem.first == it->first)
		{
			it->second = addedItem.second;
			break;
		}
	}

	items.RecalcHash();
	m_Items = GetInterned(items);
}

template<typename value_t>
void CShaderParams<value_t>::SetMany(const CShaderParams& params)
{
	SItems items;
	// set_union merges the two sorted lists into a new sorted list;
	// if two items are equivalent (i.e. equal names, possibly different values)
	// then the one from the first list is kept
	std::set_union(
		params.m_Items->items.begin(), params.m_Items->items.end(),
		m_Items->items.begin(), m_Items->items.end(),
		std::inserter(items.items, items.items.begin()),
		ItemNameCmp<value_t>());
	items.RecalcHash();
	m_Items = GetInterned(items);
}

template<typename value_t>
std::map<CStrIntern, value_t> CShaderParams<value_t>::GetMap() const
{
	std::map<CStrIntern, value_t> ret;
	for (size_t i = 0; i < m_Items->items.size(); ++i)
		ret[m_Items->items[i].first] = m_Items->items[i].second;
	return ret;
}

template<typename value_t>
size_t CShaderParams<value_t>::GetHash() const
{
	return m_Items->hash;
}

template<typename value_t>
void CShaderParams<value_t>::SItems::RecalcHash()
{
	size_t h = 0;
	for (size_t i = 0; i < items.size(); ++i)
	{
		boost::hash_combine(h, items[i].first);
		boost::hash_combine(h, items[i].second);
	}
	hash = h;
}


void CShaderDefines::Add(const char* name, const char* value)
{
	Set(CStrIntern(name), CStrIntern(value));
}

int CShaderDefines::GetInt(const char* name) const
{
	CStrIntern nameIntern(name);
	for (size_t i = 0; i < m_Items->items.size(); ++i)
	{
		if (m_Items->items[i].first == nameIntern)
		{
			int ret;
			std::stringstream str(m_Items->items[i].second.c_str());
			str >> ret;
			return ret;
		}
	}
	return 0;
}


void CShaderUniforms::Add(const char* name, const CVector4D& value)
{
	Set(CStrIntern(name), value);
}

CVector4D CShaderUniforms::GetVector(const char* name) const
{
	CStrIntern nameIntern(name);
	for (size_t i = 0; i < m_Items->items.size(); ++i)
	{
		if (m_Items->items[i].first == nameIntern)
		{
			return m_Items->items[i].second;
		}
	}
	return CVector4D();
}

void CShaderUniforms::BindUniforms(const CShaderProgramPtr& shader) const
{
	const std::vector<SItems::Item>& items = m_Items->items;
	for (size_t i = 0; i < items.size(); ++i)
	{
		CShaderProgram::Binding binding = shader->GetUniformBinding(items[i].first);
		if (binding.Active())
		{
			CVector4D v = items[i].second;
			shader->Uniform(binding, v.X, v.Y, v.Z, v.W);
		}
	}
}

void CShaderRenderQueries::Add(const char* name)
{
	if (name == CStr("sim_time"))
	{
		m_Items.push_back(std::make_pair(RQUERY_TIME, CStrIntern(name)));
	}
	else if (name == CStr("water_tex"))
	{
		m_Items.push_back(std::make_pair(RQUERY_WATER_TEX, CStrIntern(name)));
	}
	else if (name == CStr("sky_cube"))
	{
		m_Items.push_back(std::make_pair(RQUERY_SKY_CUBE, CStrIntern(name)));
	}
}

size_t CShaderRenderQueries::GetSize()
{
	return m_Items.size();
}

CShaderRenderQueries::RenderQuery CShaderRenderQueries::GetItem(size_t i)
{
	return m_Items[i];
}

void CShaderConditionalDefines::Add(const char* defname, const char* defvalue, int type, std::vector<float> &args)
{
	CondDefine cd;
	cd.m_DefName = CStrIntern(defname);
	cd.m_DefValue = CStrIntern(defvalue);
	cd.m_CondArgs = args;
	cd.m_CondType = type;
	
	m_Defines.push_back(cd);
}

size_t CShaderConditionalDefines::GetSize()
{
	return m_Defines.size();
}

CShaderConditionalDefines::CondDefine& CShaderConditionalDefines::GetItem(size_t i)
{
	return m_Defines[i];
}


// Explicit instantiations:

template<> CShaderParams<CStrIntern>::InternedItems_t CShaderParams<CStrIntern>::s_InternedItems = CShaderParams<CStrIntern>::InternedItems_t();
template<> CShaderParams<CVector4D>::InternedItems_t CShaderParams<CVector4D>::s_InternedItems = CShaderParams<CVector4D>::InternedItems_t();

template class CShaderParams<CStrIntern>;
template class CShaderParams<CVector4D>;