#include "follow_track.hpp"

#include "ship.h"

#include "debug.h"

using TWaterRegionTraversabilityBits = uint16_t;

constexpr TWaterRegionPatchLabel FIRST_REGION_LABEL = 1;

static_assert(sizeof(TWaterRegionTraversabilityBits) * 8 == WATER_REGION_EDGE_LENGTH);

static_assert(sizeof(TWaterRegionPatchLabel) == sizeof(byte)); // Important for the hash calculation.

static inline TrackBits GetWaterTracks(TileIndex tile) { return TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, 0)); }

static inline bool IsAqueductTile(TileIndex tile) { return IsBridgeTile(tile) && GetTunnelBridgeTransportType(tile) == TRANSPORT_WATER; }

 * @param water_region_patch Water patch within the water region to start searching from

 * @param side Side of the water region to look for neigboring patches of water

 * @param callback The function that will be called for each neighbor that is found

 */

static inline void VisitAdjacentWaterRegionPatchNeighbors(const WaterRegionPatchDesc &water_region_patch, DiagDirection side, TVisitWaterRegionPatchCallBack &func)

{

	const WaterRegion &current_region = GetUpdatedWaterRegion(water_region_patch.x, water_region_patch.y);

	const TileIndexDiffC offset = TileIndexDiffCByDiagDir(side);

	const int nx = water_region_patch.x + offset.x;

	const int ny = water_region_patch.y + offset.y;

		const TileIndex current_edge_tile = GetEdgeTileCoordinate(water_region_patch.x, water_region_patch.y, side, x_or_y);

		const TWaterRegionPatchLabel current_label = current_region.GetLabel(current_edge_tile);

		if (current_label != water_region_patch.label) continue;

		const TileIndex neighbor_edge_tile = GetEdgeTileCoordinate(nx, ny, opposite_side, x_or_y);

		const TWaterRegionPatchLabel neighbor_label = neighboring_region.GetLabel(neighbor_edge_tile);

		if (std::find(unique_labels.begin(), unique_labels.end(), neighbor_label) == unique_labels.end()) unique_labels.push_back(neighbor_label);

	}

	for (TWaterRegionPatchLabel unique_label : unique_labels) func(WaterRegionPatchDesc{ nx, ny, unique_label });

}

/**

 * each cardinal direction, plus any others that are reachable via aqueducts.

 * @param water_region_patch Water patch within the water region to start searching from

 * @param callback The function that will be called for each accessible water patch that is found

 */

void VisitWaterRegionPatchNeighbors(const WaterRegionPatchDesc &water_region_patch, TVisitWaterRegionPatchCallBack &callback)

{

	const WaterRegion &current_region = GetUpdatedWaterRegion(water_region_patch.x, water_region_patch.y);

	/* Visit adjacent water region patches in each cardinal direction */

	for (DiagDirection side = DIAGDIR_BEGIN; side < DIAGDIR_END; side++) VisitAdjacentWaterRegionPatchNeighbors(water_region_patch, side, callback);

	/* Visit neigboring water patches accessible via cross-region aqueducts */

using TWaterRegionPatchLabel = uint8_t;

using TWaterRegionIndex = uint;

constexpr int WATER_REGION_EDGE_LENGTH = 16;

constexpr int WATER_REGION_NUMBER_OF_TILES = WATER_REGION_EDGE_LENGTH * WATER_REGION_EDGE_LENGTH;

/**

 * Describes a single interconnected patch of water within a particular water region.

 */

struct WaterRegionPatchDesc

{

private:

	std::vector<CYapfRegionPatchNodeKey> m_origin_keys;

public:

	void AddOrigin(const WaterRegionPatchDesc &water_region_patch)

	{

		if (!HasOrigin(water_region_patch)) m_origin_keys.push_back(CYapfRegionPatchNodeKey{ water_region_patch });

	}

	bool HasOrigin(const WaterRegionPatchDesc &water_region_patch)

	{

		return std::find(m_origin_keys.begin(), m_origin_keys.end(), CYapfRegionPatchNodeKey{ water_region_patch }) != m_origin_keys.end();