/* $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 timetable_cmd.cpp Commands related to time tabling. */

#include "stdafx.h"

#include "command_func.h"

#include "company_func.h"

#include "date_func.h"

#include "window_func.h"

#include "vehicle_base.h"

#include "cmd_helper.h"

#include "table/strings.h"

/**

 * Change/update a particular timetable entry.

 * @param v            The vehicle to change the timetable of.

 * @param order_number The index of the timetable in the order list.

 * @param val          The new data of the timetable entry.

 * @param mtf          Which part of the timetable entry to change.

 */

static void ChangeTimetable(Vehicle *v, VehicleOrderID order_number, uint16 val, ModifyTimetableFlags mtf)

{

	Order *order = v->GetOrder(order_number);

	int delta = 0;

	switch (mtf) {

		case MTF_WAIT_TIME:

			delta = val - order->wait_time;

			order->wait_time = val;

			break;

		case MTF_TRAVEL_TIME:

			delta = val - order->travel_time;

			order->travel_time = val;

			break;

		case MTF_TRAVEL_SPEED:

			order->max_speed = val;

			break;

		default:

			NOT_REACHED();

	}

	v->orders.list->UpdateOrderTimetable(delta);

	for (v = v->FirstShared(); v != NULL; v = v->NextShared()) {

		if (v->cur_real_order_index == order_number && v->current_order.Equals(*order)) {

			switch (mtf) {

				case MTF_WAIT_TIME:

					v->current_order.wait_time = val;

					break;

				case MTF_TRAVEL_TIME:

					v->current_order.travel_time = val;

					break;

				case MTF_TRAVEL_SPEED:

					v->current_order.max_speed = val;

					break;

				default:

					NOT_REACHED();

			}

		}

		SetWindowDirty(WC_VEHICLE_TIMETABLE, v->index);

	}

}

/**

 * Change timetable data of an order.

 * @param tile Not used.

 * @param flags Operation to perform.

 * @param p1 Various bitstuffed elements

 * - p1 = (bit  0-19) - Vehicle with the orders to change.

 * - p1 = (bit 20-27) - Order index to modify.

 * - p1 = (bit 28-29) - Timetable data to change (@see ModifyTimetableFlags)

 * @param p2 The amount of time to wait.

 * - p2 = (bit  0-15) - The data to modify as specified by p1 bits 28-29.

 * @param text unused

 * @return the cost of this operation or an error

 */

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

{

	VehicleID veh = GB(p1, 0, 20);

	Vehicle *v = Vehicle::GetIfValid(veh);

	if (v == NULL || !v->IsPrimaryVehicle()) return CMD_ERROR;

	CommandCost ret = CheckOwnership(v->owner);

	if (ret.Failed()) return ret;

	VehicleOrderID order_number = GB(p1, 20, 8);

	Order *order = v->GetOrder(order_number);

	if (order == NULL || order->IsType(OT_IMPLICIT)) return CMD_ERROR;

	ModifyTimetableFlags mtf = Extract<ModifyTimetableFlags, 28, 2>(p1);

	if (mtf >= MTF_END) return CMD_ERROR;

	int wait_time   = order->wait_time;

	int travel_time = order->travel_time;

	int max_speed   = order->max_speed;

	switch (mtf) {

		case MTF_WAIT_TIME:

			wait_time = GB(p2, 0, 16);

			break;

		case MTF_TRAVEL_TIME:

			travel_time = GB(p2, 0, 16);

			break;

		case MTF_TRAVEL_SPEED:

			max_speed = GB(p2, 0, 16);

			break;

		default:

			NOT_REACHED();

	}

	if (wait_time != order->wait_time) {

		switch (order->GetType()) {

			case OT_GOTO_STATION:

				if (order->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION) return_cmd_error(STR_ERROR_TIMETABLE_NOT_STOPPING_HERE);

				break;

			case OT_CONDITIONAL:

				break;

			default: return_cmd_error(STR_ERROR_TIMETABLE_ONLY_WAIT_AT_STATIONS);

		}

	}

	if (travel_time != order->travel_time && order->IsType(OT_CONDITIONAL)) return CMD_ERROR;

	if (max_speed != order->max_speed && (order->IsType(OT_CONDITIONAL) || v->type == VEH_AIRCRAFT)) return CMD_ERROR;

	if (flags & DC_EXEC) {

		if (wait_time   != order->wait_time)   ChangeTimetable(v, order_number, wait_time,   MTF_WAIT_TIME);

		if (travel_time != order->travel_time) ChangeTimetable(v, order_number, travel_time, MTF_TRAVEL_TIME);

		if (max_speed   != order->max_speed)   ChangeTimetable(v, order_number, max_speed,   MTF_TRAVEL_SPEED);

	}

	return CommandCost();

}

/**

 * Clear the lateness counter to make the vehicle on time.

 * @param tile Not used.

 * @param flags Operation to perform.

 * @param p1 Various bitstuffed elements

 * - p1 = (bit  0-19) - Vehicle with the orders to change.

 * @param p2 unused

 * @param text unused

 * @return the cost of this operation or an error

 */

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

{

	VehicleID veh = GB(p1, 0, 20);

	Vehicle *v = Vehicle::GetIfValid(veh);

	if (v == NULL || !v->IsPrimaryVehicle()) return CMD_ERROR;

	CommandCost ret = CheckOwnership(v->owner);

	if (ret.Failed()) return ret;

	if (flags & DC_EXEC) {

		v->lateness_counter = 0;

		SetWindowDirty(WC_VEHICLE_TIMETABLE, v->index);

	}

	return CommandCost();

}

/**

 * Set the start date of the timetable.

 * @param tile Not used.

 * @param flags Operation to perform.

 * @param p1 Vehicle id.

 * @param p2 The timetable start date.

 * @param text Not used.

 * @return The error or cost of the operation.

 */

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

{

	Vehicle *v = Vehicle::GetIfValid(GB(p1, 0, 20));

	if (v == NULL || !v->IsPrimaryVehicle()) return CMD_ERROR;

	CommandCost ret = CheckOwnership(v->owner);

	if (ret.Failed()) return ret;

	/* Don't let a timetable start more than 15 years into the future or 1 year in the past. */

	Date start_date = (Date)p2;

	if (start_date < 0 || start_date > MAX_DAY) return CMD_ERROR;

	if (start_date - _date > 15 * DAYS_IN_LEAP_YEAR) return CMD_ERROR;

	if (_date - start_date > DAYS_IN_LEAP_YEAR) return CMD_ERROR;

	if (flags & DC_EXEC) {

		v->lateness_counter = 0;

		ClrBit(v->vehicle_flags, VF_TIMETABLE_STARTED);

		v->timetable_start = start_date;

		SetWindowDirty(WC_VEHICLE_TIMETABLE, v->index);

	}

	return CommandCost();

}

/**

 * Start or stop filling the timetable automatically from the time the vehicle

 * actually takes to complete it. When starting to autofill the current times

 * are cleared and the timetable will start again from scratch.

 * @param tile Not used.

 * @param flags Operation to perform.

 * @param p1 Vehicle index.

 * @param p2 Various bitstuffed elements

 * - p2 = (bit 0) - Set to 1 to enable, 0 to disable autofill.

 * - p2 = (bit 1) - Set to 1 to preserve waiting times in non-destructive mode

 * @param text unused

 * @return the cost of this operation or an error

 */

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

{

	VehicleID veh = GB(p1, 0, 20);

	Vehicle *v = Vehicle::GetIfValid(veh);

	if (v == NULL || !v->IsPrimaryVehicle()) return CMD_ERROR;

	CommandCost ret = CheckOwnership(v->owner);

	if (ret.Failed()) return ret;

	if (flags & DC_EXEC) {

		if (HasBit(p2, 0)) {

			/* Start autofilling the timetable, which clears the

			 * "timetable has started" bit. Times are not cleared anymore, but are

			 * overwritten when the order is reached now. */

			SetBit(v->vehicle_flags, VF_AUTOFILL_TIMETABLE);

			ClrBit(v->vehicle_flags, VF_TIMETABLE_STARTED);

			/* Overwrite waiting times only if they got longer */

			if (HasBit(p2, 1)) SetBit(v->vehicle_flags, VF_AUTOFILL_PRES_WAIT_TIME);

			v->timetable_start = 0;

			v->lateness_counter = 0;

		} else {

			ClrBit(v->vehicle_flags, VF_AUTOFILL_TIMETABLE);

			ClrBit(v->vehicle_flags, VF_AUTOFILL_PRES_WAIT_TIME);

		}

		for (Vehicle *v2 = v->FirstShared(); v2 != NULL; v2 = v2->NextShared()) {

			if (v2 != v) {

				/* Stop autofilling; only one vehicle at a time can perform autofill */

				ClrBit(v2->vehicle_flags, VF_AUTOFILL_TIMETABLE);

				ClrBit(v2->vehicle_flags, VF_AUTOFILL_PRES_WAIT_TIME);

			}

			SetWindowDirty(WC_VEHICLE_TIMETABLE, v2->index);

		}

	}

	return CommandCost();

}

/**

 * Update the timetable for the vehicle.

 * @param v The vehicle to update the timetable for.

 * @param travelling Whether we just travelled or waited at a station.

 */

void UpdateVehicleTimetable(Vehicle *v, bool travelling)

{

	uint timetabled = travelling ? v->current_order.travel_time : v->current_order.wait_time;

	uint time_taken = v->current_order_time;

	v->current_order_time = 0;

	if (v->current_order.IsType(OT_IMPLICIT)) return; // no timetabling of auto orders

	VehicleOrderID first_manual_order = 0;

	for (Order *o = v->GetFirstOrder(); o != NULL && o->IsType(OT_IMPLICIT); o = o->next) {

		++first_manual_order;

	}

	bool just_started = false;

	/* This vehicle is arriving at the first destination in the timetable. */

	if (v->cur_real_order_index == first_manual_order && travelling) {

		/* If the start date hasn't been set, or it was set automatically when

		 * the vehicle last arrived at the first destination, update it to the

		 * current time. Otherwise set the late counter appropriately to when

		 * the vehicle should have arrived. */

		just_started = !HasBit(v->vehicle_flags, VF_TIMETABLE_STARTED);

		if (v->timetable_start != 0) {

			v->lateness_counter = (_date - v->timetable_start) * DAY_TICKS + _date_fract;

			v->timetable_start = 0;

		}

		SetBit(v->vehicle_flags, VF_TIMETABLE_STARTED);

		SetWindowDirty(WC_VEHICLE_TIMETABLE, v->index);

	}

	if (!HasBit(v->vehicle_flags, VF_TIMETABLE_STARTED)) return;

	if (HasBit(v->vehicle_flags, VF_AUTOFILL_TIMETABLE)) {

		if (travelling && !HasBit(v->vehicle_flags, VF_AUTOFILL_PRES_WAIT_TIME)) {

			/* Need to clear that now as otherwise we are not able to reduce the wait time */

			v->current_order.wait_time = 0;