/* $Id: mapmemory.hpp,v 1.17.4.1 2006/01/20 11:23:31 chfreund Exp $ */

#ifndef _MAPMEMORY_HPP_
#define _MAPMEMORY_HPP_

#include <cstring>
#include <SDL_types.h>

#include "serializable.hpp"
#include "serialize.hpp"

//////////////////////////////////////////////////////////////////////
// MapMemory<T> is a memory container for a map-like structure of
// type T
//////////////////////////////////////////////////////////////////////

template <class T>
class MapMemory : public Serializable {
	public:
		typedef T Type;
	private:
		// m_sizeX is the width, m_sizeY is the height of the map
		Uint32 m_sizeX, m_sizeY;
		// pointer to the array with all the values in the map
		T* m_memory;
	public:
		// Constructor
		MapMemory( int sizeX, int sizeY )
			: m_sizeX( sizeX ), m_sizeY( sizeY ) {
			m_memory = new T[m_sizeX*m_sizeY];
		}
		
		MapMemory( const MapMemory<T>& memory )
			: m_sizeX( memory.getSizeX() ), m_sizeY( memory.getSizeY() ) {
			m_memory = new T[m_sizeX*m_sizeY];
			memcpy( static_cast<void*>( m_memory ),
			        static_cast<void*>( memory.m_memory ),
			        m_sizeX * m_sizeY * sizeof( T ) );
		}
		
		// Destructor
		virtual ~MapMemory() {
			delete[] m_memory;
		}
		
		Uint32 getSizeX() const {
			return m_sizeX;
		}
		
		Uint32 getSizeY() const {
			return m_sizeY;
		}

		//! resize the map
		bool resize( const Uint32 sizeX, const Uint32 sizeY ) {
			if( sizeX * sizeY != m_sizeX * m_sizeY ) {
				delete [] m_memory;
				ASSERT( 0x0 != (m_memory = new T[sizeX * sizeY]),
				        "MapMemory::resize(%u, %u): could not "
				        "allocate memory.\n", sizeX, sizeY );
			}
			m_sizeX = sizeX;
			m_sizeY = sizeY;

			return true;
		}
		
		// returns the pointer the raw memory
		T* getMemory() const {
			return m_memory;
		}
		
		// return the value of the map at the point (i, j)
		T getValueAt( int i, int j ) const {
			return m_memory[m_sizeX*j + i];
		}
		
		// sets the value at the point (i, j)
		void setValueAt( int i, int j, T value ) {
			m_memory[m_sizeX*j + i] = value;
		}
		
		// return the reference for a value of the map at the point (i, j)
		T& getReferenceTo( int i, int j ) {
			return m_memory[m_sizeX*j + i];
		}
		
		// returns the size of the serialized object
		virtual Uint32 getSerializeBufferSize() const {
			return 2 * Serialize<Uint32>::sizeOf() +
				m_sizeX * m_sizeY * Serialize<T>::sizeOf();
		}
		
		// serialize the map into the buffer starting at bufferPointer
		// After this method bufferPointer points to next char after
		// the last char of the serialization of the map
		void serialize( Uint8*& bufferPointer ) const {
			// serialize m_SizeX
			Serialize<Uint32>::serialize( m_sizeX, bufferPointer );

			// serialize m_SizeY
			Serialize<Uint32>::serialize( m_sizeY, bufferPointer );

			// serialize m_memory
			Serialize<T>::serialize( m_sizeX*m_sizeY, m_memory, bufferPointer );
			/*
			for ( Uint32 i = 0; i < m_sizeX * m_sizeY; i++ ) {
				Serialize<T>::serialize( m_memory[i], bufferPointer );
			}
			*/
		}
		
		// create a new map out of a serialization in the buffer starting
		// at bufferPointer
		// After this method bufferPointer points to next char after
		// the last char of the serialization of the map
		static MapMemory<T>* createAndDeserialize( Uint8*& bufferPointer ) {
			// deserialize m_sizeX
			Uint32 sizeX;
			Serialize<Uint32>::deserialize( bufferPointer, sizeX );

			// deserialize m_sizeY
			Uint32 sizeY;
			Serialize<Uint32>::deserialize( bufferPointer, sizeY );

			// create object and fill memory from buffer
			MapMemory<T>* newObject = new MapMemory<T>( sizeX, sizeY );
			T* memoryPointer = newObject->getMemory();
			for ( Uint32 i = 0; i < sizeX * sizeY; i++ ) {
				Serialize<T>::deserialize( bufferPointer, *memoryPointer++ );
			}

			return newObject;
		}

		// replace the existing map by deserializing the contents of
		// the buffer pointed to by bufferPointer
		// After this method bufferPointer points to next char after
		// the last char of the serialization of the map
		void deserialize( Uint8*& bufferPointer ) {
			// deserialize m_sizeX
			Uint32 sizeX;
			Serialize<Uint32>::deserialize( bufferPointer, sizeX );

			// deserialize m_sizeY
			Uint32 sizeY;
			Serialize<Uint32>::deserialize( bufferPointer, sizeY );

			// reinitialize object if sizes do not match
			if ( m_sizeX != sizeX || m_sizeY != sizeY ) {
				delete[] m_memory;
				m_sizeX = sizeX;
				m_sizeY = sizeY;
				m_memory = new T[m_sizeX*m_sizeY];
			}

			// fill memory
			Serialize<T>::deserialize( m_sizeX*m_sizeY, bufferPointer, m_memory );
			/*
			T* memoryPointer = m_memory;
			for ( Uint32 i = 0; i < sizeX * sizeY; i++ ) {
				Serialize<T>::deserialize( bufferPointer, *memoryPointer++ );
			}
			*/
		}
};

#endif // _MAPMEMORY_HPP_