package scalevalapokalypsi.Model

import scala.collection.mutable.Map
import scalevalapokalypsi.Model.Entities.*

/** The class `Area` represents locations in a text adventure game world. A game
  * world consists of areas. In general, an “area” can be pretty much anything:
  * a room, a building, an acre of forest, or something completely different.
  * What different areas have in common is that players can be located in them
  * and that they can have exits leading to other, neighboring areas. An area
  * also has a name and a description.
  *
  * @param name the name of the area
  * @param description a basic description of the area (typically not including
  *                    information about items)
  */
class Area(val name: String, var description: String):

	private val neighbors = Map[String, Area]()
	private val items: Map[String, Item] = Map()
	private val entities: Map[String, Entity] = Map()

	/** Returns the area that can be reached from this area by moving in the
	  * given direction. The result is returned in an `Option`; `None` is
	  * returned if there is no exit in the given direction.
	  */
	def neighbor(direction: String): Option[Area] =
		this.neighbors.get(direction)

	def getNeighborNames: Iterable[String] = this.neighbors.keys
	def getItemNames: Iterable[String] = this.items.keys
	def getEntityNames: Iterable[String] = this.entities.values.map(_.name)
	def getEntity(name: String): Option[Entity] = this.entities.get(name)
	def getEntities: Iterable[Entity] = this.entities.values

	/** Tells whether this area has a neighbor in the given direction.
	 *
	 * @param direction the direction to check
	 * @return whether there is a neighbor in the direction
	 */
	def hasNeighbor(direction: String): Boolean =
		this.neighbors.contains(direction)

	/** Adds an exit from this area to the given area. The neighboring area is
	  * reached by moving in the specified direction from this area. */
	def setNeighbor(direction: String, neighbor: Area) =
		this.neighbors += direction -> neighbor

	/** Adds exits from this area to the given areas. Calling this method is
	  * equivalent to calling the `setNeighbor` method on each of the given
	  * direction–area pairs.
	  *
	  * @param exits contains pairs consisting of a direction and the
	  *              neighboring area in that direction
	  * @see [[setNeighbor]]
	  */
	def setNeighbors(exits: Vector[(String, Area)]) =
		this.neighbors ++= exits

	/** Adds the specified item
	  *
	  * @param item the item to add
	  */
	def addItem(item: Item): Unit = this.items += item.name -> item

	/** Adds multiple items
	  *
	  * @param items a once iterable collection of items to add
	  */
	def addItems(items: IterableOnce[Item]) =
		items.iterator.foreach(i => this.items += i.name -> i)

	def hasItem(itemName: String) = this.items.contains(itemName)


	/** Removes the specified item if it exists.
	  *
	  * @param itemName the name of the item to remove
	  * @return an option containing the removed item
	  */
	def removeItem(itemName: String): Option[Item] =
		this.items.remove(itemName)

	/** Adds the specified entity to the area.
	  *
	  * @param entity the entity to add.
	  */
	def addEntity(entity: Entity): Unit =
		this.entities += entity.name.toLowerCase -> entity

	/** Removes the entity with the name `entityName`.
	  *
	  * @param entityName the name of the entity to remove
	  * @return an option containing the removed entity if it was in the area
	  */
	def removeEntity(entityName: String): Option[Entity] =
		this.entities.remove(entityName.toLowerCase())

	/** Returns a multi-line description of the area as a player sees it. This
	  * includes a basic description of the area as well as information about
	  * exits and items. If there are no items present, the return value has the
	  * form "DESCRIPTION\n\nExits available:
	  * DIRECTIONS SEPARATED BY SPACES". If there are one or more items present,
	  * the return value has the form "DESCRIPTION\nYou see here: ITEMS
	  * SEPARATED BY SPACES\n\nExits available: DIRECTIONS SEPARATED BY SPACES".
	  * The items and directions are listed in an arbitrary order.
	  */
	def fullDescription: String =
		val exitList = this.neighbors.keys.mkString(" ")
		val itemList = this.items.keys.mkString(" ")
		val entityList = this.getEntityNames.mkString(" ")
		val itemDescription =
			if this.items.nonEmpty then
				s"\nYou see here: ${itemList}"
			else ""
		val entityDescription =
			if this.entities.nonEmpty then
				s"\nThere are entities: ${entityList}"
			else ""
		(this.description +
			itemDescription +
			entityDescription +
			s"\n\nExits available: $exitList")


	/** Returns a single-line description of the area for debugging purposes. */
	override def toString =
		this.name + ": " + this.description.replaceAll("\n", " ").take(150)

end Area