#include "Grid.h"
#include <cmath>

GridPoint::GridPoint():
    color(0, 0, 0, 0), walkable(true), tilesprite(-1), transparent(true), visible(false), discovered(false), color_overlay(0,0,0,255), tile_overlay(-1), uisprite(-1)
{};

void Grid::setSprite(int ti)
{
        int tx = ti % texture_width, ty = ti / texture_width;
            sprite.setTextureRect(sf::IntRect(tx * grid_size, ty * grid_size, grid_size, grid_size));
}

Grid::Grid(int gx, int gy, int gs, int _x, int _y, int _w, int _h):
    grid_size(gs),
    grid_x(gx), grid_y(gy), 
    zoom(1.0f), center_x((gx/2) * gs), center_y((gy/2) * gs),
    texture_width(12), texture_height(11), visible(false)
{
    //grid_size = gs;
    //zoom = 1.0f;
    //grid_x = gx;
    //grid_y = gy;
    points.resize(gx*gy);
    box.setSize(sf::Vector2f(_w, _h));
    box.setPosition(sf::Vector2f(_x, _y));
    box.setFillColor(sf::Color(0,0,0,0));

    renderTexture.create(_w, _h);

    texture.loadFromFile("./assets/kenney_tinydungeon.png");
    texture.setSmooth(false);
    sprite.setTexture(texture);

    //output.setSize(box.getSize());
    output.setTextureRect(
        sf::IntRect(0, 0,
        box.getSize().x, box.getSize().y));
    output.setPosition(box.getPosition());
    // textures are upside-down inside renderTexture
    output.setTexture(renderTexture.getTexture());

    // Show one texture at a time
    sprite.setTexture(texture);
}

bool Grid::inBounds(int x, int y) {
    return (x >= 0 && y >= 0 && x < grid_x && y < grid_y);
}

void Grid::screenToGrid(int sx, int sy, int& gx, int& gy) {

    float center_x_sq = center_x / grid_size;
    float center_y_sq = center_y / grid_size;

    float width_sq = box.getSize().x / (grid_size * zoom);
    float height_sq = box.getSize().y / (grid_size * zoom);
    float left_edge = center_x_sq - (width_sq / 2.0);
    float right_edge = center_x_sq + (width_sq / 2.0);
    float top_edge = center_y_sq - (height_sq / 2.0);
    float bottom_edge = center_y_sq + (height_sq / 2.0);

    float grid_px = zoom * grid_size;
    //std::cout <<  "##############################" << 
    //    "\nscreen coord: (" << sx << ", " << sy << ")" << std::endl;

    sx -= box.getPosition().x;
    sy -= box.getPosition().y;

    //std::cout << "box coord: (" << sx << ", " << sy << ")" << std::endl;
    float mouse_x_sq = sx / grid_px;
    float mouse_y_sq = sy / grid_px;

    float ans_x = mouse_x_sq + left_edge;
    float ans_y = mouse_y_sq + top_edge;

    // compare integer method with this (mostly working) one
    //int diff_realpixel_x = box.getSize().x / 2.0 - sx;
    //int diff_realpixel_y = box.getSize().y / 2.0 - sy;
    int left_spritepixels = center_x - (box.getSize().x / 2.0 / zoom);
    int top_spritepixels = center_y - (box.getSize().y / 2.0 / zoom);

    std::cout << "Float method got ans (" << ans_x << ", " << ans_y << ")"
        << std::endl << "Int method px (" << left_spritepixels + (sx/zoom) << ", " << 
        top_spritepixels + (sy/zoom) << ")" << std::endl << 
        "Int grid (" << (left_spritepixels + (sx/zoom) ) / grid_size << 
        ", " << (top_spritepixels + (sy/zoom)) / grid_size << ")" << 

        std::endl;

    // casting float turns -0.5 to 0; I want any negative coord to be OOB
    if (ans_x < 0) ans_x = -1;
    if (ans_y < 0) ans_y = -1;

    gx = ans_x;
    gy = ans_y;
    /*
    std::cout <<
        "C: (" << center_x << ", " << center_y << ")" << std::endl <<
        "W: " << width_sq << " H: " << height_sq << std::endl <<
        "L: " << left_edge << " T: " << top_edge << std::endl <<
        "R: " << right_edge << " B: " << bottom_edge << std::endl <<
        "Grid Px: " << grid_px << "( zoom: " << zoom << ")" << std::endl <<
        "answer: G(" << ans_x << ", " << ans_y << ")" << std::endl << 
        "##############################" << 
        std::endl;
    */
}

void Grid::renderPxToGrid(int sx, int sy, int& gx, int& gy) {
    // just like screen px coversion, but no offset by grid's position
    float center_x_sq = center_x / grid_size;
    float center_y_sq = center_y / grid_size;

    float width_sq = box.getSize().x / (grid_size * zoom);
    float height_sq = box.getSize().y / (grid_size * zoom);

    int width_px = box.getSize().x / 2.0;
    int height_px = box.getSize().y / 2.0;

    float left_edge = center_x_sq - (width_sq / 2.0);
    float top_edge = center_y_sq - (height_sq / 2.0);

    float grid_px = zoom * grid_size;
    float sx_sq = sx / grid_px;
    float sy_sq = sy / grid_px;

    float ans_x = sx_sq + left_edge;
    float ans_y = sy_sq + top_edge;

    if (ans_x < 0) ans_x = -1;
    if (ans_y < 0) ans_y = -1;

    gx = ans_x;
    gy = ans_y;
}

void Grid::integerGrid(float fx, float fy, int& gx, int& gy) {
    if (fx < 0) fx -= 0.5;
    if (fy < 0) fy -= 0.5;
    gx = fx;
    gy = fy;
}

void Grid::gridToRenderPx(int gx, int gy, int& sx, int& sy) {
    // integer grid square (gx, gy) - what pixel (on rendertexture)
    // should it's top left corner be at (the sprite's position)

    // eff_gridsize = grid_size * zoom
    // if center_x = 161, and grid_size is 16, that's 10 + 1/16 sprites
    // center_x - (box.getSize().x / 2 / zoom) = left edge (in px)
    // gx * eff_gridsize = pixel position without panning
    // pixel_gx - left_edge = grid's render position

    sx = (gx * grid_size * zoom) - (center_x - (box.getSize().x / 2.0 / zoom));
    sy = (gy * grid_size * zoom) - (center_y - (box.getSize().y / 2.0 / zoom));
}

void Grid::render(sf::RenderWindow & window)
{
    renderTexture.clear();
    //renderTexture.draw(box);

    // sprites that are visible according to zoom, center_x, center_y, and box width
    float center_x_sq = center_x / grid_size;
    float center_y_sq = center_y / grid_size;

    float width_sq = box.getSize().x / (grid_size * zoom);
    float height_sq = box.getSize().y / (grid_size * zoom);
    float left_edge = center_x_sq - (width_sq / 2.0);
    //float right_edge = center_x_sq + (width_sq / 2.0);
    float top_edge = center_y_sq - (height_sq / 2.0);
    //float bottom_edge = center_y_sq + (height_sq / 2.0);


    int left_spritepixels = center_x - (box.getSize().x / 2.0 / zoom);
    int top_spritepixels = center_y - (box.getSize().y / 2.0 / zoom);

    sprite.setScale(sf::Vector2f(zoom, zoom));
    sf::RectangleShape r; // for colors and overlays
    r.setSize(sf::Vector2f(grid_size * zoom, grid_size * zoom));
    r.setOutlineThickness(0);

    int x_limit = left_edge + width_sq + 2;
    if (x_limit > grid_x) x_limit = grid_x;

    int y_limit = top_edge + height_sq + 2;
    if (y_limit > grid_y) y_limit = grid_y;

    //for (float x = (left_edge >= 0 ? left_edge : 0); 
    for (int x = (left_edge - 1 >= 0 ? left_edge - 1 : 0);
        x < x_limit; //x < view_width; 
        x+=1)
    {
        //for (float y = (top_edge >= 0 ? top_edge : 0); 
        for (int y = (top_edge - 1 >= 0 ? top_edge - 1 : 0);
            y < y_limit; //y < view_height;
            y+=1)
        {
            // Converting everything to integer pixels to avoid jitter
            //auto pixel_pos = sf::Vector2f(
            //    (x - left_edge) * (zoom * grid_size),
            //    (y - top_edge) * (zoom * grid_size));

            // This failed horribly:
            //int gx, gy; integerGrid(x, y, gx, gy);
            //int px_x, px_y; gridToRenderPx(gx, gy, px_x, px_y);
            //auto pixel_pos = sf::Vector2f(px_x, px_y);
           
            // this draws coherently, but the coordinates
            // don't match up with the mouse cursor function
            // jitter not eliminated
            auto pixel_pos = sf::Vector2f(
                    (x*grid_size - left_spritepixels) * zoom,
                    (y*grid_size - top_spritepixels) * zoom );

            auto gridpoint = at(std::floor(x), std::floor(y));

            sprite.setPosition(pixel_pos);
            
            r.setPosition(pixel_pos);
            r.setFillColor(gridpoint.color);
            renderTexture.draw(r);

            // tilesprite
            // if discovered but not visible, set opacity to 90%
            // if not discovered... just don't draw it?
            if (gridpoint.tilesprite != -1) {
                setSprite(gridpoint.tilesprite);
                renderTexture.draw(sprite);
            }

            // overlay

            // uisprite

        }
    }

    // grid lines for testing & validation
    /*
    sf::Vertex line[] =
    {
        sf::Vertex(sf::Vector2f(0, 0), sf::Color::Red),
        sf::Vertex(box.getSize(), sf::Color::Red),

    };

    renderTexture.draw(line, 2, sf::Lines);
    sf::Vertex lineb[] =
    {
        sf::Vertex(sf::Vector2f(0, box.getSize().y), sf::Color::Blue),
        sf::Vertex(sf::Vector2f(box.getSize().x, 0), sf::Color::Blue),

    };

    renderTexture.draw(lineb, 2, sf::Lines);
    */

    // render to window
    renderTexture.display();
    window.draw(output);
}

GridPoint& Grid::at(int x, int y)
{
    return points[y * grid_x + x];
}