#include "SynEngine.hpp"

class Grid : public IDrawable
{
    private:
        sf::Vector2i offset;
        sf::Vector2i gridSize;
        Cell *cellArray;
        unsigned int cellCount;

        Cell *CreateCellArray(sf::Vector2i);
    public:
        Grid();
        void ApplyGridLimitsToVector2i(sf::Vector2i &);
        bool SetGrid();
        void UpdateCell(int, int, unsigned int, int = -1);
        void Draw(sf::RenderWindow *);
        ~Grid();
};

Grid::Grid()
{
    cellArray = NULL;
}

Cell *Grid::CreateCellArray(sf::Vector2i)
{
    cellCount = gridSize.x *gridSize.y;
    Cell *array = new Cell[cellCount];

    if(!array) return NULL;

    GameConfiguration *config = GameManager::GetConfig();

    sf::Vector2i cellSize = config -> GetSpriteCellSize();
    float sizeMultiplier = config -> GetSpriteSizeMultiplier();
    int xPos;
    int yPos;
    int i;

    for (i = 0; i < cellCount; i++)
    {
        xPos = (i % gridSize.x) * cellSize.x * sizeMultiplier + offset.x;
        yPos = ((cellCount - i - 1) / gridSize.x) * cellSize.y * sizeMultiplier + offset.y;

        (array + i) -> Set(xPos, yPos);
    }
    
    return array;
}

void Grid::ApplyGridLimitsToVector2i(sf::Vector2i &vector)
{
    vector.x %= gridSize.x; if(vector.x < 0) vector.x += gridSize.x;
    vector.y %= gridSize.y; if(vector.y < 0) vector.y += gridSize.y; 
}

bool Grid::SetGrid()
{
    GameConfiguration *config = GameManager::GetConfig();

    if(!config) return false;

    sf::Vector2i screenDimensions = config -> GetScreenDimensions();
    gridSize = config -> GetGridSize();
    offset = config -> GetGridOffset();

    cellArray = CreateCellArray(gridSize);

    return true;
}

void Grid::UpdateCell(int x, int y, unsigned int spriteIndex, int direction)
{
    x %= gridSize.x; if(x < 0) x += gridSize.x;
    y %= gridSize.y; if(y < 0) y += gridSize.y;
    int index = x + gridSize.x * y;
    Cell *cell = cellArray + index;

    cell -> UpdateSprite(spriteIndex);
    if(direction >= 0)
       cell -> UpdateRotation(direction);
}


void Grid::Draw(sf::RenderWindow *window)
{
    int i;
    for (i = 0; i < cellCount; i++)
        (cellArray + i) -> Draw(window);
}

Grid::~Grid()
{
    delete[] cellArray;
}