#include "rail_cmd.h"

#include "table/strings.h"

#include "safeguards.h"

/**

 * Static instance of FlowStat::SharesMap.

 * Note: This instance is created on task start.

 *       Lazy creation on first usage results in a data race between the CDist threads.

 */

/* static */ const FlowStat::SharesMap FlowStat::empty_sharesmap;

	/* In all cases if an industry that provides a name is found two of

	 * the standard names will be disabled. */

	sni->free_names &= ~(1 << M(STR_SV_STNAME_OILFIELD) | 1 << M(STR_SV_STNAME_MINES));

	return !sni->indtypes[indtype];

}

{

	for (const Station *s : Station::Iterate()) {

		if (s != st && s->town == t) {

			if (s->indtype != IT_INVALID) {

				indtypes[s->indtype] = true;

				StringID name = GetIndustrySpec(s->indtype)->station_name;

				if (name != STR_UNDEFINED) {

					str = M(STR_SV_STNAME_WOODS);

				}

				ClrBit(free_names, str);

			}

		}

	}

	TileIndex indtile = tile;

	StationNameInformation sni = { free_names, indtypes };

	if (CircularTileSearch(&indtile, 7, FindNearIndustryName, &sni)) {

		/* An industry has been found nearby */

		IndustryType indtype = GetIndustryType(indtile);

		const IndustrySpec *indsp = GetIndustrySpec(indtype);

		/* STR_NULL means it only disables oil rig/mines */

			st->indtype = indtype;

			return STR_SV_STNAME_FALLBACK;

		}

	}

	/* Oil rigs/mines name could be marked not free by looking for a near by industry. */

 * @param tile_iter Airport tile iterator.

 * @param flags Operation to perform.

 * @return The cost in case of success, or an error code if it failed.

 */

static CommandCost CheckFlatLandAirport(AirportTileTableIterator tile_iter, DoCommandFlag flags)

{

	int allowed_z = -1;

	for (; tile_iter != INVALID_TILE; ++tile_iter) {

		CommandCost ret = CheckBuildableTile(tile_iter, 0, allowed_z, true);

		if (ret.Failed()) return ret;

		cost.AddCost(ret);

 * @param plat_len Platform length.

 * @param numtracks Number of platforms.

 * @return The cost in case of success, or an error code if it failed.

 */

static CommandCost CheckFlatLandRailStation(TileArea tile_area, DoCommandFlag flags, Axis axis, StationID *station, RailType rt, std::vector<Train *> &affected_vehicles, StationClassID spec_class, byte spec_index, byte plat_len, byte numtracks)

{

	int allowed_z = -1;

	uint invalid_dirs = 5 << axis;

	const StationSpec *statspec = StationClass::Get(spec_class)->GetSpec(spec_index);

	bool slope_cb = statspec != nullptr && HasBit(statspec->callback_mask, CBM_STATION_SLOPE_CHECK);

 * @param station StationID to be queried and returned if available.

 * @param rt Road type to build.

 * @return The cost in case of success, or an error code if it failed.

 */

static CommandCost CheckFlatLandRoadStop(TileArea tile_area, DoCommandFlag flags, uint invalid_dirs, bool is_drive_through, bool is_truck_stop, Axis axis, StationID *station, RoadType rt)

{

	int allowed_z = -1;

	for (TileIndex cur_tile : tile_area) {

		CommandCost ret = CheckBuildableTile(cur_tile, invalid_dirs, allowed_z, !is_drive_through);

		if (ret.Failed()) return ret;

		cost.AddCost(ret);

 */

template <class T>

CommandCost RemoveFromRailBaseStation(TileArea ta, std::vector<T *> &affected_stations, DoCommandFlag flags, Money removal_cost, bool keep_rail)

{

	/* Count of the number of tiles removed */

	int quantity = 0;

	/* Accumulator for the errors seen during clearing. If no errors happen,

	 * and the quantity is 0 there is no station. Otherwise it will be one

	 * of the other error that got accumulated. */

	CommandCost error;

	/* Do the action for every tile into the area */

	/* determine width and height of platforms */

	TileArea ta = st->train_station;

	assert(ta.w != 0 && ta.h != 0);

	/* clear all areas of the station */

	for (TileIndex tile : ta) {

		/* only remove tiles that are actually train station tiles */

		if (st->TileBelongsToRailStation(tile)) {

			std::vector<T*> affected_stations; // dummy

			CommandCost ret = RemoveFromRailBaseStation(TileArea(tile, 1, 1), affected_stations, flags, removal_cost, false);

	CommandCost ret = CheckIfAuthorityAllowsNewStation(tile, flags);

	if (ret.Failed()) return ret;

	bool is_truck_stop = stop_type != ROADSTOP_BUS;

	/* Total road stop cost. */

	StationID est = INVALID_STATION;

	ret = CheckFlatLandRoadStop(roadstop_area, flags, is_drive_through ? 5 << axis : 1 << ddir, is_drive_through, is_truck_stop, axis, &est, rt);

	if (ret.Failed()) return ret;

	cost.AddCost(ret);

	Station *st = nullptr;

		} else {

			st->bus_station.Clear();

			for (const RoadStop *rs = st->bus_stops; rs != nullptr; rs = rs->next) st->bus_station.Add(rs->xy);

		}

	}

}

/**

 * Remove bus or truck stops.

 * @param flags Operation to perform.

 * @param tile Northernmost tile of the removal area.

	if (!IsValidTile(tile) || TileAddWrap(tile, width - 1, height - 1) == INVALID_TILE) return CMD_ERROR;

	/* Bankrupting company is not supposed to remove roads, there may be road vehicles. */

	if (remove_road && (flags & DC_BANKRUPT)) return CMD_ERROR;

	TileArea roadstop_area(tile, width, height);

	CommandCost last_error(STR_ERROR_THERE_IS_NO_STATION);

	bool had_success = false;

	for (TileIndex cur_tile : roadstop_area) {

		/* Make sure the specified tile is a road stop of the correct type */

		if (!IsTileType(cur_tile, MP_STATION) || !IsRoadStop(cur_tile) || GetRoadStopType(cur_tile) != stop_type) continue;

		CommandCost ret = CheckOwnership(st->owner);

		if (ret.Failed()) return ret;

	}

	tile = st->airport.tile;

	for (const Aircraft *a : Aircraft::Iterate()) {

		if (!a->IsNormalAircraft()) continue;

		if (a->targetairport == st->index && a->state != FLYING) {

			return_cmd_error(STR_ERROR_AIRCRAFT_IN_THE_WAY);

		}

	CommandCost ret = CheckIfAuthorityAllowsNewStation(tile, flags);

	if (ret.Failed()) return ret;

	if (IsBridgeAbove(tile)) return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);

	ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile);

	if (ret.Failed()) return ret;

	cost.AddCost(ret);

	TileIndex tile_cur = tile + TileOffsByDiagDir(direction);

			if (s->current_order.IsType(OT_GOTO_STATION) && !(st->facilities & FACIL_DOCK)) {

				s->SetDestTile(s->GetOrderStationLocation(st->index));

			}

		}

	}

}

#include "table/station_land.h"

const DrawTileSprites *GetStationTileLayout(StationType st, byte gfx)

{

				DrawGroundSprite(GetRailStationAxis(ti->tile) == AXIS_X ? rti->base_sprites.single_x : rti->base_sprites.single_y, PALETTE_CRASH);

			}

		}

	}

	if (HasStationRail(ti->tile) && HasRailCatenaryDrawn(GetRailType(ti->tile))) DrawRailCatenary(ti);

	if (IsRoadStop(ti->tile)) {

		RoadType road_rt = GetRoadTypeRoad(ti->tile);

		RoadType tram_rt = GetRoadTypeTram(ti->tile);

		const RoadTypeInfo* road_rti = road_rt == INVALID_ROADTYPE ? nullptr : GetRoadTypeInfo(road_rt);

		const RoadTypeInfo* tram_rti = tram_rt == INVALID_ROADTYPE ? nullptr : GetRoadTypeInfo(tram_rt);

					ge->max_waiting_cargo = waiting_avg;

				}

			}

		}

	}

	StationID index = st->index;

	if (waiting_changed) {

		SetWindowDirty(WC_STATION_VIEW, index); // update whole window

	} else {

		SetWindowWidgetDirty(WC_STATION_VIEW, index, WID_SV_ACCEPT_RATING_LIST); // update only ratings list

	}

			TriggerStationAnimation(st, st->xy, SAT_250_TICKS);

			if (Station::IsExpected(st)) AirportAnimationTrigger(Station::From(st), AAT_STATION_250_TICKS);

		}

	}

}

/** Monthly loop for stations. */

void StationMonthlyLoop()

{

	for (Station *st : Station::Iterate()) {

		for (CargoID i = 0; i < NUM_CARGO; i++) {

			GoodsEntry *ge = &st->goods[i];

			SB(ge->status, GoodsEntry::GES_LAST_MONTH, 1, GB(ge->status, GoodsEntry::GES_CURRENT_MONTH, 1));

			ClrBit(ge->status, GoodsEntry::GES_CURRENT_MONTH);

		}

	}

}

void ModifyStationRatingAround(TileIndex tile, Owner owner, int amount, uint radius)

{

			switch (GetStationType(tile)) {

				case STATION_WAYPOINT:

				case STATION_RAIL: {

					DiagDirection direction = AxisToDiagDir(GetRailStationAxis(tile));

					if (!AutoslopeCheckForEntranceEdge(tile, z_new, tileh_new, direction)) break;

					if (!AutoslopeCheckForEntranceEdge(tile, z_new, tileh_new, ReverseDiagDir(direction))) break;

				}

				case STATION_AIRPORT:

				case STATION_TRUCK:

				case STATION_BUS: {

					DiagDirection direction = GetRoadStopDir(tile);

					if (!AutoslopeCheckForEntranceEdge(tile, z_new, tileh_new, direction)) break;

					if (IsDriveThroughStopTile(tile)) {

						if (!AutoslopeCheckForEntranceEdge(tile, z_new, tileh_new, ReverseDiagDir(direction))) break;

					}

				}

				default: break;

			}

		}

	}