#include "../std_lib_inc.h"
#include "../Util/Vector2d.h"

#ifndef MAZE_H
#define MAZE_H

namespace game
{
  class Player;
  class Entity;

  /// Ein Labyrinth.
  /// Besitzt ein Feld
  class Maze
  {
    // class -> members private by default
  private:
    /// Das Spielfeld
    vector<vector<char>> field;
    /// Die Startposition des Spielers
    Vector2d player_start_position;
    /// Eine Liste an Gegnern
    vector<Entity> enemies;

  public:
    /// Das Spielfeld
    Maze(const Vector<Vector<char>>& play_field, const Vector<int>& player_start_position, const Vector<Entity>& enemies);
    /// Kontrolliere, ob der Spieler stirbt
    /// @param player Der Spieler
    /// @return Ob der Spieler tot ist
    bool was_player_killed_by_ghost(const Player& player) const;

    /// Kontrolliere, ob der Spieler am Ziel ist
    /// @param player Der Spieler
    /// @return Ob der Spieler am Ziel ist
    bool is_player_at_goal(const Player& player) const;

    /// Kontrolliere, ob eine bestimmte Position begehbar ist
    /// @param pos Die Position, die überprüft werden soll
    /// @param player_has_key If the player has at least one key
    /// @return Ob die Position begehbar ist
    bool is_pos_free(const Vector2d& pos, const bool& player_has_key) const;

    /// Zeige das Spielfeld in der Konsole an
    /// @param player Der Spieler
    /// @param infomode_enabled Ob der Infomode aktiv ist
    void render(const Player& player, vector<Entity> entities, const bool& infomode_enabled);

    /// Kriege den Wert einer Position
    /// @param pos Die gewollte Position
    /// @return Der Wert der Position
    char get_field(const Vector2d& pos) const;

    /// Ersetze den Wert von einer Position
    /// @param pos Die Position die ersetzt werden soll
    /// @param target Der Wert, auf den die Position gesetzt werden soll
    void update_field(const Vector2d& pos, const char& target);

    /// Kriege die Startposition des Spielers
    /// @return Die Startposition des Spielers
    Vector2d get_player_start_position() const;

    /// Berrechne den Abstand zwischen zwei Vektoren
    /// @return Der Abstand als Differenzvektor
    Vector2d get_delta_vector(const Vector2d& pos1, const Vector2d& pos2) const;

    /// Berechne wie viele Schritte benötigt werden, um das Labyrinth zu schaffen
    /// @warning Steps nicht zu groß setzen! Diese Funktion ist 4-fach rekursiv!
    /// @param position Die Startposition
    /// @param steps Wie viele Schritte maximal gegangen werden sollten
    /// @returns Wie viele Schritte benötigt werden
    int calculate_steps_until_win(const Vector2d& position, const int& steps);

    /// Kriege alle eingelesenen Entities
    vector<Entity> get_entities();
  };
} // game

#endif //MAZE_H