#pragma once

#include <glm/glm.hpp>
#include <map>
#include <memory>
#include <random>
#include "../../../engine/resources.h"

const float GR_OBJ_SCALE{0.5f};      /// Object scale reduction from blender 1x1
const float GR_WALL_OFFSET{0.425f};  /// Wall offset to line up no edge of floor
const float GR_CORNER_OFFSET{0.5f};  /// Corner offset for floor from walls
#define GR_ENTITY_FLOOR "EntityF_"
#define GR_ENTITY_WALL "EntityW_"
#define GR_FLOOR "Floor_"
#define GR_DOOR "Door_"
#define GR_WALL "Wall_"
#define GR_ROTATION "Rotation_"

/**
 * @class gameRoom
 * @brief A class to create a room according to a size, location, and models.
 *
 * @author Chase Percy
 *
 */
class gameRoom {
   public:
    struct RoomModels {
        std::vector<std::shared_ptr<Model>> floors;
        std::vector<std::shared_ptr<Model>> walls;
        std::shared_ptr<Model> debugCube{nullptr};
        std::shared_ptr<Model> debugSphere{nullptr};
    };

    /**
     * Generates a room given a x,z, an origin (bottom left), and a set of
     * models
     * @param x the size of the room on the x axis
     * @param z the size of the room on the z axis
     * @param wallFillPercent The percent of the walls to fill with decorations
     * @param floors the floors for the room, the first element is the default
     * floor
     * @param floorFillPercent The percent of the floor to fill with decoration.
     * @param xOrigin the x origin of the room
     * @param zOrigin the z origin of the room
     * @param roomModels the models for the room
     * @param seed the seed for room generation
     *
     */
    gameRoom(int x,
             int z,
             int wallFillPercent,
             int floorFillPercent,
             int xOrigin,
             int zOrigin,
             const RoomModels& roomModels,
             int seed,
             const std::vector<std::pair<int, int>>& doors);

    ~gameRoom();

    gameRoom() = delete;

    gameRoom(const gameRoom& other);

    gameRoom& operator=(const gameRoom&);

    /**
     * Returns all the wall points for the room
     * @return wall points
     */
    const std::vector<std::vector<glm::vec3>>& getWallPoints() const;

    /**
     * Returns all bounding spheres for entities in the room
     * @return bounding spheres
     */
    const std::vector<std::pair<glm::vec3, float>>& getBoundingSpheres() const;

    glm::vec3 getMin() const;

    glm::vec3 getMax() const;

    /**
     * Draw all objects that represent a room.
     */
    void draw();

    /**
     * Draw all debug data for wall points and bounding spheres.
     */
    void drawDebug();

    /**
     * Returns the coordinates at the centre of the room (used for draw
     * distance)
     * @return the coords at centre of room
     */
    glm::vec3 getLocation() const;

   private:
    struct Dimension {
        int xMax{0};
        int zMax{0};
        int max{0};
    };

    struct Normals {
        glm::vec3 negX{-1, 0, 0};
        glm::vec3 posX{1, 0, 0};
        glm::vec3 negZ{0, 0, -1};
        glm::vec3 posZ{0, 0, 1};
    };

    struct Offset {
        int xMin{0};
        int zMin{0};
        int xMax{0};
        int zMax{0};
        int xCent{0};
        int zCent{0};
    };

    enum accessTypes { wall, floor, empty, floorEntity, wallEntity, door };

    enum direction {
        NaD = -1,
        negZ,
        negX,
        posZ,
        posX
    };  /// NaD is used to represent an invalid direction

    accessTypes* m_accessible{
        nullptr};  /// Array of accessible cells in the room
    std::vector<std::vector<glm::vec3>>
        m_wallPoints{};  /// the wall points for the room
    std::vector<std::pair<glm::vec3, float>>
        m_entityBoundingSpheres{};  /// The bounding spheres of the room's
                                    /// entities
    Dimension m_floor;              /// the dimensions of the floor
    Dimension m_wall;               /// the dimensions of the floor + walls
    Dimension m_dimensions;         /// The dimensions of the room
    Offset m_offset;                /// The offsets for the room
    Normals m_normals;              /// A predefined set of normals to copy
    RoomModels m_models;            /// the models for the room to use
    std::map<std::string, Object> m_objects{};  /// The objects for this room
    bool m_debugData{
        false};  /// Tracks if debug data has been generated or not.
    std::vector<Object> m_debugObjects{};  /// The debug objects fro this room
    int m_seed;                            /// The seed for the room
    int m_randomRotationOffset{0};         /// Offset for random rotations
    std::map<std::string, float> m_rotationAngles;
    std::vector<std::pair<int, int>> m_doors;

    /**
     * Creates a room as specified by the x & z values in the constructor.
     */
    void createRoom();

    /**
     * Creates a wall at a given location
     * @param row the row to create the wall
     * @param col the col to create the wall
     * @param model the model to create the wall as
     */
    void createWallType(int row,
                        int col,
                        std::shared_ptr<Model>& model,
                        accessTypes accessType);

    /**
     * Creates a floor type at a given location
     * @param row the row to create the floor
     * @param col the col to create the floor
     * @param model the model to create the floor as
     * @param accessType the type of floor (entity or standard) being created
     */
    void createFloorType(int row,
                         int col,
                         std::shared_ptr<Model>& model,
                         accessTypes accessType);

    /**
     * Checks if a element at row,col is a wall.
     * @param row the row to check
     * @param col the col to check
     * @return true if a wall, else false
     */
    bool isWall(int row, int col) const;

    /**
     * Checks if a element is a corner
     * @param row the row to check
     * @param col the col to check
     * @return true if a corner, else false
     */
    bool isCorner(int row, int col) const;

    /**
     * Adds decoration to the room up to the fillPercent's
     * @param floorPercent the amount of the floors to fill
     * @param wallPercent the amount of the walls to fill
     */
    void addDecoration(float floorPercent, float wallPercent);

    /**
     * Returns a 0, 90, 180, 270 angle randomly
     * @return an angle
     */
    float randomRotation();

    /**
     * returns an integer representing an enum in direction based on the walls
     * position.
     * @param row the row to check
     * @param col the col to check
     * @return the walls direction enum
     */
    direction wallPosition(int row, int col) const;

    /**
     * Update a wall points location so that it aligns properly with the offset
     * @param location the wall location to update
     * @param wallPos the current wall direction enum
     */
    void updateWallPointLocation(glm::vec3& location, direction wallPos) const;

    /**
     * Gets a normal for a wall based on its current wall direction enum
     * @param wallPos the wall direction enum
     * @return the normal for the wall
     */
    glm::vec3 getNormal(direction wallPos) const;

    /**
     * Gets the index based on row and col for the accessible array
     * @param row the row to find
     * @param col the col to find
     * @return the index
     */
    std::size_t getIndex(int row, int col) const;

    /**
     * Generates the wall points for the room
     */
    void generateWallPoints();

    /**
     * Inserts the wall points into the wall vector based on their direction and
     * position.
     * @param row the row to check for a wall
     * @param col the col to check for a wall
     * @param wall the wall vector
     * @param pOneInserted if the first point has been inserted
     * @param wallCount the number of wall accessTypes connected to the wall
     * @param dir the location of the wall
     */
    void insertWallPoints(int row,
                          int col,
                          std::vector<glm::vec3>& wall,
                          bool& pOneInserted,
                          int& wallCount,
                          direction dir);

    /**
     * Creates the bounding sphere objects for the entities in the scene
     */
    void generateEntityBoundingSpheres();

    /**
     * Create all debug objects.
     */
    void generateDebugData();

    /**
     * Set the door locations for the room
     */
    void setDoors();

    /**
     * Make sure that doors arent blocked and that there is a way to get to each
     * wall.
     * @param start the starting location to walk from.
     * @param doorAxis the axis the door is aligned with
     */
    void walkRoom(std::pair<int, int> start, direction doorAxis);

    /**
     * Checks if a position in m_accessible is a floor type
     * @param row the row to check
     * @param col the col to check
     * @return true if floor type, else false.
     */
    bool isFloor(int row, int col) const;

    /**
     * Checks if a position in m_accessible is a floor entity type
     * @param row the row to check
     * @param col the col to check
     * @return true if floor entity type, else false.
     */
    bool isFloorEntity(int row, int col) const;

    /**
     * Removes a floor entity at row & col and replaces it with a floor type.
     * @param row the row to remove it from
     * @param col the col to remove it from
     */
    void removeFloorEntity(int row, int col);

    /**
     * Updates the walking position for the walkRoom function based on the
     * direction the door started at.
     * @param walking the walking variable to update
     * @param dir the direction the door started at
     */
    void updateWalking(int& walking, direction dir);

    /**
     * Sets the strafe start and end variable in the walkRoom function.
     * @param strafe The strafe variable to set
     * @param strafeEnd The strafe end variable to set
     * @param dir The direction of the door
     * @param row The current row
     * @param col The current col
     */
    void setStrafe(int& strafe,
                   int& strafeEnd,
                   direction dir,
                   int row,
                   int col) const;

    /**
     * Checks if the strafe position is colliding with any entities at its
     * current position or current position + 1 in the walking direction.
     * @param strafe The current strafe position
     * @param dir The direction of the door
     * @param row The current row
     * @param col The current col
     * @return {true, true} if next position is valid. {true, false} if strafe
     * position is valid but walk position is not. {false, false} is strafe
     * position isn't valid.
     */
    std::pair<bool, bool> checkStrafeCollision(int strafe,
                                               direction dir,
                                               int& row,
                                               int& col) const;

    /**
     * Moves the row and col values forward based on the door location.
     * @param row the row to increase/decrease.
     * @param col the col to increase/decrease.
     * @param dir The direction of the door.
     */
    void walkForward(int& row, int& col, direction dir);

    /**
     * Set the starting & ending points for the walking variables based on the
     * doors direction.
     * @param start The starting spot for walking
     * @param end The ending spot for walking
     * @param dir The direction of the door
     */
    void setWalkingStart(int& start, int& end, direction dir);
};