/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

/** @file tile_map.h Map writing/reading functions for tiles. */

#ifndef TILE_MAP_H
#define TILE_MAP_H

#include "slope_type.h"
#include "map_func.h"
#include "core/bitmath_func.hpp"
#include "settings_type.h"

/**
 * Returns the height of a tile
 *
 * This function returns the height of the northern corner of a tile.
 * This is saved in the global map-array. It does not take affect by
 * any slope-data of the tile.
 *
 * @param tile The tile to get the height from
 * @return the height of the tile
 * @pre tile < Map::Size()
 */
[[debug_inline]] inline static uint TileHeight(Tile tile)
{
	assert(tile < Map::Size());
	return tile.height();
}

/**
 * Returns the height of a tile, also for tiles outside the map (virtual "black" tiles).
 *
 * @param x X coordinate of the tile, may be outside the map.
 * @param y Y coordinate of the tile, may be outside the map.
 * @return The height in the same unit as TileHeight.
 */
inline uint TileHeightOutsideMap(int x, int y)
{
	return TileHeight(TileXY(Clamp(x, 0, Map::MaxX()), Clamp(y, 0, Map::MaxY())));
}

/**
 * Sets the height of a tile.
 *
 * This function sets the height of the northern corner of a tile.
 *
 * @param tile The tile to change the height
 * @param height The new height value of the tile
 * @pre tile < Map::Size()
 * @pre height <= MAX_TILE_HEIGHT
 */
inline void SetTileHeight(Tile tile, uint height)
{
	assert(tile < Map::Size());
	assert(height <= MAX_TILE_HEIGHT);
	tile.height() = height;
}

/**
 * Returns the height of a tile in pixels.
 *
 * This function returns the height of the northern corner of a tile in pixels.
 *
 * @param tile The tile to get the height
 * @return The height of the tile in pixel
 */
inline uint TilePixelHeight(Tile tile)
{
	return TileHeight(tile) * TILE_HEIGHT;
}

/**
 * Returns the height of a tile in pixels, also for tiles outside the map (virtual "black" tiles).
 *
 * @param x X coordinate of the tile, may be outside the map.
 * @param y Y coordinate of the tile, may be outside the map.
 * @return The height in pixels in the same unit as TilePixelHeight.
 */
inline uint TilePixelHeightOutsideMap(int x, int y)
{
	return TileHeightOutsideMap(x, y) * TILE_HEIGHT;
}

/**
 * Get the tiletype of a given tile.
 *
 * @param tile The tile to get the TileType
 * @return The tiletype of the tile
 * @pre tile < Map::Size()
 */
[[debug_inline]] inline static TileType GetTileType(Tile tile)
{
	assert(tile < Map::Size());
	return TileType(GB(tile.type(), 4, TILE_TYPE_BITS));
}

/**
 * Check if a tile is within the map (not a border)
 *
 * @param tile The tile to check
 * @return Whether the tile is in the interior of the map
 * @pre tile < Map::Size()
 */
inline bool IsInnerTile(Tile tile)
{
	assert(tile < Map::Size());

	uint x = TileX(tile);
	uint y = TileY(tile);

	return x < Map::MaxX() && y < Map::MaxY() && ((x > 0 && y > 0) || !_settings_game.construction.freeform_edges);
}

/**
 * Set the type of a tile
 *
 * This functions sets the type of a tile. If the type
 * TileType::Void is selected the tile must be at the south-west or
 * south-east edges of the map and vice versa.
 *
 * @param tile The tile to save the new type
 * @param type The type to save
 * @pre tile < Map::Size()
 * @pre type TileType::Void <=> tile is on the south-east or south-west edge.
 */
inline void SetTileType(Tile tile, TileType type)
{
	assert(tile < Map::Size());
	/* VOID tiles (and no others) are exactly allowed at the lower left and right
	 * edges of the map. If _settings_game.construction.freeform_edges is true,
	 * the upper edges of the map are also VOID tiles. */
	assert(IsInnerTile(tile) == (type != TileType::Void));
	SB(tile.type(), 4, TILE_TYPE_BITS, to_underlying(type));
}

/**
 * Checks if a tile is a given tiletype.
 *
 * This function checks if a tile has the given tiletype.
 *
 * @param tile The tile to check
 * @param type The type to check against
 * @return true If the type matches against the type of the tile
 */
[[debug_inline]] inline static bool IsTileType(Tile tile, TileType type)
{
	return GetTileType(tile) == type;
}

/**
 * Checks if a tile is valid
 *
 * @param tile The tile to check
 * @return True if the tile is on the map and not one of TileType::Void.
 */
inline bool IsValidTile(Tile tile)
{
	return tile < Map::Size() && !IsTileType(tile, TileType::Void);
}

/**
 * Returns the owner of a tile
 *
 * This function returns the owner of a tile. This cannot used
 * for tiles which type is one of TileType::House, TileType::Void and TileType::Industry
 * as no company owned any of these buildings.
 *
 * @param tile The tile to check
 * @return The owner of the tile
 * @pre IsValidTile(tile)
 * @pre The type of the tile must not be TileType::House and TileType::Industry
 */
inline Owner GetTileOwner(Tile tile)
{
	assert(IsValidTile(tile));
	assert(!IsTileType(tile, TileType::House));
	assert(!IsTileType(tile, TileType::Industry));

	return (Owner)GB(tile.m1(), 0, 5);
}

/**
 * Sets the owner of a tile
 *
 * This function sets the owner status of a tile. Note that you cannot
 * set a owner for tiles of type TileType::House, TileType::Void and TileType::Industry.
 *
 * @param tile The tile to change the owner status.
 * @param owner The new owner.
 * @pre IsValidTile(tile)
 * @pre The type of the tile must not be TileType::House and TileType::Industry
 */
inline void SetTileOwner(Tile tile, Owner owner)
{
	assert(IsValidTile(tile));
	assert(!IsTileType(tile, TileType::House));
	assert(!IsTileType(tile, TileType::Industry));

	SB(tile.m1(), 0, 5, owner.base());
}

/**
 * Checks if a tile belongs to the given owner
 *
 * @param tile The tile to check
 * @param owner The owner to check against
 * @return True if a tile belongs the the given owner
 */
inline bool IsTileOwner(Tile tile, Owner owner)
{
	return GetTileOwner(tile) == owner;
}

/**
 * Set the tropic zone
 * @param tile the tile to set the zone of
 * @param type the new type
 * @pre tile < Map::Size()
 */
inline void SetTropicZone(Tile tile, TropicZone type)
{
	assert(tile < Map::Size());
	assert(!IsTileType(tile, TileType::Void) || type == TropicZone::Normal);
	SB(tile.type(), 0, 2, to_underlying(type));
}

/**
 * Get the tropic zone
 * @param tile the tile to get the zone of
 * @pre tile < Map::Size()
 * @return the zone type
 */
inline TropicZone GetTropicZone(Tile tile)
{
	assert(tile < Map::Size());
	return static_cast<TropicZone>(GB(tile.type(), 0, 2));
}

/**
 * Get the current animation frame
 * @param t the tile
 * @pre IsTileType(t, TileType::House) || IsTileType(t, TileType::Object) || IsTileType(t, TileType::Industry) || IsTileType(t, TileType::Station)
 * @return frame number
 */
inline uint8_t GetAnimationFrame(Tile t)
{
	assert(IsTileType(t, TileType::House) || IsTileType(t, TileType::Object) || IsTileType(t, TileType::Industry) || IsTileType(t, TileType::Station));
	return t.m7();
}

/**
 * Set a new animation frame
 * @param t the tile
 * @param frame the new frame number
 * @pre IsTileType(t, TileType::House) || IsTileType(t, TileType::Object) || IsTileType(t, TileType::Industry) || IsTileType(t, TileType::Station)
 */
inline void SetAnimationFrame(Tile t, uint8_t frame)
{
	assert(IsTileType(t, TileType::House) || IsTileType(t, TileType::Object) || IsTileType(t, TileType::Industry) || IsTileType(t, TileType::Station));
	t.m7() = frame;
}

std::tuple<Slope, int> GetTileSlopeZ(TileIndex tile);
int GetTileZ(TileIndex tile);
int GetTileMaxZ(TileIndex tile);

bool IsTileFlat(TileIndex tile, int *h = nullptr);

/**
 * Return the slope of a given tile inside the map.
 * @param tile Tile to compute slope of
 * @return Slope of the tile, except for the HALFTILE part
 */
inline Slope GetTileSlope(TileIndex tile)
{
	return std::get<Slope>(GetTileSlopeZ(tile));
}

/**
 * Return the slope of a given tile
 * @param tile Tile to compute slope of
 * @return Slope of the tile, except for the HALFTILE part, and the z height.
 */
inline std::tuple<Slope, int> GetTilePixelSlope(TileIndex tile)
{
	auto [s, h] = GetTileSlopeZ(tile);
	return {s, h * TILE_HEIGHT};
}

std::tuple<Slope, int> GetTilePixelSlopeOutsideMap(int x, int y);

/**
 * Get bottom height of the tile
 * @param tile Tile to compute height of
 * @return Minimum height of the tile
 */
inline int GetTilePixelZ(TileIndex tile)
{
	return GetTileZ(tile) * TILE_HEIGHT;
}

/**
 * Get top height of the tile
 * @param tile Tile to compute height of
 * @return Maximum height of the tile
 */
inline int GetTileMaxPixelZ(TileIndex tile)
{
	return GetTileMaxZ(tile) * TILE_HEIGHT;
}

/**
 * Calculate a hash value from a tile position
 *
 * @param x The X coordinate
 * @param y The Y coordinate
 * @return The hash of the tile
 */
inline uint TileHash(uint x, uint y)
{
	uint hash = x >> 4;
	hash ^= x >> 6;
	hash ^= y >> 4;
	hash -= y >> 6;
	return hash;
}

/**
 * Get the last two bits of the TileHash
 *  from a tile position.
 *
 * @see TileHash()
 * @param x The X coordinate
 * @param y The Y coordinate
 * @return The last two bits from hash of the tile
 */
inline uint TileHash2Bit(uint x, uint y)
{
	return GB(TileHash(x, y), 0, 2);
}

#endif /* TILE_MAP_H */
