/* $Id$ */

/** @file ai_vehicle.cpp handles the functions of the AIVehicle class */

#include "ai_vehicle.hpp"
#include "ai_engine.hpp"
#include "ai_cargo.hpp"
#include "ai_order.hpp"
#include "../../command_func.h"
#include "../../depot.h"
#include "../../engine.h"
#include "../../player_func.h"
#include "../../aircraft.h"
#include "../../strings_func.h"
#include "../../core/alloc_func.hpp"
#include "table/strings.h"

/* static */ bool AIVehicle::IsValidVehicle(VehicleID vehicle_id)
{
	return ::IsValidVehicleID(vehicle_id) && ::GetVehicle(vehicle_id)->owner == _current_player && GetVehicle(vehicle_id)->IsPrimaryVehicle();
}

VehicleID AIVehicle::BuildVehicle(TileIndex depot, EngineID engine_id)
{
	if (!AIEngine::IsValidEngine(engine_id)) return false;

	/* Reset the internal NewVehicleID in case we are in TestMode */
	AIObject::SetNewVehicleID(0);

	bool ret;
	switch (::GetEngine(engine_id)->type) {
		case VEH_ROAD: ret = this->DoCommand(depot, engine_id, 0, CMD_BUILD_ROAD_VEH); break;
		case VEH_TRAIN: ret = this->DoCommand(depot, engine_id, 0, CMD_BUILD_RAIL_VEHICLE); break;
		case VEH_SHIP: ret = this->DoCommand(depot, engine_id, 0, CMD_BUILD_SHIP); break;
		case VEH_AIRCRAFT: ret = this->DoCommand(depot, engine_id, 0, CMD_BUILD_AIRCRAFT); break;
		default: NOT_REACHED(); return INVALID_VEHICLE;
	}

	return ret ? AIObject::GetNewVehicleID() : INVALID_VEHICLE;
}

VehicleID AIVehicle::CloneVehicle(TileIndex depot, VehicleID vehicle_id, bool share_orders)
{
	if (!this->IsValidVehicle(vehicle_id)) return false;

	/* Reset the internal NewVehicleID in case we are in TestMode */
	AIObject::SetNewVehicleID(0);

	bool ret = this->DoCommand(depot, vehicle_id, share_orders, CMD_CLONE_VEHICLE);
	return ret ? AIObject::GetNewVehicleID() : INVALID_VEHICLE;
}

bool AIVehicle::RefitVehicle(VehicleID vehicle_id, CargoID cargo)
{
	if (!this->IsValidVehicle(vehicle_id) || !AICargo::IsValidCargo(cargo)) return false;

	switch (::GetVehicle(vehicle_id)->type) {
		case VEH_ROAD: return this->DoCommand(0, vehicle_id, cargo, CMD_REFIT_ROAD_VEH);
		case VEH_TRAIN: return this->DoCommand(0, vehicle_id, cargo, CMD_REFIT_RAIL_VEHICLE);
		case VEH_SHIP: return this->DoCommand(0, vehicle_id, cargo, CMD_REFIT_SHIP);
		case VEH_AIRCRAFT: return this->DoCommand(0, vehicle_id, cargo, CMD_REFIT_AIRCRAFT);
		default: return false;
	}
}


bool AIVehicle::SellVehicle(VehicleID vehicle_id)
{
	if (!this->IsValidVehicle(vehicle_id)) return false;

	switch (::GetVehicle(vehicle_id)->type) {
		case VEH_ROAD: return this->DoCommand(0, vehicle_id, 0, CMD_SELL_ROAD_VEH);
		case VEH_TRAIN: return this->DoCommand(0, vehicle_id, 0, CMD_SELL_RAIL_WAGON);
		case VEH_SHIP: return this->DoCommand(0, vehicle_id, 0, CMD_SELL_SHIP);
		case VEH_AIRCRAFT: return this->DoCommand(0, vehicle_id, 0, CMD_SELL_AIRCRAFT);
		default: return false;
	}
}

bool AIVehicle::SendVehicleToDepot(VehicleID vehicle_id)
{
	if (!this->IsValidVehicle(vehicle_id)) return false;

	switch (::GetVehicle(vehicle_id)->type) {
		case VEH_ROAD: return this->DoCommand(0, vehicle_id, 0, CMD_SEND_ROADVEH_TO_DEPOT);
		case VEH_TRAIN: return this->DoCommand(0, vehicle_id, 0, CMD_SEND_TRAIN_TO_DEPOT);
		case VEH_SHIP: return this->DoCommand(0, vehicle_id, 0, CMD_SEND_SHIP_TO_DEPOT);
		case VEH_AIRCRAFT: return this->DoCommand(0, vehicle_id, 0, CMD_SEND_AIRCRAFT_TO_HANGAR);
		default: return false;
	}
}

bool AIVehicle::IsInDepot(VehicleID vehicle_id)
{
	if (!this->IsValidVehicle(vehicle_id)) return false;
	return ::GetVehicle(vehicle_id)->IsInDepot();
}

bool AIVehicle::IsStoppedInDepot(VehicleID vehicle_id)
{
	if (!this->IsValidVehicle(vehicle_id)) return false;
	return ::GetVehicle(vehicle_id)->IsStoppedInDepot();
}

bool AIVehicle::StartStopVehicle(VehicleID vehicle_id)
{
	if (!this->IsValidVehicle(vehicle_id)) return false;

	switch (::GetVehicle(vehicle_id)->type) {
		case VEH_ROAD: return this->DoCommand(0, vehicle_id, 0, CMD_START_STOP_ROADVEH);
		case VEH_TRAIN: return this->DoCommand(0, vehicle_id, 0, CMD_START_STOP_TRAIN);
		case VEH_SHIP: return this->DoCommand(0, vehicle_id, 0, CMD_START_STOP_SHIP);
		case VEH_AIRCRAFT: return this->DoCommand(0, vehicle_id, 0, CMD_START_STOP_AIRCRAFT);
		default: return false;
	}
}

bool AIVehicle::SkipToVehicleOrder(VehicleID vehicle_id, uint32 order_id)
{
	if (!AIOrder::IsValidVehicleOrder(vehicle_id, order_id)) return false;

	return this->DoCommand(0, vehicle_id, order_id, CMD_SKIP_TO_ORDER);
}

bool AIVehicle::SetName(VehicleID vehicle_id, const char *name)
{
	if (!this->IsValidVehicle(vehicle_id)) return false;
	if (name == NULL) return false;

	_cmd_text = name;
	return this->DoCommand(0, vehicle_id, 0, CMD_NAME_VEHICLE);
}

/* static */ TileIndex AIVehicle::GetLocation(VehicleID vehicle_id)
{
	if (!AIVehicle::IsValidVehicle(vehicle_id)) return INVALID_TILE;

	return ::GetVehicle(vehicle_id)->tile;
}

/* static */ EngineID AIVehicle::GetEngineType(VehicleID vehicle_id)
{
	if (!AIVehicle::IsValidVehicle(vehicle_id)) return INVALID_ENGINE;

	return ::GetVehicle(vehicle_id)->engine_type;
}

/* static */ int32 AIVehicle::GetUnitNumber(VehicleID vehicle_id)
{
	if (!AIVehicle::IsValidVehicle(vehicle_id)) return -1;

	return ::GetVehicle(vehicle_id)->unitnumber;
}

/* static */ char *AIVehicle::GetName(VehicleID vehicle_id)
{
	if (!AIVehicle::IsValidVehicle(vehicle_id)) return NULL;

	static const int len = 64;
	char *vehicle_name = MallocT<char>(len);

	::SetDParam(0, vehicle_id);
	::GetString(vehicle_name, STR_VEHICLE_NAME, &vehicle_name[len - 1]);
	return vehicle_name;
}

/* static */ int32 AIVehicle::GetAge(VehicleID vehicle_id)
{
	if (!AIVehicle::IsValidVehicle(vehicle_id)) return -1;

	return ::GetVehicle(vehicle_id)->age;
}

/* static */ int32 AIVehicle::GetMaxAge(VehicleID vehicle_id)
{
	if (!AIVehicle::IsValidVehicle(vehicle_id)) return -1;

	return ::GetVehicle(vehicle_id)->max_age;
}

/* static */ int32 AIVehicle::GetAgeLeft(VehicleID vehicle_id)
{
	if (!AIVehicle::IsValidVehicle(vehicle_id)) return -1;

	return ::GetVehicle(vehicle_id)->max_age - ::GetVehicle(vehicle_id)->age;
}

/* static */ int32 AIVehicle::GetProfitThisYear(VehicleID vehicle_id)
{
	if (!AIVehicle::IsValidVehicle(vehicle_id)) return -1;

	return ::GetVehicle(vehicle_id)->profit_this_year;
}

/* static */ int32 AIVehicle::GetProfitLastYear(VehicleID vehicle_id)
{
	if (!AIVehicle::IsValidVehicle(vehicle_id)) return -1;

	return ::GetVehicle(vehicle_id)->profit_last_year;
}

/* static */ AIVehicle::VehicleType AIVehicle::GetVehicleType(VehicleID vehicle_id)
{
	if (!AIVehicle::IsValidVehicle(vehicle_id)) return VEHICLE_INVALID;

	switch (GetVehicle(vehicle_id)->type) {
		case VEH_ROAD:     return VEHICLE_ROAD;
		case VEH_TRAIN:    return VEHICLE_RAIL;
		case VEH_SHIP:     return VEHICLE_WATER;
		case VEH_AIRCRAFT: return VEHICLE_AIR;
		default:           return VEHICLE_INVALID;
	}
}