#include <SFML/Graphics.hpp>
#include <cstdlib>
#include <ctime>
#include <string>
#include <vector>
#include <iostream>

const unsigned TILE_HEIGHT = 32, TILE_WIDTH = 32,
               WINDOW_X = 30, WINDOW_Y = 20;

struct Tile {
    sf::Sprite s;
    float posX, posY;

    Tile(float x, float y, const sf::Texture& t) : posX(x), posY(y) {
        s.setTexture(t);
        s.setPosition(posX, posY);
    }
};

struct SnakeTile {
    sf::Sprite s;
    int dx, dy;
    float posX, posY;

    SnakeTile(sf::Texture& t, int dx, int dy, float posX, float posY) : dx(dx), dy(dy), posX(posX), posY(posY) {
        s.setTexture(t);
        s.setScale(sf::Vector2f(2.f, 2.f)); //original is 16x16
        s.setPosition(posX, posY);
    }
};

void freeMem(sf::RenderWindow& w, Tile*& t) { delete t; t = nullptr; }
void draw(sf::RenderWindow& w, Tile*& t) { w.draw(t->s); }
void iterateThroughBG(sf::RenderWindow& w, std::vector<std::vector<Tile*>>& v, void f(sf::RenderWindow& ,Tile*&));
void drawSnake(sf::RenderWindow& w, std::vector<SnakeTile*>& s);
void updateSnake(std::vector<SnakeTile*>& s);
void increaseSize(sf::Texture& t, std::vector<SnakeTile*>& s);
void wrapAround(SnakeTile& tile);

int main()
{
    sf::RenderWindow window(sf::VideoMode(TILE_WIDTH * WINDOW_X, TILE_HEIGHT * WINDOW_Y), "Snake!");
    std::srand((unsigned)std::time(0));

    //Load Textures
    sf::Texture bgTexture, snakeTexture;
    bgTexture.loadFromFile("tile.png");
    bgTexture.setSmooth(1);
    snakeTexture.loadFromFile("snake_block.png");
    snakeTexture.setSmooth(1);

    //Create Window Icon
    sf::Image icon;
    icon.loadFromFile("icon.png");
    window.setIcon(icon.getSize().x, icon.getSize().y, icon.getPixelsPtr());

    //Create Background Vector
    std::vector<std::vector<Tile*>> background(WINDOW_Y);
    for (unsigned i = 0; i < WINDOW_Y; i++) {
        background[i].resize(WINDOW_X);
        for (unsigned j = 0; j < WINDOW_X; j++) {
            background[i][j] = new Tile((float)TILE_HEIGHT * j, (float)TILE_WIDTH * i, bgTexture);
        }
    }

    //Create Snake Vector
    std::vector<SnakeTile*> snake(1);
    snake[0] = new SnakeTile(snakeTexture, 0, -1, WINDOW_X / 2.f * TILE_WIDTH, WINDOW_Y / 2.f * TILE_HEIGHT);
    increaseSize(snakeTexture, snake);
    increaseSize(snakeTexture, snake);

    sf::Clock c;

    while (window.isOpen())
    {

        sf::Event event;
        while (window.pollEvent(event))
        {
            if (event.type == sf::Event::Closed)
                window.close();
        }

        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left)) {
            snake[0]->dx = -1;
            snake[0]->dy = 0;
        }else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right)) {
            snake[0]->dx = 1;
            snake[0]->dy = 0;
        }else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Up)) {
            snake[0]->dx = 0;
            snake[0]->dy = -1;
        }else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down)) {
            snake[0]->dx = 0;
            snake[0]->dy = 1;
        }

        if (c.getElapsedTime().asSeconds() >= 0.08f) {
            updateSnake(snake);
            c.restart();
        }

        window.clear(sf::Color(sf::Color::White));

        iterateThroughBG(window, background, draw);
        drawSnake(window, snake);
        window.display();
    }

    iterateThroughBG(window, background, freeMem);

    for (auto i = snake.begin(); i != snake.end(); ++i)
        delete *i;

    return 0;
}

void iterateThroughBG(sf::RenderWindow& w, std::vector<std::vector<Tile*>>& v, void f(sf::RenderWindow&, Tile*&)) {
    for (auto row = v.begin(); row != v.end(); ++row) {
        for (auto col = (*row).begin(); col != (*row).end(); ++col) {
            f(w, *col);
        }
    }
}

void drawSnake(sf::RenderWindow& w, std::vector<SnakeTile*>& s) {
    for (auto i = s.begin(); i != s.end(); ++i)
        w.draw((*i)->s);
}

void updateSnake(std::vector<SnakeTile*>& s) {
    s[0]->posX += s[0]->dx * TILE_WIDTH;
    s[0]->posY += s[0]->dy * TILE_HEIGHT;
    s[0]->s.setPosition(sf::Vector2f(s[0]->posX, s[0]->posY));
    wrapAround(*s[0]);

    for (int i = s.size() -1; i > 0; i--) {
        s[i]->dx = s[i - 1]->dx;
        s[i]->dy = s[i - 1]->dy;
        s[i]->posX = s[i - 1]->posX;
        s[i]->posY = s[i - 1]->posY;
        s[i]->s.setPosition(sf::Vector2f(s[i]->posX, s[i]->posY));
    }
}

void wrapAround(SnakeTile& tile) {
    sf::FloatRect pos = tile.s.getGlobalBounds();

    //Check for out-of-bounds so we can wrap around
    if (pos.left + TILE_WIDTH <= 0.f) {
        tile.posX = (float)WINDOW_X * TILE_WIDTH;
    }
    else if (pos.left >= WINDOW_X * TILE_WIDTH) {
        tile.posX = 0.f - TILE_WIDTH;
    }
    else if (pos.top >= WINDOW_Y * TILE_HEIGHT) {
        tile.posY = 0.f - TILE_HEIGHT;
    }
    else if (pos.top + TILE_HEIGHT <= 0) {
        tile.posY = (float)WINDOW_Y * TILE_HEIGHT;
    }

    tile.s.setPosition(sf::Vector2f(tile.posX, tile.posY));
}

void increaseSize(sf::Texture& t, std::vector<SnakeTile*>& s) {
    SnakeTile* last = s[s.size() - 1];
    s.push_back(new SnakeTile(t, last->dx, last->dy, last->posX + (TILE_WIDTH * -last->dx), last->posY + (TILE_HEIGHT * -last->dy)));
}