#ifndef _CELLHANDLER_H
#define _CELLHANDLER_H

#define TilesCount 32
#define TileSize 250.0f
#define _minY ( -TilesCount * TileSize / 2 )
#define _minX ( -TilesCount * TileSize / 2 )

#define _maxY ( TilesCount * TileSize / 2 )
#define _maxX ( TilesCount * TileSize / 2 )

#define CellsPerTile 4
#define _cellSize ( TileSize / CellsPerTile )
#define _sizeX ( TilesCount * CellsPerTile )
#define _sizeY ( TilesCount * CellsPerTile )

#define GetRelatCoord( Coord, CellCoord ) ( ( _maxX - Coord ) - CellCoord * _cellSize )
namespace Core {

class Zone;

template< class T >
class CellHandler
{
public:
   CellHandler();
   ~CellHandler();

   T* getCell( uint32_t x, uint32_t y );
   T* getCellByCoords( float x, float y );
   T* create( uint32_t x, uint32_t y );
   T* createByCoords( float x, float y );
   void remove( uint32_t x, uint32_t y );

   bool allocated( uint32_t x, uint32_t y ) { return m_pCells[x][y] != nullptr; }

   static uint32_t getPosX( float x );
   static uint32_t getPosY( float y );

protected:
   void _init();

   T*** m_pCells;
};

template< class T >
CellHandler< T >::CellHandler()
{

   _init();
}

template< class T >
void CellHandler< T >::_init()
{
   m_pCells = new T**[_sizeX];

   assert( m_pCells );
   for( uint32_t i = 0; i < _sizeX; i++ )
   {
      m_pCells[i] = nullptr;
   }
}

template< class T >
CellHandler< T >::~CellHandler()
{
   if( m_pCells )
   {
      for( uint32_t i = 0; i < _sizeX; i++ )
      {
         if( !m_pCells[i] )
         {
            continue;
         }

         for( uint32_t j = 0; j < _sizeY; j++ )
         {
            if( m_pCells[i][j] )
            {
               delete m_pCells[i][j];
            }
         }
         delete[] m_pCells[i];
      }
      delete[] m_pCells;
   }
}

template< class T >
T* CellHandler< T >::create( uint32_t x, uint32_t y )
{
   if( x >= _sizeX || y >= _sizeY )
   {
      return nullptr;
   }

   if( !m_pCells[x] )
   {
      m_pCells[x] = new T*[_sizeY];
      memset( m_pCells[x], 0, sizeof( T* ) * _sizeY );
   }

   assert( m_pCells[x][y] == nullptr );

   T* cls = new T;
   m_pCells[x][y] = cls;

   return cls;
}

template< class T >
T* CellHandler< T >::createByCoords( float x, float y )
{
   return create( getPosX( x ), getPosY( y ) );
}

template< class T >
void CellHandler< T >::remove( uint32_t x, uint32_t y )
{
   if( x >= _sizeX || y >= _sizeY )
   {
      return;
   }

   if( !m_pCells[x] )
   {
      return;
   }

   assert( m_pCells[x][y] != nullptr );

   T* cls = m_pCells[x][y];
   m_pCells[x][y] = nullptr;

   delete cls;
}

template< class T >
T* CellHandler< T >::getCell( uint32_t x, uint32_t y )
{
   if( !m_pCells[x] )
   {
      return nullptr;
   }

   return m_pCells[x][y];
}

template< class T >
T* CellHandler< T >::getCellByCoords( float x, float y )
{
   return getCell( getPosX( x ), getPosY( y ) );
}

template< class T >
uint32_t CellHandler< T >::getPosX( float x )
{
   assert( ( x >= _minX ) && ( x <= _maxX ) );
   return ( uint32_t )( ( _maxX - x ) / _cellSize );
}

template< class T >
uint32_t CellHandler< T >::getPosY( float y )
{
   assert( ( y >= _minY ) && ( y <= _maxY ) );
   return ( uint32_t )( ( _maxY - y ) / _cellSize );
}

} // namespace Core
#endif