/* 
 * File:   ThreadedMeshGenerator.hpp
 * Author: oliver
 *
 * Created on April 7, 2011, 4:04 PM
 */

#ifndef THREADEDMESHGENERATOR_HPP
#    define	THREADEDMESHGENERATOR_HPP

#include <PolyVoxCore/Vector.h>
#include <PolyClientUtil.hpp>

#include <PolyVoxCore/Volume.h>
#include <PolyVoxCore/Region.h>
#include <PolyVoxCore/SurfaceExtractor.h>
#include <PolyVoxCore/SurfaceMesh.h>
#include <PolyVoxCore/Raycast.h>

#include <boost/thread.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/thread/mutex.hpp>

#include <boost/timer.hpp>

#include <utility>
#include <vector>

template<typename VoxelType>
class ThreadedVolume;

template<typename VoxelType>
class VoxelAccessor
{
public:
	VoxelAccessor(ThreadedVolume<VoxelType>& vol);
	void setVoxel(int32_t x, int32_t y, int32_t z, VoxelType voxel);
	void setVoxel(PolyVox::Vector3DInt32 pos, VoxelType voxel);
	VoxelType getVoxel(int32_t x, int32_t y, int32_t z) const;
	VoxelType getVoxel(PolyVox::Vector3DInt32 pos) const;
private:
	ThreadedVolume<VoxelType>& m_TV;
	boost::lock_guard<boost::mutex> m_Lock;
};


struct MeshCommand
{
	MeshCommand(PolyVox::Vector3DInt32 p) : pos(p) {}
	PolyVox::SurfaceMesh<PolyVox::PositionMaterialNormal> mesh;
	PolyVox::Vector3DInt32 pos;
};

template<typename VoxelType>
class ThreadedVolume
{
	friend class VoxelAccessor<VoxelType>;
	typedef PolyVox::Volume<VoxelType> Volume;
public:
	ThreadedVolume(uint32_t uChunkSideLengthPower);
	~ThreadedVolume();
	void stop();
	void start();
	std::unique_ptr<MeshCommand> next();
	void resize(uint32_t uChunkSideLengthPower);
	PolyVox::RaycastResult raycast(PolyVox::Vector3DFloat start, PolyVox::Vector3DFloat end);
	void add(PolyVox::Vector3DInt32 pos);
private:
	std::set<PolyVox::Vector3DInt32> m_Blocks;
	std::queue<MeshCommand*> m_vecMeshesToRender;
	std::queue<MeshCommand*> m_vecMeshesRendered;
	Volume m_Volume, m_Volume2;
	void thread_loop();
	bool m_bStopThread;
	uint32_t m_uChunkSideLengthPower;
	boost::scoped_ptr<boost::thread> m_Thread;
	boost::mutex m_mutexVolume;
	boost::mutex m_mutexMeshesToRender;
	boost::mutex m_mutexMeshesRendered;
	std::set<PolyVox::Vector3DInt32> m_ModifiedChunks;
	std::set<PolyVox::Vector3DInt32> m_LoadedChunks;
};


template<typename VoxelType>
inline void VoxelAccessor<VoxelType>::setVoxel(int32_t x, int32_t y, int32_t z, VoxelType voxel)
{
	m_TV.m_Volume.setVoxelAt(x, y, z, voxel);
}

template<typename VoxelType>
inline void VoxelAccessor<VoxelType>::setVoxel(PolyVox::Vector3DInt32 pos, VoxelType voxel)
{
	setVoxel(pos.getX(), pos.getY(), pos.getZ(), voxel);
}

template<typename VoxelType>
inline VoxelType VoxelAccessor<VoxelType>::getVoxel(int32_t x, int32_t y, int32_t z) const
{
	return m_TV.m_Volume.getVoxelAt(x, y, z);
}

template<typename VoxelType>
inline VoxelType VoxelAccessor<VoxelType>::getVoxel(PolyVox::Vector3DInt32 pos) const
{
	return getVoxel(pos.getX(), pos.getY(), pos.getZ());
}



template<typename VoxelType>
inline ThreadedVolume<VoxelType>::~ThreadedVolume()
{
	if(m_Thread) {
		m_Thread->join();
	}
}

template<typename VoxelType>
inline VoxelAccessor<VoxelType>::VoxelAccessor(ThreadedVolume<VoxelType>& tv)
:m_TV(tv), m_Lock(tv.m_mutexVolume)
{
}

template<typename VoxelType>
inline PolyVox::RaycastResult ThreadedVolume<VoxelType>::raycast(PolyVox::Vector3DFloat start, PolyVox::Vector3DFloat direction)
{
	boost::lock_guard<boost::mutex> lock(m_mutexVolume);
	PolyVox::RaycastResult raycastResult;
	PolyVox::Raycast<PolyVox::MaterialDensityPair44> raycast(&m_Volume, start, direction, raycastResult);
	raycast.execute();
	return raycastResult;
}

template<typename VoxelType>
inline std::unique_ptr<MeshCommand> ThreadedVolume<VoxelType>::next()
{
	std::unique_ptr<MeshCommand> ret;
	boost::lock_guard<boost::mutex> lock(m_mutexMeshesRendered);
	if(m_vecMeshesRendered.empty()) {
		return ret;
	}
	// get one
	ret.reset(m_vecMeshesRendered.front());
	m_vecMeshesRendered.pop();
	return std::move(ret);
}

template<typename VoxelType>
inline void ThreadedVolume<VoxelType>::add(PolyVox::Vector3DInt32 pos)
{
	boost::lock_guard<boost::mutex> lock(m_mutexMeshesToRender);
	if(m_ModifiedChunks.count(pos) == 0) {
		m_vecMeshesToRender.push(new MeshCommand(pos));
		m_LoadedChunks.insert(pos);
		m_ModifiedChunks.insert(pos);
	}
}

template<typename VoxelType>
inline void ThreadedVolume<VoxelType>::start()
{
	if(!m_bStopThread && m_Thread) {
		stop();
		m_Thread->join();
	}
	m_bStopThread = false;
	m_Thread.reset(new boost::thread(boost::bind(&ThreadedVolume<VoxelType>::thread_loop, this)));
}

template<typename VoxelType>
inline void ThreadedVolume<VoxelType>::stop()
{
	m_bStopThread = true;
}

template<typename VoxelType>
inline ThreadedVolume<VoxelType>::ThreadedVolume(uint32_t uChunkSideLengthPower)
:m_Volume(NULL, NULL), m_Volume2(NULL, NULL), m_bStopThread(true)
{
	resize(uChunkSideLengthPower);
}

template<typename VoxelType>
inline void ThreadedVolume<VoxelType>::resize(uint32_t uChunkSideLengthPower)
{
	boost::lock_guard<boost::mutex> lock1(m_mutexMeshesToRender);
	boost::lock_guard<boost::mutex> lock2(m_mutexMeshesRendered);
	boost::lock_guard<boost::mutex> lock3(m_mutexVolume);
	m_uChunkSideLengthPower = uChunkSideLengthPower;
	m_Volume.resize(PolyVox::Region::MaxRegion, 0x01<<m_uChunkSideLengthPower);
	m_Volume2.resize(PolyVox::Region::MaxRegion, 0x01<<m_uChunkSideLengthPower);
	m_Volume.setMaxNumberOfUncompressedBlocks(32);
	m_Volume.setMaxNumberOfBlocksInMemory(30000u);
	m_Volume2.setMaxNumberOfUncompressedBlocks(32);
	m_Volume2.setMaxNumberOfBlocksInMemory(30000u);
}

template<typename VoxelType>
inline void ThreadedVolume<VoxelType>::thread_loop() {
	while(!m_bStopThread) {
		boost::this_thread::sleep(boost::posix_time::milliseconds(10));
		MeshCommand* mcCurrent;
		{
			boost::lock_guard<boost::mutex> lock(m_mutexMeshesToRender);
			if(m_vecMeshesToRender.empty()) {
				continue;
			}
			mcCurrent = m_vecMeshesToRender.front();
			m_vecMeshesToRender.pop();
			m_ModifiedChunks.erase(mcCurrent->pos);
		}
		{
			boost::lock_guard<boost::mutex> lock(m_mutexVolume);
			int32_t x = mcCurrent->pos.getX();
			int32_t y = mcCurrent->pos.getY();
			int32_t z = mcCurrent->pos.getZ();

			bool bCanRender = true;
			for(int x1 = x-1; x1 <= x+1 && bCanRender; x1++)
			{
				for(int y1 = y-1; y1 <= y+1 && bCanRender; y1++)
				{
					for(int z1 = z-1; z1 <= z+1; z1++)
					{
						if(m_ModifiedChunks.count(PolyVox::Vector3DInt32(x1, y1, z1)) == 1) {
							m_Volume.copyBlockTo(m_Volume2, x1, y1, z1);
						} else if(m_LoadedChunks.count(PolyVox::Vector3DInt32(x1, y1, z1)) == 0) {
							bCanRender = false;
							break;
						}
					}
				}
			}
			if(!bCanRender) {
				continue;
			}

		}
		PolyVox::Region reg(
			(mcCurrent->pos) << static_cast<int32_t>(m_uChunkSideLengthPower),
			((mcCurrent->pos) + PolyVox::Vector3DInt32(1,1,1)) << static_cast<int32_t>(m_uChunkSideLengthPower)
			);
		PolyVox::SurfaceExtractor<VoxelType> extractor(&m_Volume2, reg, &(mcCurrent->mesh));
		extractor.execute();

		{
			boost::lock_guard<boost::mutex> lock(m_mutexMeshesRendered);
			m_vecMeshesRendered.push(mcCurrent);
		}
	}
}

#endif	/* THREADEDMESHGENERATOR_HPP */