#include "water_map.h"

#include "network/network.h"

#include "yapf/yapf.h"

#include "date.h"

#include "newgrf_callbacks.h"

#include "newgrf_engine.h"

#include "newgrf_sound.h"

#include "helpers.hpp"

#define INVALID_COORD (-0x8000)

#define GEN_HASH(x, y) ((GB((y), 6, 6) << 6) + GB((x), 7, 6))

	CMD_BUILD_RAIL_VEHICLE,

	CMD_BUILD_ROAD_VEH,

	CMD_BUILD_SHIP,

	CMD_BUILD_AIRCRAFT,

};

	CMD_SELL_RAIL_WAGON,

	CMD_SELL_ROAD_VEH,

	CMD_SELL_SHIP,

	CMD_SELL_AIRCRAFT,

};

	CMD_REFIT_RAIL_VEHICLE,

	CMD_REFIT_ROAD_VEH,

	CMD_REFIT_SHIP,

	CMD_REFIT_AIRCRAFT,

};

const uint32 _send_to_depot_proc_table[] = {

	CMD_SEND_TRAIN_TO_DEPOT,

	CMD_SEND_ROADVEH_TO_DEPOT,

	CMD_SEND_SHIP_TO_DEPOT,

	CMD_SEND_AIRCRAFT_TO_HANGAR,

};

		}

	}

	v = v_front;

	do {

		if (IsMultiheaded(v) && !IsTrainEngine(v)) {

			/* we build the rear ends of multiheaded trains with the front ones */

			continue;

		}

		build_argument = 3; // ensure that we only assign a number to the first engine

		if (CmdFailed(cost)) return cost;

		total_cost += cost;

		if (flags & DC_EXEC) {

			w = GetVehicle(_new_vehicle_id);

			if (v->cargo_type != w->cargo_type || v->cargo_subtype != w->cargo_subtype) {

				// we can't pay for refitting because we can't estimate refitting costs for a vehicle before it's build

				// if we pay for it anyway, the cost and the estimated cost will not be the same and we will have an assert

			}

			if (v->type == VEH_Train && HASBIT(v->u.rail.flags, VRF_REVERSE_DIRECTION)) {

				SETBIT(w->u.rail.flags, VRF_REVERSE_DIRECTION);

			}

			if (v->type == VEH_Train && !IsFrontEngine(v)) {

				// this s a train car

				// add this unit to the end of the train

				DoCommand(0, (w_rear->index << 16) | w->index, 1, flags, CMD_MOVE_RAIL_VEHICLE);

			} else {

				// this is a front engine or not a train. It need orders

				w_front = w;

	Vehicle *new_v = NULL;

	char vehicle_name[32];

	CargoID replacement_cargo_type;

	new_engine_type = EngineReplacementForPlayer(p, old_v->engine_type);

	if (new_engine_type == INVALID_ENGINE) new_engine_type = old_v->engine_type;

	replacement_cargo_type = GetNewCargoTypeForReplace(old_v, new_engine_type);

	/* check if we can't refit to the needed type, so no replace takes place to prevent the vehicle from altering cargo type */

	if (replacement_cargo_type == CT_INVALID) return 0;

	/* We give the player a loan of the same amount as the sell value.

	 * This is needed in case he needs the income from the sale to build the new vehicle.

	 * We take it back if building fails or when we really sell the old engine */

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

	SubtractMoneyFromPlayer(sell_value);

	if (CmdFailed(cost)) {

		SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

		SubtractMoneyFromPlayer(-sell_value); // Take back the money we just gave the player

		return cost;

	}

	if (replacement_cargo_type != CT_NO_REFIT) cost += GetRefitCost(new_engine_type); // add refit cost

	if (flags & DC_EXEC) {

		new_v = GetVehicle(_new_vehicle_id);

		*w = new_v; //we changed the vehicle, so MaybeReplaceVehicle needs to work on the new one. Now we tell it what the new one is

		/* refit if needed */

		if (replacement_cargo_type != CT_NO_REFIT) {

				/* Being here shows a failure, which most likely is in GetNewCargoTypeForReplace() or incorrect estimation costs */

				error("Autoreplace failed to refit. Replace engine %d to %d and refit to cargo %d", old_v->engine_type, new_v->engine_type, replacement_cargo_type);

			}

		}

		if (new_v->type == VEH_Train && HASBIT(old_v->u.rail.flags, VRF_REVERSE_DIRECTION) && !IsMultiheaded(new_v) && !(new_v->next != NULL && IsArticulatedPart(new_v->next))) {

			// we are autorenewing to a single engine, so we will turn it as the old one was turned as well

			SETBIT(new_v->u.rail.flags, VRF_REVERSE_DIRECTION);

		}

		if (old_v->type == VEH_Train && !IsFrontEngine(old_v)) {

			/* this is a railcar. We need to move the car into the train

			SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

			SubtractMoneyFromPlayer(-sell_value); // Pay back the loan

			return CMD_ERROR;

		}

	}

	/* Take back the money we just gave the player just before building the vehicle

	 * The player will get the same amount now that the sale actually takes place */

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

	SubtractMoneyFromPlayer(-sell_value);

	/* sell the engine/ find out how much you get for the old engine (income is returned as negative cost) */

	if (new_front) {

		/* now we assign the old unitnumber to the new vehicle */

		new_v->unitnumber = cached_unitnumber;

	}

	/* Transfer the name of the old vehicle */

	if ((flags & DC_EXEC) && vehicle_name[0] != '\0') {

		_cmd_text = vehicle_name;

		DoCommand(0, new_v->index, 0, DC_EXEC, CMD_NAME_VEHICLE);

	}

 */

int32 SendAllVehiclesToDepot(byte type, uint32 flags, bool service, PlayerID owner, uint16 vlw_flag, uint32 id)

{

	const Vehicle **sort_list = NULL;

	uint n, i;

	uint16 array_length = 0;

	n = GenerateVehicleSortList(&sort_list, &array_length, type, owner, id, vlw_flag);

	/* Send all the vehicles to a depot */

	for (i = 0; i < n; i++) {

		const Vehicle *v = sort_list[i];

		/* Return 0 if DC_EXEC is not set this is a valid goto depot command)

			* In this case we know that at least one vehicle can be sent to a depot

			* and we will issue the command. We can now safely quit the loop, knowing

			* it will succeed at least once. With DC_EXEC we really need to send them to the depot */

		if (!CmdFailed(ret) && !(flags & DC_EXEC)) {

			free((void*)sort_list);

			return 0;

		}

	}

	free((void*)sort_list);

		Order t;

		InvalidateWindow(WC_VEHICLE_VIEW, v->index);

		t = v->current_order;

		v->current_order.type = OT_DUMMY;

		v->current_order.flags = 0;

		if (t.refit_cargo < NUM_CARGO) {

			int32 cost;

			_current_player = v->owner;

			if (CmdFailed(cost)) {

				v->leave_depot_instantly = false; // We ensure that the vehicle stays in the depot

				if (v->owner == _local_player) {

					/* Notify the user that we stopped the vehicle */

					SetDParam(0, _vehicle_type_names[v->type - 0x10]);

					SetDParam(1, v->unitnumber);

					AddNewsItem(STR_ORDER_REFIT_FAILED, NEWS_FLAGS(NM_SMALL, NF_VIEWPORT|NF_VEHICLE, NT_ADVICE, 0), v->index, 0);

				}

			} else if (v->owner == _local_player && cost != 0) {

				ShowCostOrIncomeAnimation(v->x_pos, v->y_pos, v->z_pos, cost);

			}

/**

 * Get the colour map for a vehicle.

 * @param v Vehicle to get colour map for

 * @return A ready-to-use palette modifier

 */

SpriteID GetVehiclePalette(const Vehicle *v);

/* A lot of code calls for the invalidation of the status bar, which is widget 5.

 * Best is to have a virtual value for it when it needs to change again */

#define STATUS_BAR 5

extern const uint32 _send_to_depot_proc_table[];

#endif /* VEHICLE_H */

					break;

				case VLW_WIDGET_MANAGE_VEHICLES_DROPDOWN:

					assert(vl->l.list_length != 0);

					switch (e->we.dropdown.index) {

						case 0: /* Replace window */

							ShowReplaceVehicleWindow(vl->vehicle_type);

							break;

						case 1: /* Send for servicing */

							DoCommandP(0, GB(w->window_number, 16, 16) /* StationID or OrderID (depending on VLW) */,

								(w->window_number & VLW_MASK) | DEPOT_MASS_SEND | DEPOT_SERVICE,

								NULL,

							break;

						case 2: /* Send to Depots */

							DoCommandP(0, GB(w->window_number, 16, 16) /* StationID or OrderID (depending on VLW) */,

								(w->window_number & VLW_MASK) | DEPOT_MASS_SEND,

								NULL,

							break;

						default: NOT_REACHED();

					}

					break;

				default: NOT_REACHED();

			}

			SetWindowDirty(w);

			break;

		case WE_DESTROY:

			free((void*)vl->sort_list);