#include <iostream>
#include <print>
#include <string>
#include <vector>
#include <variant>
#include <cctype>

class Tile
{
public:
    Tile() = default;

    enum class VariableName
    {
        BaseLayerTile,
        CharacterTile,
        HasCollision
    };

    using VariableType = std::variant<char, bool>;

    VariableType GetVariable(VariableName variable) const
    {
        switch (variable)
        {
        case VariableName::BaseLayerTile: return mBaseLayerTile;
        case VariableName::CharacterTile: return mCharacterLayerTile;
        case VariableName::HasCollision: return mHasCollision;
        }

        return {}; // Should never reach here
    }

    void SetVariable(VariableName variable, char newTile = '\0', bool newState = false)
    {
        switch (variable)
        {
        case VariableName::BaseLayerTile:
            mBaseLayerTile = newTile;
            break;

        case VariableName::CharacterTile:
            mCharacterLayerTile = newTile;
            break;

        case VariableName::HasCollision:
            mHasCollision = newState;
            break;
        }
    }

    void ClearCharacterLayer()
    {
        mCharacterLayerTile = '\0'; // Clears the character after rendering
    }

private:
    char mBaseLayerTile{ '.' };
    char mCharacterLayerTile{ '\0' };
    bool mHasCollision{ false };
};

class Map
{
public:
    Map(int height, int width, char tile)
        : mHeight(height), mWidth(width), mTile(tile), mMap(mHeight, std::vector<Tile>(mWidth, Tile()))
    {
    }

    enum class VariableName
    {
        Height,
        Width,
        Tile
    };

    using VariableType = std::variant<int, char>;

    VariableType GetVariable(VariableName variable) const
    {
        switch (variable)
        {
        case VariableName::Height: return mHeight;
        case VariableName::Width: return mWidth;
        case VariableName::Tile: return mTile;
        }

        return {}; // Should never reach here
    }

    void Draw()
    {
        for (int y = 0; y < mHeight; ++y)
        {
            for (int x = 0; x < mWidth; ++x)
            {
                Tile& tile = mMap[y][x];

                if (std::get<char>(tile.GetVariable(Tile::VariableName::CharacterTile)) != '\0')
                {
                    std::print("{} ", std::get<char>(tile.GetVariable(Tile::VariableName::CharacterTile)));
                }
                else if (std::get<bool>(tile.GetVariable(Tile::VariableName::HasCollision)))
                {
                    std::print("X ");
                }
                else
                {
                    std::print("{} ", std::get<char>(tile.GetVariable(Tile::VariableName::BaseLayerTile)));
                }
            }
            std::print("\n");
        }

        // Clear character layer after drawing so it doesn't remain permanently
        for (auto& row : mMap)
        {
            for (auto& tile : row)
            {
                tile.ClearCharacterLayer();
            }
        }
    }

    void SetCharacterAt(int y, int x, char character)
    {
        if (IsInBounds(y, x))
        {
            mMap[y][x].SetVariable(Tile::VariableName::CharacterTile, character);
        }
    }

    void SetCollision(int y, int x, bool hasCollision)
    {
        if (IsInBounds(y, x))
        {
            mMap[y][x].SetVariable(Tile::VariableName::HasCollision, {}, hasCollision);
        }
    }

    bool CheckCollision(int y, int x) const
    {
        return IsInBounds(y, x) && std::get<bool>(mMap[y][x].GetVariable(Tile::VariableName::HasCollision));
    }

    bool IsInBounds(int y, int x) const
    {
        return y >= 0 && y < mHeight && x >= 0 && x < mWidth;
    }

private:
    int mHeight{};
    int mWidth{};
    char mTile{};

    std::vector<std::vector<Tile>> mMap;
};

class Character
{
public:
    Character(char sprite, int startY, int startX)
        : mSprite(sprite), mPositionY(startY), mPositionX(startX)
    {
    }

    void Move(Map& map, char direction)
    {
        int nextY = mPositionY;
        int nextX = mPositionX;

        switch (direction)
        {
        case 'w': --nextY; break;
        case 's': ++nextY; break;
        case 'a': --nextX; break;
        case 'd': ++nextX; break;
        default:
            std::print("Invalid input!\n");
            return;
        }

        if (!map.IsInBounds(nextY, nextX))
        {
            std::print("Can't move out of bounds!\n");
            return;
        }

        if (map.CheckCollision(nextY, nextX))
        {
            std::print("You can't move there! It's blocked.\n");
            return;
        }

        mPositionY = nextY;
        mPositionX = nextX;
    }

    void PlaceOnMap(Map& map)
    {
        map.SetCharacterAt(mPositionY, mPositionX, mSprite);
    }

private:
    int mPositionY{};
    int mPositionX{};
    char mSprite{};
};

int main()
{
    Map test(10, 10, '.');
    Character player('O', 4, 4);

    test.SetCollision(5, 5, true); // Set a wall at (5,5)
    test.SetCollision(2, 2, true); // Another collision tile for testing

    bool gameOver{ false };

    while (!gameOver)
    {
        player.PlaceOnMap(test);
        test.Draw();

        std::print("\n{}\n\n", "Move Where?");
        std::print("\n{}\n", "W). Up");
        std::print("{}\n", "S). Down");
        std::print("{}\n", "A). Left");
        std::print("{}\n", "D). Right");

        char input{};
        std::cin >> input;

        input = std::tolower(input);
        player.Move(test, input);
    }
}