// CMakeLists.txt
cmake_minimum_required(VERSION 3.16)
project(DangerousRacers VERSION 0.2.0 LANGUAGES CXX)

# =========================
# C++ Standard
# =========================
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# =========================
# Build Type Default
# =========================
if(NOT CMAKE_BUILD_TYPE)
    set(CMAKE_BUILD_TYPE Release)
endif()

message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")

# =========================
# MSVC Runtime (IMPORTANT)
# Use dynamic runtime (/MD, /MDd)
# Reduces antivirus false positives
# =========================
if (MSVC)
    set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
endif()

# =========================
# SFML Configuration
# =========================
include(FetchContent)

# Debug = static (easy local dev)
# Release = shared (better distribution)
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
    set(BUILD_SHARED_LIBS OFF)
    set(SFML_STATIC_LIBRARIES ON)
else()
    set(BUILD_SHARED_LIBS ON)
    set(SFML_STATIC_LIBRARIES OFF)
endif()

FetchContent_Declare(
        SFML
        GIT_REPOSITORY https://github.com/SFML/SFML.git
        GIT_TAG 2.6.1
        GIT_SHALLOW ON
)

FetchContent_MakeAvailable(SFML)

# =========================
# Source Files
# =========================
set(SOURCE_FILES
        src/main.cpp
        src/Scene.cpp
        src/AnimatedSprite.cpp
        src/SceneManager.cpp
        src/DrawableEntity.cpp
        src/Meter.cpp
        src/Player.cpp
        src/Obstacles/Obstacle.cpp
        src/Obstacles/ObstacleManager.cpp
        src/Label.cpp
        src/Button.cpp
        src/Scenes/MainMenu.cpp
        src/Scenes/studio_splashscreen.cpp
        src/Scenes/TutorialOver.cpp
        src/Scenes/GameOver.cpp
        src/Scenes/Levels/tutorial_level.cpp
)

# =========================
# Executable
# =========================
# WIN32 removes console window (optional)
add_executable(DangerousRacers ${SOURCE_FILES})

# Only apply for Release builds on Windows
if(WIN32)
    target_link_options(DangerousRacers PRIVATE
            $<$<CONFIG:Release>:/SUBSYSTEM:WINDOWS>
            $<$<CONFIG:Release>:/ENTRY:mainCRTStartup>
    )
endif()

target_sources(DangerousRacers PRIVATE resources/version.rc)

# =========================
# Includes
# =========================
target_include_directories(DangerousRacers PRIVATE
        ${CMAKE_CURRENT_SOURCE_DIR}/include
)

# =========================
# Compile Definitions
# =========================
if(SFML_STATIC_LIBRARIES)
    target_compile_definitions(DangerousRacers PRIVATE SFML_STATIC)
endif()

# =========================
# Linking
# =========================
target_link_libraries(DangerousRacers PRIVATE
        sfml-graphics
        sfml-window
        sfml-system
        sfml-audio
)

# =========================
# Compiler Flags
# =========================
if(MSVC)
    target_compile_options(DangerousRacers PRIVATE
            $<$<CONFIG:Release>:/O2 /DNDEBUG>
            $<$<CONFIG:Debug>:/Zi>
    )
endif()

# =========================
# Copy Assets
# =========================
add_custom_command(TARGET DangerousRacers POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E copy_directory
        ${CMAKE_CURRENT_SOURCE_DIR}/assets
        $<TARGET_FILE_DIR:DangerousRacers>/assets
)

add_custom_command(TARGET DangerousRacers POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E copy
        ${CMAKE_CURRENT_SOURCE_DIR}/resources/README.md
        $<TARGET_FILE_DIR:DangerousRacers>/README.md
)

# =========================
# OpenAL DLL (needed for audio)
# =========================
if (WIN32)
    if (CMAKE_SIZEOF_VOID_P EQUAL 8)
        set(OPENAL_DLL "${sfml_SOURCE_DIR}/extlibs/bin/x64/openal32.dll")
    else()
        set(OPENAL_DLL "${sfml_SOURCE_DIR}/extlibs/bin/x86/openal32.dll")
    endif()

    add_custom_command(TARGET DangerousRacers POST_BUILD
            COMMAND ${CMAKE_COMMAND} -E copy_if_different
            "${OPENAL_DLL}"
            $<TARGET_FILE_DIR:DangerousRacers>
    )
endif()

# =========================
# Copy SFML DLLs (Release builds)
# =========================
if(WIN32 AND BUILD_SHARED_LIBS)
    add_custom_command(TARGET DangerousRacers POST_BUILD
            COMMAND ${CMAKE_COMMAND} -E copy_if_different
            $<TARGET_FILE:sfml-graphics>
            $<TARGET_FILE:sfml-window>
            $<TARGET_FILE:sfml-system>
            $<TARGET_FILE:sfml-audio>
            $<TARGET_FILE_DIR:DangerousRacers>
    )
endif()

# =========================
# Install / Packaging (optional)
# =========================
install(TARGETS DangerousRacers DESTINATION .)

install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/assets
        DESTINATION ./assets)

# =========================
# Output Directories
# =========================
set_target_properties(DangerousRacers PROPERTIES
        RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
)

// include/DangerousRacers/AnimatedSprite.h
#pragma once
#include "DrawableEntity.h"

class AnimatedSprite : public DrawableEntity {
private:
    int frames = 1;
    int fps = 1;

    int currentFrame = 1;
    float frameTimer = 0.f;
public:
    AnimatedSprite(const float x, const float y, const std::string& texturePath, const int _frames = 1, const int _fps = 1);

    void render(sf::RenderWindow& window);

    void update(const float deltaTime);
};


// include/DangerousRacers/Button.h
#pragma once
#include <functional>

#include "Label.h"
#include "SFML/Graphics/RectangleShape.hpp"
#include "SFML/Graphics/RenderWindow.hpp"

class Button {
private:
    sf::RectangleShape buttonRect;
    Label label;
    bool selected = false;

    std::function<void()> onClick;
public:
    Button(const std::string &labelString, sf::Vector2f position, const std::function<void()>& _onClick = []() {});

    void setText(const std::string &labelString);
    void render(sf::RenderWindow& window) const;
    void update(const float deltaTime);
    void eventHandler(const sf::Event& event);

    void setOnClick(const std::function<void()>& _onClick) { onClick = _onClick; }

    void setSelected(const bool _selected) {
        if (_selected == selected) return;
        selected = _selected;
        label.setDarkMode(selected);

        if (selected) buttonRect.setFillColor({255, 255, 255});
        else buttonRect.setFillColor({0, 0, 0, 64});
    };
};


// include/DangerousRacers/DrawableEntity.h
#pragma once
#include <string>

#include "SFML/Graphics/RenderWindow.hpp"
#include "SFML/Graphics/Sprite.hpp"
#include "SFML/Graphics/Texture.hpp"

class DrawableEntity {
protected:
    sf::Texture texture;
    sf::Sprite sprite;
    sf::Vector2f position, startPosition, targetPosition;
    float moveDuration = 0.f, moveElapsed = 0.f;
    bool moving = false;

    void _setPosition(const float x, const float y);
public:
    DrawableEntity(const float x, const float y, const std::string& texturePath);

    sf::Sprite& getSprite();

    void loadTexture(const std::string& texturePath);
    void _setTexture(const sf::Texture& _texture);

    void moveTo(const float x, const float y, const float timeToMove = 0.f);

    bool isMoving() const;

    sf::Vector2f getPosition() const {
        return position;
    };

    sf::Vector2i getRelativePosition() const;

    int getHeight() const;

    void render(sf::RenderWindow& window);

    void update(const float deltaTime);
};


// include/DangerousRacers/GameManager.h
#pragma once

class GameManager {
    public:
    int score = 0;
    int bubblesPopped = 0;

    int getScore() const { return score; }
    void addScore(const int amount) { score += amount; }
    void resetScore() { score = 0; }

    int getBubblesPopped() const { return bubblesPopped; }
    void addBubblesPopped(const int amount) { bubblesPopped += amount; }
    void resetBubblesPopped() { bubblesPopped = 0; }

    void reset() { resetScore(); resetBubblesPopped(); }
};

// include/DangerousRacers/Label.h
#pragma once
#include "SFML/Graphics/Text.hpp"
#include "SFML/Graphics/RenderWindow.hpp"

class Label {
private:
    sf::Text labelText;
    bool center;
    bool outline;
    bool darkMode = false;
public:
    Label(const std::string &labelString, sf::Vector2f position, const bool _center = false, const bool _outline = true);

    void setText(const std::string &labelString);
    void setPosition(const sf::Vector2f position);
    void setFillColor(const sf::Color color) {
        labelText.setFillColor(color);
    };
    void setOutlineColor(const sf::Color color) {
        labelText.setOutlineColor(color);
    };
    sf::FloatRect getBounds() const {
        return labelText.getGlobalBounds();
    };
    void render(sf::RenderWindow& window) const;

    void setDarkMode(const bool _darkMode) {
        darkMode = _darkMode;

        labelText.setFillColor(darkMode ? sf::Color::Black : sf::Color::White);
        if (outline) {
            labelText.setOutlineColor(darkMode ? sf::Color::White : sf::Color::Black);
            labelText.setOutlineThickness(2);
        }
    };
};


// include/DangerousRacers/Meter.h
#pragma once
#include "SFML/Graphics/RectangleShape.hpp"
#include "SFML/Graphics/RenderWindow.hpp"

class Meter {
private:
    sf::RectangleShape outline;
    sf::RectangleShape fillBar;
public:
    Meter(int x, int y, float w, float h, sf::Color color, float value = 0);

    void render(sf::RenderWindow& window) const;

    void setValue(float value);
};


// include/DangerousRacers/Obstacles/Obstacle.h
#pragma once
#include "DangerousRacers/DrawableEntity.h"

class Obstacle : public DrawableEntity {
    float& speed;
public:
    Obstacle(const float x, const float y, float& speed);

    void render(sf::RenderWindow& window);
    void update(const float deltaTime);

    bool outOfBounds() {
        const auto height = this->getSprite().getGlobalBounds().height;
        return this->getPosition().y > 720.f + height / 2;
    }
};

// include/DangerousRacers/Obstacles/ObstacleManager.h
#pragma once
#include "Obstacle.h"

class ObstacleManager {
    float& sceneSpeed;
    std::vector<std::unique_ptr<Obstacle>> obstacles;
public:
    ObstacleManager(float& sceneSpeed);

    void render(sf::RenderWindow& window);
    void update(const float deltaTime);

    void reset();

    void spawnObstacle(const float x = 0, const float y = 0);

    bool obstacleCollides(const sf::FloatRect& collisionObject) const;
};


// include/DangerousRacers/Player.h
#pragma once
#include "AnimatedSprite.h"

class Player : public AnimatedSprite {
public:
    Player(const float x, const float y);

    void render(sf::RenderWindow& window);
    void update(const float deltaTime);
};


// include/DangerousRacers/Scene.h
#pragma once
#include <string>

#include "SceneManager.h"

class Scene {
public:
    SceneManager& sceneManager;
    sf::Clock clock;
    std::string name;

    Scene(SceneManager& _sceneManager, std::string  _name) : sceneManager(_sceneManager), name(std::move(_name)) {};

    virtual ~Scene() = default;

    virtual void start();
    virtual void leave();
    virtual void update(float deltaTime);
    virtual void render(sf::RenderWindow& window);
    virtual void eventHandler(sf::Event& event);
};

// include/DangerousRacers/SceneManager.h
#pragma once
#include <memory>
#include <functional>
#include <unordered_map>

#include "GameManager.h"
#include "SFML/Graphics/RenderWindow.hpp"

class Scene;

class SceneManager {
private:
    sf::RenderWindow& gameWindow;
    GameManager& gameManager;
    std::unordered_map<std::string, std::function<std::unique_ptr<Scene>()>> sceneFactories;
    std::unique_ptr<Scene> currentScene;
    std::string activeScene;
public:
    SceneManager(sf::RenderWindow& gameWindow, GameManager& gameManager);

    void addScene(const std::string& name, const std::function<std::unique_ptr<Scene>()>& sceneFactory) {
        sceneFactories.emplace(name, sceneFactory);
    }

    void update(float deltaTime) const;
    void render(sf::RenderWindow& window) const;

    std::string getCurrentScene() const {
        return activeScene;
    };

    GameManager& getGameManager() const { return gameManager; }
    sf::RenderWindow& getGameWindow() const { return gameWindow; }

    void changeScene(const std::string& sceneName);

    void eventHandler(sf::Event& event) const;

    void _quit();
};

// include/DangerousRacers/Scenes/GameOver.h
#pragma once
#include "DangerousRacers/Label.h"
#include "DangerousRacers/Scene.h"
#include "SFML/Graphics/RectangleShape.hpp"
#include "SFML/Graphics/Texture.hpp"

class GameOverScene : public Scene {
private:
    bool wallTileLoaded = false;
    sf::Texture wallTileTexture;
    sf::RectangleShape wallTile;

    Label scoreLabel{"Score: 0\nBubbles Popped: 0", {576.f/2,768.f/2}, true, true};
public:
    GameOverScene(SceneManager& _sceneManager);

    void start();

    void update(float deltaTime);
    void render(sf::RenderWindow& window);
    void eventHandler(sf::Event& event);
};


// include/DangerousRacers/Scenes/Levels/tutorial_level.h
#pragma once
#include "DangerousRacers/Label.h"
#include "DangerousRacers/Meter.h"
#include "DangerousRacers/Player.h"
#include "DangerousRacers/Scene.h"
#include "DangerousRacers/Obstacles/ObstacleManager.h"
#include "SFML/Graphics/Texture.hpp"
#include "SFML/Graphics/Sprite.hpp"

class DebugLevelScene : public Scene {
    sf::Texture backgroundTexture;
    sf::Sprite backgroundSprite;

    float speed = 200.f;
    float bgYOffset = -720.f;

    float distanceTraveled = 0.f;

    Player player{405.f/2, 720.f/2};
    ObstacleManager obstacleManager{speed};

    bool reverseTime = false;
    float timeInReverse = 0.f;

    Label scoreLabel{"KM: 0", {8,8}, false, true};

    float fuel = 1.f, health = 1.f;

    Meter fuelMeter{ 8, 712, 16.f, 320.f, {175, 198, 151} };
    Meter damageMeter{ 8, 384, 16.f, 320.f, {250,231,19} };

    unsigned char currentTutorial = 0;
    const std::vector<float> tutorialDistance { 1750.f, 3750.f, 5750.f };
    std::vector<Label> tutorialLabels {
        { "Move your mouse\nto avoid obstacles", sf::Vector2f(405.f/2, 720.f*0.25f), true },
        { "This is your fuel\nIf it runs out, gameover", sf::Vector2f(32, 600), false },
        { "This is your damage\nToo much damage, kaboom", sf::Vector2f(32, 200), false },
    };
public:
    DebugLevelScene(SceneManager& _sceneManager);

    void start();
    void reset();

    void leave();

    void update(float deltaTime);

    void render(sf::RenderWindow& window);

    void eventHandler(sf::Event& event);
};


// include/DangerousRacers/Scenes/MainMenu.h
#pragma once

#include "DangerousRacers/Button.h"
#include "DangerousRacers/Scene.h"
#include "SFML/Graphics/Sprite.hpp"
#include "SFML/Graphics/Texture.hpp"

class MainMenuScene : public Scene {
private:
    sf::Texture backgroundTexture;
    sf::Sprite backgroundSprite;

    sf::Texture titleTexture;
    sf::Sprite titleSprite;

    Button tutorialButton{"Tutorial", {405.f / 2.f, 720.f * 0.25}, [&] { return startTutorialLevel(); }};
public:
    MainMenuScene(SceneManager& _sceneManager);

    void start();
    void update(float deltaTime);
    void render(sf::RenderWindow& window);
    void eventHandler(sf::Event& event);

    void startTutorialLevel() const;
};

// include/DangerousRacers/Scenes/studio_splashscreen.h
#pragma once
#include "DangerousRacers/Scene.h"
#include "SFML/Graphics/Texture.hpp"
#include "SFML/Graphics/Sprite.hpp"

class StudioSplashScreenScene : public Scene {
public:
    sf::Texture logoTexture;
    sf::Sprite logoSprite;
    bool fadingIn = true;
    float fadeTime = 2.5f;
    StudioSplashScreenScene(SceneManager& _sceneManager);

    void start();

    void update(float deltaTime);

    void render(sf::RenderWindow& window);

    void eventHandler(sf::Event& event);
};


// include/DangerousRacers/Scenes/TutorialOver.h
#pragma once
#include "DangerousRacers/Button.h"
#include "DangerousRacers/Label.h"
#include "DangerousRacers/Scene.h"
#include "SFML/Graphics/RectangleShape.hpp"
#include "SFML/Graphics/Texture.hpp"

class TutorialOverScene : public Scene {
private:
    bool wallTileLoaded = false;
    sf::Texture wallTileTexture;
    sf::RectangleShape wallTile;

    Label gameOverLabel{"Tutorial\nComplete!", {405.f/2, 720.f*0.25f}, true, true};
    Button returnButton{ "Return to Main Menu", { 405.f / 2, 720.f / 2 }, [&] {
        sceneManager.changeScene("MainMenu");
    } };
public:
    TutorialOverScene(SceneManager& _sceneManager);

    void start();

    void update(float deltaTime);
    void render(sf::RenderWindow& window);
    void eventHandler(sf::Event& event);
};


// src/AnimatedSprite.cpp
#include <DangerousRacers/AnimatedSprite.h>

AnimatedSprite::AnimatedSprite(const float x, const float y, const std::string &texturePath, const int _frames, const int _fps) : DrawableEntity(x, y, texturePath) {
    fps = _fps;
    frames = _frames;
    sprite.setTextureRect({0, 0, getHeight(), getHeight()});
}

void AnimatedSprite::render(sf::RenderWindow &window) {
    DrawableEntity::render(window);
}

void AnimatedSprite::update(const float deltaTime) {
    DrawableEntity::update(deltaTime);

    frameTimer += deltaTime;

    if (frameTimer >= 1.f / static_cast<float>(fps)) {
        frameTimer = 0.f;
        sprite.setTextureRect({getHeight() * (currentFrame % frames), 0, getHeight(), getHeight()});
        currentFrame++;
    }
}



// src/Button.cpp
#include <DangerousRacers/Button.h>

#include "SFML/Window/Event.hpp"

constexpr int BUTTON_X_PADDING = 48, BUTTON_Y_PADDING = 32;

Button::Button(const std::string &labelString, const sf::Vector2f position, const std::function<void()>& _onClick) :
label("", {0,0}, true, false), onClick(_onClick) {
    label.setText(labelString);
    label.setPosition(position);

    // label.setColor({0, 0, 0});

    const sf::FloatRect bounds = label.getBounds();
    buttonRect.setSize({bounds.width + BUTTON_X_PADDING, bounds.height + BUTTON_Y_PADDING});
    buttonRect.setOrigin(bounds.width / 2.f + (BUTTON_X_PADDING / 2), bounds.height / 2.f - 14 + (BUTTON_Y_PADDING / 2));
    buttonRect.setPosition(position);
    buttonRect.setFillColor({0, 0, 0, 64});
}

void Button::setText(const std::string &labelString) {
    label.setText(labelString);
}

void Button::render(sf::RenderWindow &window) const {
    window.draw(buttonRect);
    label.render(window);
}

void Button::update(const float deltaTime) {

}

void Button::eventHandler(const sf::Event &event) {
    if (event.type == sf::Event::MouseMoved) {
        if (buttonRect.getGlobalBounds().contains(event.mouseMove.x, event.mouseMove.y)) {
            setSelected(true);
        } else setSelected(false);
    }

    if (event.type == sf::Event::MouseButtonPressed && event.mouseButton.button == sf::Mouse::Left && selected) {
        // Trigger Button
        onClick();
    }
}

// src/DrawableEntity.cpp
#include <iostream>
#include <ostream>
#include <DangerousRacers/DrawableEntity.h>

#include "SFML/Graphics/Texture.hpp"

DrawableEntity::DrawableEntity(const float x, const float y, const std::string &texturePath) {
    loadTexture(texturePath);
    this->_setPosition(x, y);
}

void DrawableEntity::loadTexture(const std::string &texturePath) {
    if (texturePath.empty() || !texture.loadFromFile(texturePath)) {
        std::cerr << "Failed to load texture: " << texturePath << std::endl;
    }

    texture.setSmooth(false);
    sprite.setTexture(texture);
}

void DrawableEntity::_setPosition(const float x, const float y) {
    startPosition = position;
    targetPosition = sf::Vector2f(x, y);
    position = targetPosition;
    moveDuration = 0;
    moveElapsed = 0.f;
    moving = false;
    sprite.setPosition(position);
}

sf::Sprite& DrawableEntity::getSprite() {
    return sprite;
}

void DrawableEntity::moveTo(const float x, const float y, const float timeToMove) {
    startPosition = position;
    targetPosition = sf::Vector2f(x, y);
    moveDuration = timeToMove;
    moveElapsed = 0.f;
    moving = timeToMove > 0.f;

    if (!moving) {
        position = targetPosition;
        sprite.setPosition(position);
    };
}

void DrawableEntity::_setTexture(const sf::Texture &_texture) {
    texture = _texture;
    sprite.setTexture(texture, true);
}

sf::Vector2i DrawableEntity::getRelativePosition() const {
    return {static_cast<int>(targetPosition.x) / 64, static_cast<int>(targetPosition.y) / 64};
}

bool DrawableEntity::isMoving() const {
    return moving;
}

void DrawableEntity::render(sf::RenderWindow &window) {
    window.draw(sprite);
}

void DrawableEntity::update(const float deltaTime) {
    if (!moving) return;

    moveElapsed += deltaTime;
    float t = moveElapsed / moveDuration;

    if (t >= 1.f) {
        t = 1.f;
        moving = false;
    }

    position = startPosition + (targetPosition - startPosition) * t;
    sprite.setPosition(position);
}

int DrawableEntity::getHeight() const {
    return static_cast<int>(sprite.getGlobalBounds().height / sprite.getScale().y);
}


// src/Label.cpp
#include <iostream>
#include <ostream>
#include <DangerousRacers/Label.h>

Label::Label(const std::string &labelString, const sf::Vector2f position, const bool _center, const bool _outline) {
    center = _center;
    outline = _outline;

    static bool fontLoaded = false;
    static sf::Font font;

    if (!fontLoaded) {
        std::cout << "Loading font..." << std::endl;
        fontLoaded = true;
        font.loadFromFile("assets/jersey.ttf");
        font.setSmooth(false);
    }

    labelText.setFont(font);
    // labelText.setString(labelString);
    // labelText.setPosition(position);

    labelText.setCharacterSize(32);
    labelText.setFillColor(darkMode ? sf::Color::Black : sf::Color::White);
    if (outline) {
        labelText.setOutlineColor(darkMode ? sf::Color::White : sf::Color::Black);
        labelText.setOutlineThickness(2);
    }

    setText(labelString);
    setPosition(position);
}

void Label::setText(const std::string &labelString) {
    labelText.setString(labelString);
    if (center) labelText.setOrigin(labelText.getLocalBounds().width / 2, labelText.getLocalBounds().height / 2);
}

void Label::setPosition(const sf::Vector2f position) {
    if (center) labelText.setOrigin(labelText.getLocalBounds().width / 2, labelText.getLocalBounds().height / 2);
    labelText.setPosition(position);
}

void Label::render(sf::RenderWindow &window) const {
    window.draw(labelText);
}


// src/main.cpp
#include <SFML/Graphics.hpp>

#include "DangerousRacers/SceneManager.h"
#include "DangerousRacers/GameManager.h"
#include "DangerousRacers/Scenes/GameOver.h"
#include "DangerousRacers/Scenes/MainMenu.h"
#include "DangerousRacers/Scenes/studio_splashscreen.h"
#include "DangerousRacers/Scenes/TutorialOver.h"
#include "DangerousRacers/Scenes/Levels/tutorial_level.h"

int main() {
    // Setup View related stuffs
    sf::Vector2u RESOLUTION(405, 720);
    sf::VideoMode VIDEO_MODE = sf::VideoMode::getDesktopMode();
    sf::RenderWindow GAME_WINDOW;

    GAME_WINDOW.create(sf::VideoMode(RESOLUTION.x, RESOLUTION.y), "SFML Game", sf::Style::None);

    GAME_WINDOW.setMouseCursorVisible(true);
    GAME_WINDOW.setMouseCursorGrabbed(true);

    // Make sure the background is black
    sf::RectangleShape bg_rect(sf::Vector2f(static_cast<float>(RESOLUTION.x), static_cast<float>(RESOLUTION.y)));
    bg_rect.setFillColor(sf::Color::Black);

    // THe big bad delta clock
    sf::Clock deltaClock;

    auto gameManager = std::make_unique<GameManager>();
    auto sceneManager = std::make_unique<SceneManager>(GAME_WINDOW, *gameManager);

    sceneManager->addScene("StudioSplashScreenScene",[&] {
        return std::make_unique<StudioSplashScreenScene>(*sceneManager);
    });
    sceneManager->addScene("MainMenu",[&] {
        return std::make_unique<MainMenuScene>(*sceneManager);
    });
    sceneManager->addScene("DebugLevelScene",[&] {
       return std::make_unique<DebugLevelScene>(*sceneManager);
    });
    sceneManager->addScene("TutorialOverScene",[&] {
        return std::make_unique<TutorialOverScene>(*sceneManager);
    });

    sceneManager->changeScene("StudioSplashScreenScene");

    while (GAME_WINDOW.isOpen()) {
        sf::Event event;
        while (GAME_WINDOW.pollEvent(event)) {
            if (event.type == sf::Event::Closed) {
                sceneManager->_quit();
            }

            if ((event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Escape)) {
                if (sceneManager->getCurrentScene() != "MainMenu") sceneManager->changeScene("MainMenu");
                else sceneManager->_quit();
            }

            sceneManager->eventHandler(event);
        }

        float deltaTime = deltaClock.restart().asSeconds();

        sceneManager->update(deltaTime);

        GAME_WINDOW.clear();
        GAME_WINDOW.draw(bg_rect);
        sceneManager->render(GAME_WINDOW);
        GAME_WINDOW.display();
    }

    return 0;
}


// src/Meter.cpp
#include "DangerousRacers/Meter.h"

Meter::Meter(const int x, const int y, const float w, const float h, const sf::Color color, const float value) {
    for (const auto& shape : {&outline, &fillBar}) {
        shape->setSize({ w, h });
        shape->setOrigin(0, h);
        shape->setPosition(x, y);
    }

    outline.setFillColor(sf::Color::Transparent);
    outline.setOutlineColor(color);
    outline.setOutlineThickness(2);

    fillBar.setFillColor(color);
    setValue(.5f);
}

void Meter::setValue(const float value) {
    fillBar.setScale(1, value);
}

void Meter::render(sf::RenderWindow &window) const {
    for (const auto& shape : {&outline, &fillBar}) {
        window.draw(*shape);
    }
}


// src/Obstacles/Obstacle.cpp
#include "DangerousRacers/Obstacles/Obstacle.h"

#include <iostream>

Obstacle::Obstacle(const float x, const float y, float& speed) : DrawableEntity(x, y, "assets/Obstacles/traffic_cone.png"), speed(speed) {
    sprite.setOrigin(sprite.getLocalBounds().width / 2, sprite.getLocalBounds().height / 2);
    sprite.setScale(2.f, 2.f);
}

void Obstacle::render(sf::RenderWindow &window) {
    DrawableEntity::render(window);
}

void Obstacle::update(const float deltaTime) {
    DrawableEntity::update(deltaTime);

    const sf::Vector2f position = this->getPosition();
    this->moveTo(position.x, position.y + speed * deltaTime, 0.f);
}

// src/Obstacles/ObstacleManager.cpp
#include "DangerousRacers/Obstacles/ObstacleManager.h"

ObstacleManager::ObstacleManager(float& sceneSpeed) : sceneSpeed(sceneSpeed) {

}

void ObstacleManager::reset() {
    obstacles.clear();
}

void ObstacleManager::render(sf::RenderWindow &window) {
    for (const auto& obstacle : obstacles) {
        obstacle->render(window);
    }
}

void ObstacleManager::update(const float deltaTime) {
    unsigned char i = 0;
    for (const auto& obstacle : obstacles) {
        if (obstacle == nullptr) return;
        obstacle->update(deltaTime);
        if (!obstacle->outOfBounds()) {
            i++;
            continue;
        }

        //TODO: Delete obstacle
        obstacles.erase(obstacles.begin() + i);
        i++;
    }
}

void ObstacleManager::spawnObstacle(const float x, const float y) {
    float spawnX = 32 + rand() % (405-64), spawnY = -32.f;

    if (y != 0.f) {
        spawnX = x;
        spawnY = y;
    }

    const auto obstacle = new Obstacle(spawnX, spawnY, this->sceneSpeed);
    obstacles.push_back(std::unique_ptr<Obstacle>(obstacle));
}

bool ObstacleManager::obstacleCollides(const sf::FloatRect &collisionObject) const {
    for (const auto& obstacle : obstacles) {
        if (obstacle->getSprite().getGlobalBounds().intersects(collisionObject)) return true;
    }
    return false;
}


// src/Player.cpp
#include "DangerousRacers/Player.h"

Player::Player(const float x, const float y) : AnimatedSprite(x, y, "assets/car-animated.png", 2, 3) {
    sprite.setOrigin(sprite.getLocalBounds().width / 2, sprite.getLocalBounds().height / 2);
    sprite.setScale(2.f, 2.f);
}

void Player::render(sf::RenderWindow &window) {
    AnimatedSprite::render(window);
}

void Player::update(const float deltaTime) {
    AnimatedSprite::update(deltaTime);
}


// src/Scene.cpp
#include <DangerousRacers/Scene.h>

void Scene::start() {
    clock.restart();
}

void Scene::leave() {

}

void Scene::update(const float deltaTime) {

}

void Scene::render(sf::RenderWindow& window) {

}

void Scene::eventHandler(sf::Event& event) {

}

// src/SceneManager.cpp
#include <iostream>
#include <ostream>
#include <DangerousRacers/SceneManager.h>
#include "DangerousRacers/Scene.h"

SceneManager::SceneManager(sf::RenderWindow& gameWindow, GameManager& gameManager) :
gameWindow(gameWindow), gameManager(gameManager) {

}

void SceneManager::changeScene(const std::string& sceneName) {
    std::cout << "Changing scene to " << sceneName << std::endl;
    const auto& factory = sceneFactories.at(sceneName);
    if (!factory) {
        std::cout << "Scene not found?" << std::endl;
        return;
    };
    if (currentScene != nullptr) currentScene->leave();
    currentScene = factory();
    activeScene = sceneName;
    currentScene->start();
}

void SceneManager::update(const float deltaTime) const {
    if (currentScene == nullptr) return;
    currentScene->update(deltaTime);
}

void SceneManager::render(sf::RenderWindow& window) const {
    if (currentScene == nullptr) return;
    currentScene->render(window);
}

void SceneManager::eventHandler(sf::Event &event) const {
    if (currentScene == nullptr) return;
    currentScene->eventHandler(event);
}

void SceneManager::_quit() {
    sceneFactories.clear();
    currentScene = nullptr;
    this->gameWindow.close();
}


// src/Scenes/GameOver.cpp
#include "DangerousRacers/Scenes/GameOver.h"

GameOverScene::GameOverScene(SceneManager &_sceneManager) : Scene(_sceneManager, "GameOverScene") {
    if (!wallTileLoaded) {
        wallTileTexture.loadFromFile("assets/wall-tile.png");
        wallTileTexture.setSmooth(false);
        wallTileTexture.setRepeated(true);
        wallTileLoaded = true;
    }

    // 768
    wallTile.setSize({576.f, 768.f});
    wallTile.setTexture(&wallTileTexture);
    wallTile.setTextureRect({0, 0, 576/2, 768/2});
    // wallTile.setFillColor(sf::Color::Red);
}

void GameOverScene::start() {
    Scene::start();

    scoreLabel.setText(
        "Game Over!\n\n"
        "Score: " + std::to_string(sceneManager.getGameManager().getScore()) + "\n"
        "Bubbles Popped: " + std::to_string(sceneManager.getGameManager().getBubblesPopped())
        );
}

void GameOverScene::update(const float deltaTime) {
    Scene::update(deltaTime);
}

void GameOverScene::render(sf::RenderWindow &window) {
    Scene::render(window);
    window.draw(wallTile);
    scoreLabel.render(window);
}

void GameOverScene::eventHandler(sf::Event &event) {
    Scene::eventHandler(event);
}

// src/Scenes/Levels/tutorial_level.cpp
#include <iostream>
#include <ostream>
#include <DangerousRacers/Scenes/Levels/tutorial_level.h>

#include "SFML/Window/Event.hpp"

DebugLevelScene::DebugLevelScene (SceneManager& _sceneManager) : Scene (_sceneManager, "DebugLevelScene") {
    backgroundTexture.loadFromFile("assets/racing_bg.png");
    backgroundSprite.setTexture(backgroundTexture);
    backgroundSprite.setPosition(0, -720);
}

void DebugLevelScene::leave() {
    sceneManager.getGameWindow().setMouseCursorVisible(true);
}

void DebugLevelScene::reset() {
    obstacleManager.reset();
    reverseTime = false;
    bgYOffset = -720.f;
    speed = 200.f;

    player.moveTo(405.f/2, 720.f/2, 0.f);
}

void DebugLevelScene::start() {
    Scene::start();
    reset();
    sceneManager.getGameWindow().setMouseCursorVisible(false);

    obstacleManager.spawnObstacle(405*0.25f, -900.f);
    obstacleManager.spawnObstacle(405*0.5f, -500.f);
    obstacleManager.spawnObstacle(405*0.75f, -900.f);
}

void DebugLevelScene::update (const float deltaTime) {
    if (reverseTime && timeInReverse >= 2.5f) reverseTime = false;
    const float delta = reverseTime ? -deltaTime : deltaTime;

    Scene::update(delta);
    // Update player movement before anything else
    player.update(delta);

    // Check for collisions
    if (!reverseTime && obstacleManager.obstacleCollides(player.getSprite().getGlobalBounds())) {
        std::cout << "Collision!\n";
        reverseTime = true;
        timeInReverse = 0.f;
    }

    // Scroll BG
    bgYOffset += delta * speed;
    if (bgYOffset >= 0) bgYOffset = -720.f;
    else if (bgYOffset < -720.f) bgYOffset = 0.f;
    backgroundSprite.setPosition(0, bgYOffset);

    // Move obstacles (and maybe spawn?)
    obstacleManager.update(delta);

    if (reverseTime) timeInReverse += std::abs(delta);
    distanceTraveled += delta * speed;
    scoreLabel.setText("Distance: " + std::to_string(static_cast<int>(distanceTraveled)));

    fuel -= delta * 0.025f;
    if (fuel <= 0) {
        // Tutorial Over
        sceneManager.changeScene("TutorialOverScene");
        return;
    }

    fuelMeter.setValue(fuel);
    damageMeter.setValue(health);

    if (currentTutorial >= tutorialDistance.size()) return;
    if (distanceTraveled >= tutorialDistance[currentTutorial]) currentTutorial++;
}

void DebugLevelScene::render (sf::RenderWindow& window) {
    Scene::render (window);
    window.draw(backgroundSprite);

    obstacleManager.render(window);

    // Draw player here, to be on top of obstacles
    player.render(window);

    // Draw UI components last
    scoreLabel.render(window);

    if (currentTutorial >= 1) fuelMeter.render(window);
    if (currentTutorial >= 2) damageMeter.render(window);

    if (currentTutorial >= tutorialLabels.size()) return;
    tutorialLabels[currentTutorial].render(window);
}

void DebugLevelScene::eventHandler (sf::Event& event) {
    Scene::eventHandler (event);

    if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Escape) {
        this->sceneManager.changeScene("MainMenu");
        return;
    }

    if (reverseTime) {
        const sf::Vector2 playerPos = player.getPosition();
        player.moveTo(playerPos.x, playerPos.y, 0.f);
        return;
    }

    if (event.type == sf::Event::MouseMoved) {
        int x = event.mouseMove.x;
        if (x < 32) x = 32; else if (x > 373) x = 373;
        player.moveTo(x, player.getPosition().y, 0.025f);
    }
}

// src/Scenes/MainMenu.cpp
#include <DangerousRacers/Scenes/MainMenu.h>

#include "SFML/Window/Event.hpp"

MainMenuScene::MainMenuScene(SceneManager& _sceneManager) : Scene (_sceneManager, "MainMenu") {
    backgroundTexture.loadFromFile("assets/background.png");
    backgroundSprite.setTexture(backgroundTexture);

    titleTexture.loadFromFile("assets/title.png");
    titleSprite.setTexture(titleTexture);
    titleSprite.setOrigin(titleTexture.getSize().x / 2, titleTexture.getSize().y / 2);
    titleSprite.setPosition(405.f / 2.f, 720.f / 6.f);
}

void MainMenuScene::start() {
    Scene::start();
}

void MainMenuScene::update(const float deltaTime) {
    Scene::update(deltaTime);

    tutorialButton.update(deltaTime);
}

void MainMenuScene::render(sf::RenderWindow &window) {
    Scene::render(window);
    window.draw(backgroundSprite);
    window.draw(titleSprite);
    
    tutorialButton.render(window);
}

void MainMenuScene::eventHandler(sf::Event &event) {
    Scene::eventHandler(event);

    tutorialButton.eventHandler(event);
}

void MainMenuScene::startTutorialLevel() const {
    sceneManager.changeScene("DebugLevelScene");
}


// src/Scenes/studio_splashscreen.cpp
#include <DangerousRacers/Scenes/studio_splashscreen.h>

#include "SFML/Graphics/Texture.hpp"
#include "SFML/Graphics/Sprite.hpp"
#include "SFML/Window/Event.hpp"

StudioSplashScreenScene::StudioSplashScreenScene (SceneManager& _sceneManager) : Scene (_sceneManager, "StudioSplashScreenScene") {
    logoTexture.loadFromFile("assets/StudioLogo.png");
    logoSprite.setTexture(logoTexture);
    logoSprite.setOrigin(logoTexture.getSize().x / 2, logoTexture.getSize().y / 2);
    logoSprite.setPosition(405.f / 2.f, 720.f / 2.f);
    logoSprite.setColor({255, 255, 255, 0});
}

void StudioSplashScreenScene::start() {
    Scene::start();
}

void StudioSplashScreenScene::update (const float deltaTime) {
    Scene::update (deltaTime);

    if (fadingIn && this->clock.getElapsedTime().asSeconds() > fadeTime) {
        fadingIn = false;
        this->clock.restart();
    } else if (!fadingIn && this->clock.getElapsedTime().asSeconds() > fadeTime) {
        this->sceneManager.changeScene("MainMenu");
        return;
    }

    float percent = this->clock.getElapsedTime().asSeconds() / fadeTime;

    if (!fadingIn) percent = 1.f - percent;

    logoSprite.setColor({255, 255, 255, static_cast<sf::Uint8>(255 * percent)});
}

void StudioSplashScreenScene::render (sf::RenderWindow& window) {
    Scene::render (window);
    window.draw(logoSprite);
}

void StudioSplashScreenScene::eventHandler (sf::Event& event) {
    Scene::eventHandler (event);

    if (event.type == sf::Event::JoystickButtonPressed || event.type == sf::Event::KeyPressed) {
        this->sceneManager.changeScene("MainMenu");
    }
}

// src/Scenes/TutorialOver.cpp
#include "DangerousRacers/Scenes/TutorialOver.h"

#include "SFML/Window/Event.hpp"
#include "SFML/Window/Keyboard.hpp"

TutorialOverScene::TutorialOverScene(SceneManager &_sceneManager) : Scene(_sceneManager, "TutorialOverScene") {
    if (!wallTileLoaded) {
        wallTileTexture.loadFromFile("assets/wall-tile.png");
        wallTileTexture.setSmooth(false);
        wallTileTexture.setRepeated(true);
        wallTileLoaded = true;
    }

    // 768
    wallTile.setSize({576.f, 768.f});
    wallTile.setTexture(&wallTileTexture);
    wallTile.setTextureRect({0, 0, 576/2, 768/2});
    // wallTile.setFillColor(sf::Color::Red);
}

void TutorialOverScene::start() {
    Scene::start();
}

void TutorialOverScene::update(const float deltaTime) {
    Scene::update(deltaTime);
}

void TutorialOverScene::render(sf::RenderWindow &window) {
    Scene::render(window);
    window.draw(wallTile);
    gameOverLabel.render(window);
    returnButton.render(window);
}

void TutorialOverScene::eventHandler(sf::Event &event) {
    Scene::eventHandler(event);
    returnButton.eventHandler(event);

    if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Escape) {
        this->sceneManager.changeScene("MainMenu");
    }
}