/* $Id$ */

/*

 * 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 <http://www.gnu.org/licenses/>.

 */

/** @file newgrf_airporttiles.h NewGRF handling of airport tiles. */

#ifndef NEWGRF_AIRPORTTILES_H

#define NEWGRF_AIRPORTTILES_H

#include "airport.h"

#include "station_map.h"

#include "newgrf_commons.h"

/** Animation triggers for airport tiles */

enum AirpAnimationTrigger {

	AAT_BUILT,               ///< Triggered when the airport it build (for all tiles at the same time)

	AAT_TILELOOP,            ///< Triggered in the periodic tile loop

	AAT_STATION_NEW_CARGO,   ///< Triggered when new cargo arrives at the station (for all tiles at the same time)

	AAT_STATION_CARGO_TAKEN, ///< Triggered when a cargo type is completely removed from the station (for all tiles at the same time)

	AAT_STATION_250_ticks,   ///< Triggered every 250 ticks (for all tiles at the same time)

};

/**

 * Defines the data structure of each indivudual tile of an airport.

 */

struct AirportTileSpec {

	uint16 animation_info;                ///< Information about the animation (is it looping, how many loops etc)

	uint8 animation_speed;                ///< The speed of the animation

	StringID name;                        ///< Tile Subname string, land information on this tile will give you "AirportName (TileSubname)"

	uint8 callback_flags;                 ///< Flags telling which grf callback is set

	uint8 animation_triggers;             ///< When to start the animation

	uint8 animation_special_flags;        ///< Extra flags to influence the animation

	bool enabled;                         ///< entity still available (by default true). newgrf can disable it, though

	GRFFileProps grf_prop;                ///< properties related the the grf file

	static const AirportTileSpec *Get(StationGfx gfx);

	static void ResetAirportTiles();

private:

	static AirportTileSpec tiles[NUM_AIRPORTTILES];

	friend void AirportTileOverrideManager::SetEntitySpec(const AirportTileSpec *airpts);

};

StationGfx GetTranslatedAirportTileID(StationGfx gfx);

void AnimateAirportTile(TileIndex tile);

void AirportTileAnimationTrigger(Station *st, TileIndex tile, AirpAnimationTrigger trigger, CargoID cargo_type = CT_INVALID);

void AirportAnimationTrigger(Station *st, AirpAnimationTrigger trigger, CargoID cargo_type = CT_INVALID);

bool DrawNewAirportTile(TileInfo *ti, Station *st, StationGfx gfx, const AirportTileSpec *airts);

#endif /* NEWGRF_AIRPORTTILES_H */

#endif

}

struct MyGetOptData {

	char *opt;

	int numleft;

	char **argv;

	const char *options;

	char *cont;

	MyGetOptData(int argc, char **argv, const char *options)

	{

		opt = NULL;

		numleft = argc;

		this->argv = argv;

		this->options = options;

		cont = NULL;

	}

};

static int MyGetOpt(MyGetOptData *md)

{

	char *s = md->cont;

	if (s != NULL)

		goto md_continue_here;

	for (;;) {

		if (--md->numleft < 0) return -1;

		s = *md->argv++;

		if (*s == '-') {

md_continue_here:;

			s++;

			if (*s != 0) {

				const char *r;

				/* Found argument, try to locate it in options. */

				if (*s == ':' || (r = strchr(md->options, *s)) == NULL) {

					/* ERROR! */

					return -2;

				}

				if (r[1] == ':') {

					char *t;

					/* Item wants an argument. Check if the argument follows, or if it comes as a separate arg. */

					if (!*(t = s + 1)) {

						/* It comes as a separate arg. Check if out of args? */

						if (--md->numleft < 0 || *(t = *md->argv) == '-') {

							/* Check if item is optional? */

							if (r[2] != ':')

								return -2;

							md->numleft++;

							t = NULL;

						} else {

							md->argv++;

						}

					}

					md->opt = t;

					md->cont = NULL;

					return *s;

				}

				md->opt = NULL;

				md->cont = s;

				return *s;

			}

		} else {

			/* This is currently not supported. */

			return -2;

		}

	}

}

/**

 * Extract the resolution from the given string and store

 * it in the 'res' parameter.

 * @param res variable to store the resolution in.

 * @param s   the string to decompose.

 */

static void ParseResolution(Dimension *res, const char *s)

{

	const char *t = strchr(s, 'x');

	if (t == NULL) {

		ShowInfoF("Invalid resolution '%s'", s);

		return;

	}

	res->width  = max(strtoul(s, NULL, 0), 64UL);

	res->height = max(strtoul(t + 1, NULL, 0), 64UL);

}

static void InitializeDynamicVariables()

{

	/* Dynamic stuff needs to be initialized somewhere... */

	_engine_mngr.ResetToDefaultMapping();

	_house_mngr.ResetMapping();

	_industry_mngr.ResetMapping();

	_industile_mngr.ResetMapping();

}

/** Unitializes drivers, frees allocated memory, cleans pools, ...

 * Generally, prepares the game for shutting down

 */

static void ShutdownGame()

{

	IConsoleFree();

	if (_network_available) NetworkShutDown(); // Shut down the network and close any open connections

	DriverFactoryBase::ShutdownDrivers();

	UnInitWindowSystem();

	/* stop the AI */

	AI::Uninitialize(false);

	/* Uninitialize airport state machines */

	UnInitializeAirports();

	/* Uninitialize variables that are allocated dynamically */

	GamelogReset();

	_town_pool.CleanPool();

	_industry_pool.CleanPool();

	_station_pool.CleanPool();

	_roadstop_pool.CleanPool();

	_vehicle_pool.CleanPool();

	_sign_pool.CleanPool();

	_order_pool.CleanPool();

	_group_pool.CleanPool();

	_cargopacket_pool.CleanPool();

	_engine_pool.CleanPool();

	_company_pool.CleanPool();

	free(_config_file);

	/* Close all and any open filehandles */

	FioCloseAll();

}

static void LoadIntroGame()

{

	_game_mode = GM_MENU;

	ResetGRFConfig(false);

	/* Setup main window */

	ResetWindowSystem();

	SetupColoursAndInitialWindow();

	/* Load the default opening screen savegame */

	if (SaveOrLoad("opntitle.dat", SL_LOAD, DATA_DIR) != SL_OK) {

		GenerateWorld(GWM_EMPTY, 64, 64); // if failed loading, make empty world.

		WaitTillGeneratedWorld();

		SetLocalCompany(COMPANY_SPECTATOR);

	} else {

		SetLocalCompany(COMPANY_FIRST);

	}

	_pause_mode = PM_UNPAUSED;

	_cursor.fix_at = false;

	CheckForMissingGlyphsInLoadedLanguagePack();

	/* Play main theme */

	if (_music_driver->IsSongPlaying()) ResetMusic();

}

void MakeNewgameSettingsLive()

{

#ifdef ENABLE_AI

	for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) {

		if (_settings_game.ai_config[c] != NULL) {

			delete _settings_game.ai_config[c];

		}

	}

#endif /* ENABLE_AI */

	_settings_game = _settings_newgame;

#ifdef ENABLE_AI

	for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) {

		_settings_game.ai_config[c] = NULL;

		if (_settings_newgame.ai_config[c] != NULL) {

			_settings_game.ai_config[c] = new AIConfig(_settings_newgame.ai_config[c]);

		}

	}

#endif /* ENABLE_AI */

}

byte _savegame_sort_order;

#if defined(UNIX) && !defined(__MORPHOS__)

extern void DedicatedFork();

#endif

		if (st->owner != _current_company) {

			return_cmd_error(STR_ERROR_TOO_CLOSE_TO_ANOTHER_STATION);

		}

		if (!st->rect.BeforeAddRect(tile, w, h, StationRect::ADD_TEST)) return CMD_ERROR;

		if (st->airport.tile != INVALID_TILE) {

			return_cmd_error(STR_ERROR_TOO_CLOSE_TO_ANOTHER_AIRPORT);

		}

	} else {

		airport_upgrade = false;

		/* allocate and initialize new station */

		if (!Station::CanAllocateItem()) return_cmd_error(STR_ERROR_TOO_MANY_STATIONS_LOADING);

		if (flags & DC_EXEC) {

			st = new Station(tile);

			st->town = t;

			st->string_id = GenerateStationName(st, tile, !(GetAirport(p1)->flags & AirportFTAClass::AIRPLANES) ? STATIONNAMING_HELIPORT : STATIONNAMING_AIRPORT);

			if (Company::IsValidID(_current_company)) {

				SetBit(st->town->have_ratings, _current_company);

			}

		}

	}

	cost.AddCost(_price[PR_BUILD_STATION_AIRPORT] * w * h);

	if (flags & DC_EXEC) {

		/* Always add the noise, so there will be no need to recalculate when option toggles */

		nearest->noise_reached += newnoise_level;

		st->AddFacility(FACIL_AIRPORT, tile);

		st->airport_type = (byte)p1;

		st->airport_flags = 0;

		st->rect.BeforeAddRect(tile, w, h, StationRect::ADD_TRY);

		const AirportTileTable *it = as->table[0];

		do {

			TileIndex cur_tile = tile + ToTileIndexDiff(it->ti);

			MakeAirport(cur_tile, st->owner, st->index, it->gfx);

			SetStationTileRandomBits(cur_tile, GB(Random(), 0, 4));

			st->airport.Add(cur_tile);

			if (AirportTileSpec::Get(GetTranslatedAirportTileID(it->gfx))->animation_info != 0xFFFF) AddAnimatedTile(cur_tile);

		} while ((++it)->ti.x != -0x80);

		/* Only call the animation trigger after all tiles have been built */

		it = as->table[0];

		do {

			TileIndex cur_tile = tile + ToTileIndexDiff(it->ti);

			AirportTileAnimationTrigger(st, cur_tile, AAT_BUILT);

		} while ((++it)->ti.x != -0x80);

		/* if airport was demolished while planes were en-route to it, the

		 * positions can no longer be the same (v->u.air.pos), since different

		 * airports have different indexes. So update all planes en-route to this

		 * airport. Only update if

		 * 1. airport is upgraded

		 * 2. airport is added to existing station (unfortunately unavoideable)

		 */

		if (airport_upgrade) UpdateAirplanesOnNewStation(st);

		st->UpdateVirtCoord();

		UpdateStationAcceptance(st, false);

		st->RecomputeIndustriesNear();

		InvalidateWindowData(WC_SELECT_STATION, 0, 0);

		InvalidateWindowData(WC_STATION_LIST, st->owner, 0);

		SetWindowWidgetDirty(WC_STATION_VIEW, st->index, SVW_PLANES);

		if (_settings_game.economy.station_noise_level) {

			SetWindowDirty(WC_TOWN_VIEW, st->town->index);

		}

	}

	return cost;

}

/**

 * Remove an airport

 * @param tile TileIndex been queried

 * @param flags operation to perform

 * @return cost or failure of operation

 */

static CommandCost RemoveAirport(TileIndex tile, DoCommandFlag flags)

{

	Station *st = Station::GetByTile(tile);

	if (_current_company != OWNER_WATER && !CheckOwnership(st->owner)) {

		return CMD_ERROR;

	}

	tile = st->airport.tile;

	CommandCost cost(EXPENSES_CONSTRUCTION);

	const Aircraft *a;

	FOR_ALL_AIRCRAFT(a) {

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

		if (a->targetairport == st->index && a->state != FLYING) return CMD_ERROR;

	}

	TILE_AREA_LOOP(tile_cur, st->airport) {

		if (!st->TileBelongsToAirport(tile_cur)) continue;

		ret.SetGlobalErrorMessage();

		if (ret.Failed()) return ret;

		cost.AddCost(_price[PR_CLEAR_STATION_AIRPORT]);

		if (flags & DC_EXEC) {

			DeleteAnimatedTile(tile_cur);

			DoClearSquare(tile_cur);

		}

	}

	if (flags & DC_EXEC) {

		for (uint i = 0; i < as->nof_depots; ++i) {

			DeleteWindowById(

				WC_VEHICLE_DEPOT, st->GetHangarTile(i)

			);

		}

		/* Go get the final noise level, that is base noise minus factor from distance to town center.

		 * And as for construction, always remove it, even if the setting is not set, in order to avoid the

		 * need of recalculation */

		Town *nearest = AirportGetNearestTown(as, tile);

		nearest->noise_reached -= GetAirportNoiseLevelForTown(as, nearest->xy, tile);

		st->airport.Clear();

		st->facilities &= ~FACIL_AIRPORT;

		SetWindowWidgetDirty(WC_STATION_VIEW, st->index, SVW_PLANES);

		if (_settings_game.economy.station_noise_level) {

			SetWindowDirty(WC_TOWN_VIEW, st->town->index);

		}

		st->UpdateVirtCoord();

		st->RecomputeIndustriesNear();

		DeleteStationIfEmpty(st);

	}

	return cost;

}

/**

 * Tests whether the company's vehicles have this station in orders

 * When company == INVALID_COMPANY, then check all vehicles

 * @param station station ID

 * @param company company ID, INVALID_COMPANY to disable the check

 */

bool HasStationInUse(StationID station, CompanyID company)

{

	const Vehicle *v;

	FOR_ALL_VEHICLES(v) {

		if (company == INVALID_COMPANY || v->owner == company) {

			const Order *order;

			FOR_VEHICLE_ORDERS(v, order) {

				if ((order->IsType(OT_GOTO_STATION) || order->IsType(OT_GOTO_WAYPOINT)) && order->GetDestination() == station) {

					return true;

				}

			}

		}

	}

	return false;

}

static const TileIndexDiffC _dock_tileoffs_chkaround[] = {

	{-1,  0},

	{ 0,  0},

	{ 0,  0},

	{ 0, -1}

};

static const byte _dock_w_chk[4] = { 2, 1, 2, 1 };

static const byte _dock_h_chk[4] = { 1, 2, 1, 2 };

/** Build a dock/haven.

 * @param tile tile where dock will be built

 * @param flags operation to perform

 * @param p1 (bit 0) - allow docks directly adjacent to other docks.

 * @param p2 bit 16-31: station ID to join (NEW_STATION if build new one)

 * @param text unused

 * @return the cost of this operation or an error

 */

CommandCost CmdBuildDock(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)

{

	StationID station_to_join = GB(p2, 16, 16);

	bool reuse = (station_to_join != NEW_STATION);

	if (!reuse) station_to_join = INVALID_STATION;

	bool distant_join = (station_to_join != INVALID_STATION);

	if (distant_join && (!_settings_game.station.distant_join_stations || !Station::IsValidID(station_to_join))) return CMD_ERROR;

	DiagDirection direction = GetInclinedSlopeDirection(GetTileSlope(tile, NULL));

	if (direction == INVALID_DIAGDIR) return_cmd_error(STR_ERROR_SITE_UNSUITABLE);

	direction = ReverseDiagDir(direction);

	/* Docks cannot be placed on rapids */

	if (IsWaterTile(tile)) return_cmd_error(STR_ERROR_SITE_UNSUITABLE);

	CommandCost ret = CheckIfAuthorityAllowsNewStation(tile, flags);

	ret.SetGlobalErrorMessage();

	if (ret.Failed()) return ret;

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

	if (DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR).Failed()) return CMD_ERROR;

	TileIndex tile_cur = tile + TileOffsByDiagDir(direction);

	if (!IsTileType(tile_cur, MP_WATER) || GetTileSlope(tile_cur, NULL) != SLOPE_FLAT) {

		return_cmd_error(STR_ERROR_SITE_UNSUITABLE);

	}

	if (MayHaveBridgeAbove(tile_cur) && IsBridgeAbove(tile_cur)) return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);

	/* Get the water class of the water tile before it is cleared.*/

	WaterClass wc = GetWaterClass(tile_cur);

	if (DoCommand(tile_cur, 0, 0, flags, CMD_LANDSCAPE_CLEAR).Failed()) return CMD_ERROR;

	tile_cur += TileOffsByDiagDir(direction);

	if (!IsTileType(tile_cur, MP_WATER) || GetTileSlope(tile_cur, NULL) != SLOPE_FLAT) {