#include <SFML/Graphics.hpp>
#include <iostream>
#include <vector>
#include "Player.h"
#include "Goomba.h"
#include "blocks.h"

// add goomba animations

int WINDOW_WIDTH = 1024;
int WINDOW_HEIGHT = 768;

using Enemy = baseSpriteClass;
using Powerups = baseSpriteClass;

// macros for memory efficiency
#define platLeft platforms[i]->getPosition().x
#define platRight platforms[i]->getPosition().x + platforms[i]->getLocalBounds().width
#define platTop platforms[i]->getPosition().y
#define platBottom platforms[i]->getPosition().y + platforms[i]->getLocalBounds().height

// return true if it should fall
bool applyGravity(Enemy& e, std::vector<sf::Sprite*> platforms, bool ligma = false)
{
    bool apply = true;
    int spriteLeft = e.getPosX();
    int spriteRight = e.getPosX() + e.getWidth();
    int spriteTop = e.getPosY();
    int spriteBottom = e.getPosY() + e.getHeight();

    for (int i = 0; i < platforms.size(); i++)
    {
        if (spriteRight > platLeft && spriteLeft < platRight)
        {
            if (spriteBottom >= platTop - 10 && spriteBottom <= platTop + 10)
            {
                apply = false;
                e.getPosY() = platTop - e.getWidth() - 8; // -5 is an offset for the top of the block
            }
        }
    }

    return apply;
}

bool enemyChangeDirection(Enemy& e, std::vector<sf::Sprite*> platforms, int& velX)
{
    bool change = false;
    int spriteLeft = e.getPosX();
    int spriteRight = e.getPosX() + e.getWidth();
    int spriteTop = e.getPosY();
    int spriteBottom = e.getPosY() + e.getHeight();

    for (int i = 0; i < platforms.size(); i++)
    {
        // using the macros from the previous function here as well
        if ((spriteLeft >= platRight - 2 && spriteLeft <= platRight + 2)
            || (spriteRight >= platLeft - 2 && spriteRight <= platLeft + 2))
            if (spriteBottom >= platBottom)
                change = true;
    }

    if (change)
        velX = -velX;
    return change;
}

// basic bounding box collision between the player and a sprite
bool playerEnemyCollision(Player& p, Enemy& e)
{
    int spriteLeft = e.getPosX();
    int spriteRight = e.getPosX() + e.getWidth();
    int spriteTop = e.getPosY();
    int spriteBottom = e.getPosY() + e.getHeight();

    bool colliding = true;
    if (p.left > spriteRight)
        colliding = false;
    if (p.right < spriteLeft)
        colliding = false;
    if (p.top > spriteBottom)
        colliding = false;
    if (p.bottom < spriteTop)
        colliding = false;
    return colliding;
}

// detects if the player has stomped the head of an enemy
bool hitEnemy(Player& p, Enemy& e)
{
    int spriteLeft = e.getPosX();
    int spriteRight = e.getPosX() + e.getWidth();
    int spriteTop = e.getPosY();
    int spriteBottom = e.getPosY() + e.getHeight();

    // if the player's x is within the sprite's
    if (p.right >= spriteLeft && p.left <= spriteRight)
    {
        if (p.bottom >= spriteTop - 5 && p.bottom <= spriteTop + 10)
            return true;
    }
    return false;
}

void levelReset(Player& p, std::vector<Enemy*> g)
{
    p.hp = 1;
    p.setPosX(p.originalX);
    p.setPosY(p.originalY);
    for (int i = 0; i < g.size(); i++)
    {
        g[i]->setPosX(g[i]->originalX);
        g[i]->setPosY(g[i]->originalY);
        g[i]->velX = g[i]->originalVelX;
    }
}

//add all blocks to platforms vector
int main()
{
    sf::RenderWindow window(sf::VideoMode(WINDOW_WIDTH, WINDOW_HEIGHT), "Mario Clone");
    window.setFramerateLimit(60);

    Player player;
    sf::View view(sf::FloatRect(0.f, 0.f, WINDOW_WIDTH, WINDOW_HEIGHT));

    // the vectors for the enemies and shit have to be pointers to the instances
    std::vector<Enemy*> enemies;
    Goomba* testGoomba = new Goomba(1000, 460);
    enemies.push_back(testGoomba);

    std::vector<Powerups*> onScreenPowerUps;

    std::vector<Block*> blocks;
    Block* testPowerBlock = new Block(300, 600, true);
    blocks.push_back((testPowerBlock));

    std::vector<sf::Sprite*> platforms;
    for (int i = 0; i < 50; i++)
    {
        Block* testPlatform2 = new Block(i * 48, 700, false);
        platforms.push_back(testPlatform2->getSpriteAddr());
    }
    // platforms.push_back(&testPlatform2);
   //  platforms.push_back(&testPlatform3);

    int leftLevelBorder = 0;
    int rightLevelBorder = 2000;

    while (window.isOpen())
    {
        if (player.getPosX() <= WINDOW_WIDTH / 2)
            view.setCenter(sf::Vector2f(WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2));
        else
            // center the camera's view to the player's position, if he isn't too far to the right/left
            view.setCenter(sf::Vector2f(player.getPosX(), WINDOW_HEIGHT / 2));

        window.setView(view);

        sf::Event event;
        while (window.pollEvent(event))
        {
            if (event.type == sf::Event::Closed)
                window.close();
            if (event.type == sf::Event::KeyPressed)
                if (event.key.code == sf::Keyboard::Space)
                {
                    if (!player.isAirborne)
                    {
                        player.jump(false);
                        player.justJumped = true;
                    }
                }
        }

        // change this to black to test for colour key success
        window.clear(sf::Color::White);

        if (sf::Keyboard::isKeyPressed(sf::Keyboard::A))
            player.velX = -5;
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::D))
            player.velX = 5;
        if (!sf::Keyboard::isKeyPressed(sf::Keyboard::A) &&
            !sf::Keyboard::isKeyPressed(sf::Keyboard::D))
            player.velX = 0;

        for (int i = 0; i < enemies.size(); i++)
        {
            enemies[i]->move();
            enemyChangeDirection(*enemies[i], platforms, enemies[i]->velX);

            static int gravityDelay = 0;
            if (applyGravity(*enemies[i], platforms))
            {
                // this changes the frequency at which the gravity is applied
                if (gravityDelay % 8 == 0)
                {
                    enemies[i]->velY += 1;
                    gravityDelay = 1;
                }
                gravityDelay++;
            }
            else
                enemies[i]->velY = 0;

            if (hitEnemy(player, *enemies[i]))
            {
                delete enemies[i];
                enemies.erase(enemies.begin() + i);
                player.jump(true);
                // continue statemente here, otherwise it would try to render a dangling pointer
                continue;
            }
            else
            {
                if (playerEnemyCollision(player, *enemies[i]))
                {
                    time_t tempTimer;
                    time(&tempTimer);
                    player.takeDamage(tempTimer);
                }
            }
            window.draw(enemies[i]->getRect());

        }

        if (player.hp <= 0)
        {
            levelReset(player, enemies);
        }

        player.move();
        player.isAirborne = true;
        // iterate through all the platforms and detect collision. last arg is number of plats.
        int newPlayerX = player.getPosX();
        for (int i = 0; i < platforms.size(); i++)
        {
            player.platformCollision(*platforms[i], &newPlayerX, nullptr);
            window.draw(*platforms[i]);
        }
        bool hitBot = false;
        for (int i = 0; i < blocks.size(); i++)
        {
            player.platformCollision(blocks[i]->getSprite(), &newPlayerX, &hitBot);
            window.draw(blocks[i]->getSprite());
            if (hitBot && blocks[i]->isPowerupBlock && !blocks[i]->hasReleased)
            {
                // make this work with all blocks by removing  powerBlock
                // and just making a member variable determine if it is a
                // block with something in it.
                blocks[i]->hasReleased = true;
                onScreenPowerUps.push_back(testPowerBlock->releasePowerUp(*testPowerBlock));
            }
        }

        for (int i = 0; i < onScreenPowerUps.size(); i++)
        {
            window.draw(onScreenPowerUps[i]->getRect());
            onScreenPowerUps[i]->update();
            static int updateGravity = 0;
            updateGravity++;
            if (onScreenPowerUps[i]->update())
            {
                if (onScreenPowerUps[i]->velY < 0)
                    onScreenPowerUps[i]->velY = 0;
                if (applyGravity(*onScreenPowerUps[i], platforms, true))
                    onScreenPowerUps[i]->velY += updateGravity / 10;
            }
            if (updateGravity > 10)
                updateGravity = 0;
        }

        player.getRect().setPosition(newPlayerX, player.getPosY());

        window.draw(player.getRect());

        window.display();
    }
}