#pragma once

#include "StarImage.hpp"
#include "StarItemDescriptor.hpp"
#include "StarWorldGeometry.hpp"
#include "StarGameTypes.hpp"
#include "StarRandom.hpp"
#include "StarSet.hpp"
#include "StarThread.hpp"
#include "StarLruCache.hpp"

namespace Star {

STAR_EXCEPTION(DungeonException, StarException);

STAR_CLASS(DungeonGeneratorWorldFacade);
STAR_CLASS(DungeonDefinition);
STAR_CLASS(DungeonDefinitions);

class DungeonGeneratorWorldFacade {
public:
  virtual ~DungeonGeneratorWorldFacade() {}

  // Hint that the given rectangular region is dungeon generated, and thus
  // would not receive the normal entity generation steps.
  virtual void markRegion(RectI const& region) = 0;
  // Mark the region as needing terrain to properly integrate with the dungeon
  virtual void markTerrain(PolyF const& region) = 0;
  // Mark the region as needing space to properly integrate with the dungeon
  virtual void markSpace(PolyF const& region) = 0;

  virtual void setForegroundMaterial(Vec2I const& position, MaterialId material, MaterialHue hueshift, MaterialColorVariant colorVariant) = 0;
  virtual void setBackgroundMaterial(Vec2I const& position, MaterialId material, MaterialHue hueshift, MaterialColorVariant colorVariant) = 0;
  virtual void setForegroundMod(Vec2I const& position, ModId mod, MaterialHue hueshift) = 0;
  virtual void setBackgroundMod(Vec2I const& position, ModId mod, MaterialHue hueshift) = 0;
  virtual void placeObject(Vec2I const& pos, String const& objectName, Star::Direction direction, Json const& parameters) = 0;
  virtual void placeVehicle(Vec2F const& pos, String const& vehicleName, Json const& parameters) = 0;
  virtual void placeSurfaceBiomeItems(Vec2I const& pos) = 0;
  virtual void placeBiomeTree(Vec2I const& pos) = 0;
  virtual void addDrop(Vec2F const& position, ItemDescriptor const& item) = 0;
  virtual void spawnNpc(Vec2F const& position, Json const& parameters) = 0;
  virtual void spawnStagehand(Vec2F const& position, Json const& definition) = 0;
  virtual void setLiquid(Vec2I const& pos, LiquidStore const& liquid) = 0;
  virtual void connectWireGroup(List<Vec2I> const& wireGroup) = 0;
  virtual void setTileProtection(DungeonId dungeonId, bool isProtected) = 0;
  virtual bool checkSolid(Vec2I const& position, TileLayer layer) = 0;
  virtual bool checkOpen(Vec2I const& position, TileLayer layer) = 0;
  virtual bool checkOceanLiquid(Vec2I const& position) = 0;
  virtual DungeonId getDungeonIdAt(Vec2I const& position) = 0;
  virtual void setDungeonIdAt(Vec2I const& position, DungeonId dungeonId) = 0;
  virtual void clearTileEntities(RectI const& bounds, Set<Vec2I> const& positions, bool clearAnchoredObjects) = 0;

  virtual WorldGeometry getWorldGeometry() const = 0;

  virtual void setPlayerStart(Vec2F const& startPosition) = 0;
};

namespace Dungeon {
  STAR_CLASS(DungeonGeneratorWriter);
  STAR_CLASS(PartReader);
  STAR_CLASS(Part);
  STAR_CLASS(Rule);
  STAR_CLASS(Brush);
  STAR_STRUCT(Tile);
  STAR_CLASS(Connector);

  class DungeonGeneratorWriter {
  public:
    DungeonGeneratorWriter(DungeonGeneratorWorldFacadePtr facade, Maybe<int> terrainMarkingSurfaceLevel, Maybe<int> terrainSurfaceSpaceExtends);

    Vec2I wrapPosition(Vec2I const& pos) const;

    void setMarkDungeonId(Maybe<DungeonId> markDungeonId = {});

    void requestLiquid(Vec2I const& pos, LiquidStore const& liquid);
    void setLiquid(Vec2I const& pos, LiquidStore const& liquid);
    void setForegroundMaterial(Vec2I const& position, MaterialId material, MaterialHue hueshift, MaterialColorVariant colorVariant);
    void setBackgroundMaterial(Vec2I const& position, MaterialId material, MaterialHue hueshift, MaterialColorVariant colorVariant);
    void setForegroundMod(Vec2I const& position, ModId mod, MaterialHue hueshift);
    void setBackgroundMod(Vec2I const& position, ModId mod, MaterialHue hueshift);
    bool needsForegroundBiomeMod(Vec2I const& position);
    bool needsBackgroundBiomeMod(Vec2I const& position);
    void placeObject(Vec2I const& position, String const& objectType, Direction direction, Json const& parameters);
    void placeVehicle(Vec2F const& pos, String const& vehicleName, Json const& parameters);
    void placeSurfaceBiomeItems(Vec2I const& pos);
    void placeBiomeTree(Vec2I const& pos);
    void addDrop(Vec2F const& position, ItemDescriptor const& item);
    void requestWire(Vec2I const& position, String const& wireGroup, bool partLocal);
    void spawnNpc(Vec2F const& pos, Json const& definition);
    void spawnStagehand(Vec2F const& pos, Json const& definition);
    void setPlayerStart(Vec2F const& startPosition);
    bool checkSolid(Vec2I position, TileLayer layer);
    bool checkOpen(Vec2I position, TileLayer layer);
    bool checkLiquid(Vec2I const& position);
    bool otherDungeonPresent(Vec2I position);
    void setDungeonId(Vec2I const& pos, DungeonId dungeonId);
    void markPosition(Vec2F const& pos);
    void markPosition(Vec2I const& pos);
    void finishPart();

    void clearTileEntities(RectI const& bounds, Set<Vec2I> const& positions, bool clearAnchoredObjects);

    void flushLiquid();
    void flush();

    List<RectI> boundingBoxes() const;

    void reset();

  private:
    struct Material {
      MaterialId material;
      MaterialHue hueshift;
      MaterialColorVariant colorVariant;
    };

    struct Mod {
      ModId mod;
      MaterialHue hueshift;
    };

    struct ObjectSettings {
      ObjectSettings() : direction() {}
      ObjectSettings(String const& objectName, Direction direction, Json const& parameters)
        : objectName(objectName), direction(direction), parameters(parameters) {}

      String objectName;
      Direction direction;
      Json parameters;
    };

    DungeonGeneratorWorldFacadePtr m_facade;
    Maybe<int> m_terrainMarkingSurfaceLevel;
    Maybe<int> m_terrainSurfaceSpaceExtends;

    Map<Vec2I, LiquidStore> m_pendingLiquids;

    Map<Vec2I, Material> m_foregroundMaterial;
    Map<Vec2I, Material> m_backgroundMaterial;
    Map<Vec2I, Mod> m_foregroundMod;
    Map<Vec2I, Mod> m_backgroundMod;

    Map<Vec2I, ObjectSettings> m_objects;
    Map<Vec2F, pair<String, Json>> m_vehicles;
    Set<Vec2I> m_biomeTrees;
    Set<Vec2I> m_biomeItems;
    Map<Vec2F, ItemDescriptor> m_drops;
    Map<Vec2F, Json> m_npcs;
    Map<Vec2F, Json> m_stagehands;
    Map<Vec2I, DungeonId> m_dungeonIds;

    Map<Vec2I, LiquidStore> m_liquids;

    StringMap<Set<Vec2I>> m_globalWires;
    List<Set<Vec2I>> m_localWires;
    StringMap<Set<Vec2I>> m_openLocalWires;

    Maybe<DungeonId> m_markDungeonId;
    RectI m_currentBounds;
    List<RectI> m_boundingBoxes;
  };

  class Rule {
  public:
    static Maybe<RuleConstPtr> parse(Json const& rule);
    static List<RuleConstPtr> readRules(Json const& rules);

    virtual ~Rule() {}

    virtual bool checkTileCanPlace(Vec2I position, DungeonGeneratorWriter* writer) const;

    virtual bool overdrawable() const;
    virtual bool ignorePartMaximum() const;
    virtual bool allowSpawnCount(int currentCount) const;

    virtual bool doesNotConnectToPart(String const& name) const;
    virtual bool checkPartCombinationsAllowed(StringMap<int> const& placementCounter) const;

    virtual bool requiresOpen() const;
    virtual bool requiresSolid() const;
    virtual bool requiresLiquid() const;

  protected:
    Rule() {}
  };

  class WorldGenMustContainAirRule : public Rule {
  public:
    WorldGenMustContainAirRule(TileLayer layer) : layer(layer) {}

    virtual bool checkTileCanPlace(Vec2I position, DungeonGeneratorWriter* writer) const override;

    virtual bool requiresOpen() const override {
      return true;
    }

    TileLayer layer;
  };

  class WorldGenMustContainSolidRule : public Rule {
  public:
    WorldGenMustContainSolidRule(TileLayer layer) : layer(layer) {}

    virtual bool checkTileCanPlace(Vec2I position, DungeonGeneratorWriter* writer) const override;

    virtual bool requiresSolid() const override {
      return true;
    }

    TileLayer layer;
  };

  class WorldGenMustContainLiquidRule : public Rule {
  public:
    WorldGenMustContainLiquidRule() {}

    virtual bool checkTileCanPlace(Vec2I position, DungeonGeneratorWriter* writer) const override;
    
    virtual bool requiresLiquid() const override {
      return true;
    }
  };

  class WorldGenMustNotContainLiquidRule : public Rule {
  public:
    WorldGenMustNotContainLiquidRule() {}

    virtual bool checkTileCanPlace(Vec2I position, DungeonGeneratorWriter* writer) const override;
  };

  class AllowOverdrawingRule : public Rule {
  public:
    AllowOverdrawingRule() {}

    virtual bool overdrawable() const override {
      return true;
    }
  };

  class IgnorePartMaximumRule : public Rule {
  public:
    IgnorePartMaximumRule() {}

    virtual bool ignorePartMaximum() const override {
      return true;
    }
  };

  class MaxSpawnCountRule : public Rule {
  public:
    MaxSpawnCountRule(Json const& rule) {
      m_maxCount = rule.toArray()[1].toArray()[0].toInt();
    }

    virtual bool allowSpawnCount(int currentCount) const override {
      return currentCount < m_maxCount;
    }

  private:
    int m_maxCount;
  };

  class DoNotConnectToPartRule : public Rule {
  public:
    DoNotConnectToPartRule(Json const& rule) {
      for (auto entry : rule.toArray()[1].toArray())
        m_partNames.add(entry.toString());
    }

    virtual bool doesNotConnectToPart(String const& name) const override {
      return m_partNames.contains(name);
    }

  private:
    StringSet m_partNames;
  };

  class DoNotCombineWithRule : public Rule {
  public:
    DoNotCombineWithRule(Json const& rule) {
      for (auto part : rule.toArray()[1].toArray())
        m_parts.add(part.toString());
    }

    virtual bool checkPartCombinationsAllowed(StringMap<int> const& placementCounter) const override {
      for (auto part : m_parts) {
        if (placementCounter.contains(part) && (placementCounter.get(part) > 0))
          return false;
      }
      return true;
    }

  private:
    StringSet m_parts;
  };

  enum class Phase {
    ClearPhase,
    WallPhase,
    ModsPhase,
    ObjectPhase,
    BiomeTreesPhase,
    BiomeItemsPhase,
    WirePhase,
    ItemPhase,
    NpcPhase,
    DungeonIdPhase
  };

  class Brush {
  public:
    static BrushConstPtr parse(Json const& brush);
    static List<BrushConstPtr> readBrushes(Json const& brushes);

    virtual ~Brush() {}

    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const = 0;

  protected:
    Brush() {}
  };

  class RandomBrush : public Brush {
  public:
    RandomBrush(Json const& brush);

    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const override;

  private:
    List<BrushConstPtr> m_brushes;
    int64_t m_seed;
  };

  class ClearBrush : public Brush {
  public:
    ClearBrush() {}

    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const override;
  };

  class FrontBrush : public Brush {
  public:
    FrontBrush(String const& material, Maybe<String> mod, Maybe<float> hueshift, Maybe<float> modhueshift, Maybe<MaterialColorVariant> colorVariant);

    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const override;

  private:
    String m_material;
    MaterialHue m_materialHue;
    MaterialColorVariant m_materialColorVariant;
    Maybe<String> m_mod;
    MaterialHue m_modHue;
  };

  class BackBrush : public Brush {
  public:
    BackBrush(String const& material, Maybe<String> mod, Maybe<float> hueshift, Maybe<float> modhueshift, Maybe<MaterialColorVariant> colorVariant);

    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const override;

  private:
    String m_material;
    MaterialHue m_materialHue;
    MaterialColorVariant m_materialColorVariant;
    Maybe<String> m_mod;
    MaterialHue m_modHue;
  };

  class ObjectBrush : public Brush {
  public:
    ObjectBrush(String const& object, Star::Direction direction, Json const& parameters);

    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const override;

  private:
    String m_object;
    Star::Direction m_direction;
    Json m_parameters;
  };

  class VehicleBrush : public Brush {
  public:
    VehicleBrush(String const& vehicle, Json const& parameters);

    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const override;

  private:
    String m_vehicle;
    Json m_parameters;
  };

  class BiomeItemsBrush : public Brush {
  public:
    BiomeItemsBrush() {}

    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const override;
  };

  class BiomeTreeBrush : public Brush {
  public:
    BiomeTreeBrush() {}

    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const override;
  };

  class ItemBrush : public Brush {
  public:
    ItemBrush(ItemDescriptor const& item);

    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const override;

  private:
    ItemDescriptor m_item;
  };

  class NpcBrush : public Brush {
  public:
    NpcBrush(Json const& brush);

    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const override;

  private:
    Json m_npc;
  };

  class StagehandBrush : public Brush {
  public:
    StagehandBrush(Json const& definition);

    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const override;

  private:
    Json m_definition;
  };

  class DungeonIdBrush : public Brush {
  public:
    DungeonIdBrush(DungeonId dungeonId);

    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const override;

  private:
    DungeonId m_dungeonId;
  };

  class SurfaceBrush : public Brush {
  public:
    SurfaceBrush(Maybe<int> variant, Maybe<String> mod);

    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const override;

  private:
    int m_variant;
    Maybe<String> m_mod;
  };

  class SurfaceBackgroundBrush : public Brush {
  public:
    SurfaceBackgroundBrush(Maybe<int> variant, Maybe<String> mod);

    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const override;

  private:
    int m_variant;
    Maybe<String> m_mod;
  };

  class LiquidBrush : public Brush {
  public:
    LiquidBrush(String const& liquidName, float quantity, bool source);

    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const override;

  private:
    String m_liquid;
    float m_quantity;
    bool m_source;
  };

  class WireBrush : public Brush {
  public:
    WireBrush(String wireGroup, bool partLocal) : m_wireGroup(wireGroup), m_partLocal(partLocal) {}

    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const override;

  private:
    String m_wireGroup;
    bool m_partLocal;
  };

  class PlayerStartBrush : public Brush {
  public:
    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const override;
  };

  // InvalidBrush reports an error when it is painted. This brush is used on
  // tiles
  // that represent objects that have been removed from the game.
  class InvalidBrush : public Brush {
  public:
    InvalidBrush(Maybe<String> nameHint);

    virtual void paint(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const override;

  private:
    Maybe<String> m_nameHint;
  };

  enum class Direction : uint8_t {
    Left = 0,
    Right = 1,
    Up = 2,
    Down = 3,
    Unknown = 4,
    Any = 5
  };
  extern EnumMap<Dungeon::Direction> const DungeonDirectionNames;

  class Connector {
  public:
    Connector(Part* part, String value, bool forwardOnly, Direction direction, Vec2I offset);

    bool connectsTo(ConnectorConstPtr connector) const;

    String value() const;
    Vec2I positionAdjustment() const;
    Part* part() const;
    Vec2I offset() const;

  private:
    String m_value;
    bool m_forwardOnly;
    Direction m_direction;
    Vec2I m_offset;
    Part* m_part;
  };

  typedef function<bool(Vec2I, Tile const&)> TileCallback;

  class PartReader {
  public:
    virtual ~PartReader() {}

    virtual void readAsset(String const& asset) = 0;

    // Returns the dimensions of the part
    virtual Vec2U size() const = 0;

    // Iterate over every tile in every layer of the part.
    // The callback receives the position of the tile (within the part), and
    // the tile at that position.
    // The callback can return true to exit from the loop early.
    virtual void forEachTile(TileCallback const& callback) const = 0;

    // Calls the callback with only the tiles at the given position.
    virtual void forEachTileAt(Vec2I pos, TileCallback const& callback) const = 0;

  protected:
    PartReader() {}
  };

  class Part {
  public:
    Part(DungeonDefinition* dungeon, Json const& part, PartReaderPtr reader);

    String const& name() const;
    Vec2U size() const;
    Vec2I anchorPoint() const;
    float chance() const;
    bool markDungeonId() const;
    Maybe<float> minimumThreatLevel() const;
    Maybe<float> maximumThreatLevel() const;
    bool clearAnchoredObjects() const;
    int placementLevelConstraint() const;
    bool ignoresPartMaximum() const;
    bool allowsPlacement(int currentPlacementCount) const;
    List<ConnectorConstPtr> const& connections() const;
    bool doesNotConnectTo(Part* part) const;
    bool checkPartCombinationsAllowed(StringMap<int> const& placementCounts) const;
    bool collidesWithPlaces(Vec2I pos, Set<Vec2I>& places) const;

    bool canPlace(Vec2I pos, DungeonGeneratorWriter* writer) const;

    void place(Vec2I pos, Set<Vec2I> const& places, DungeonGeneratorWriter* writer) const;

    void forEachTile(TileCallback const& callback) const;

  private:
    void placePhase(Vec2I pos, Phase phase, Set<Vec2I> const& places, DungeonGeneratorWriter* writer) const;

    bool tileUsesPlaces(Vec2I pos) const;
    Direction pickByEdge(Vec2I position, Vec2U size) const;
    Direction pickByNeighbours(Vec2I pos) const;
    void scanConnectors();
    void scanAnchor();

    PartReaderConstPtr m_reader;

    String m_name;
    List<RuleConstPtr> m_rules;
    DungeonDefinition* m_dungeon;
    List<ConnectorConstPtr> m_connections;
    Vec2I m_anchorPoint;
    bool m_overrideAllowAlways;
    Maybe<float> m_minimumThreatLevel;
    Maybe<float> m_maximumThreatLevel;
    bool m_clearAnchoredObjects;
    Vec2U m_size;
    float m_chance;
    bool m_markDungeonId;
  };

  struct TileConnector {
    String value;
    bool forwardOnly;
    Direction direction = Direction::Unknown;
  };

  struct Tile {
    bool canPlace(Vec2I position, DungeonGeneratorWriter* writer) const;
    void place(Vec2I position, Phase phase, DungeonGeneratorWriter* writer) const;
    bool usesPlaces() const;
    bool modifiesPlaces() const;
    bool collidesWithPlaces() const;
    bool requiresOpen() const;
    bool requiresSolid() const;
    bool requiresLiquid() const;

    List<BrushConstPtr> brushes;
    List<RuleConstPtr> rules;
    Maybe<TileConnector> connector;
  };
}

class DungeonDefinition {
public:
  DungeonDefinition(JsonObject const& definition, String const& directory);

  JsonObject metadata() const;
  String directory() const;
  String name() const;
  String displayName() const;
  bool isProtected() const;
  Maybe<float> gravity() const;
  Maybe<bool> breathable() const;
  StringMap<Dungeon::PartConstPtr> const& parts() const;

  List<String> const& anchors() const;
  Maybe<Json> const& optTileset() const;
  int maxParts() const;
  int maxRadius() const;
  int extendSurfaceFreeSpace() const;

  JsonObject metaData() const;

private:
  JsonObject m_metadata;
  String m_directory;
  String m_name;
  String m_displayName;
  String m_species;
  bool m_isProtected;
  List<Dungeon::RuleConstPtr> m_rules;
  StringMap<Dungeon::PartConstPtr> m_parts;
  List<String> m_anchors;
  Maybe<Json> m_tileset;

  int m_maxRadius;
  int m_maxParts;
  int m_extendSurfaceFreeSpace;

  Maybe<float> m_gravity;
  Maybe<bool> m_breathable;
};

class DungeonDefinitions {
public:
  DungeonDefinitions();

  DungeonDefinitionConstPtr get(String const& name) const;
  JsonObject getMetadata(String const& name) const;

private:
  static DungeonDefinitionPtr readDefinition(String const& path);

  StringMap<String> m_paths;
  mutable Mutex m_cacheMutex;
  mutable HashLruCache<String, DungeonDefinitionPtr> m_definitionCache;
};

class DungeonGenerator {
public:
  DungeonGenerator(String const& dungeonName, uint64_t seed, float threatLevel, Maybe<DungeonId> dungeonId);

  Maybe<pair<List<RectI>, Set<Vec2I>>> generate(DungeonGeneratorWorldFacadePtr facade, Vec2I position, bool markSurfaceAndTerrain, bool forcePlacement);

  pair<List<RectI>, Set<Vec2I>> buildDungeon(Dungeon::PartConstPtr anchor, Vec2I pos, Dungeon::DungeonGeneratorWriter* writer, bool forcePlacement);
  Dungeon::PartConstPtr pickAnchor();
  List<Dungeon::ConnectorConstPtr> findConnectablePart(Dungeon::ConnectorConstPtr connector) const;

  DungeonDefinitionConstPtr definition() const;

private:
  DungeonDefinitionConstPtr m_def;

  RandomSource m_rand;
  float m_threatLevel;
  Maybe<DungeonId> m_dungeonId;
};

}