// Cyphesis Online RPG Server and AI Engine
// Copyright (C) 2009 Alistair Riddoch
//
// This program 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; either version 2 of the License, or
// (at your option) any later version.
// 
// This program 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 this program; if not, write to the Free Software Foundation,
// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA


#ifdef NDEBUG
#undef NDEBUG
#endif
#ifndef DEBUG
#define DEBUG
#endif

#include "rules/simulation/Task.h"
#include "rules/Entity.h"
#include "rules/Character.h"
#include "rules/Script.h"

#include "common/log.h"

#include <Atlas/Objects/Generic.h>

#include <iostream>

#include <cassert>

class TestScript : public Script {
public:
	TestScript() {}

	virtual bool operation(const std::string& opname,
						   const Atlas::Objects::Operation::RootOperation& op,
						   OpVector& res) { return true; }
};

int main() {
	int ret = 0;

	Operation op;

	Character chr(3);

	{
		Task ts(chr);

		OpVector res;
		Atlas::Objects::Operation::Generic c;
		c->setParent("generic");

		// It has no script, so init will fail, and it will be irrelevant
		ts.initTask(c, res);

		assert(ts.obsolete());
	}

	{
		Task ts(chr);

		Script* script1 = new Script;
		Script* script2 = new Script;

		ts.setScript(script1);
		ts.setScript(script2);

		assert(!ts.obsolete());

		OpVector res;
		Atlas::Objects::Operation::Generic c;
		c->setParent("generic");

		ts.initTask(c, res);

		// It has useless script, so init will fail, and it will be irrelevant
		ts.TickOperation(op, res);

		assert(ts.obsolete());
	}

	{
		Task ts(chr);

		Script* script1 = new TestScript;

		ts.setScript(script1);

		assert(!ts.obsolete());

		OpVector res;
		Atlas::Objects::Operation::Generic c;
		c->setParent("generic");

		assert(res.empty());

		ts.initTask(c, res);

		// It has useless script, so init will fail, and it will be irrelevant
		ts.TickOperation(op, res);

		assert(!ts.obsolete());
		assert(!res.empty());
	}

	return ret;
}

// stubs

namespace Atlas {
namespace Objects {
namespace Operation {
int TICK_NO = -1;
}
}
}

Task::Task(Character& chr) : m_refCount(0), m_serialno(0), m_obsolete(false), m_progress(-1), m_rate(-1), m_character(chr) {
}

Task::~Task() {
}

void Task::irrelevant() {
	m_obsolete = true;
}

Operation Task::nextTick(double interval) {
	return Operation();
}

int Task::getAttr(const std::string& attr,
				  Atlas::Message::Element& val) const {
	return -1;
}

void Task::setAttr(const std::string& attr,
				   const Atlas::Message::Element& val) {
}

Script::Script() {
}

Script::~Script() {
}

bool Script::operation(const std::string& opname,
					   const Atlas::Objects::Operation::RootOperation& op,
					   OpVector& res) {
	return false;
}

void Script::hook(const std::string& function, LocatedEntity* entity) {
}

#include "rules/Location_impl.h"


Character::Character(const std::string& id, long intId) :
		Thing(id, intId),
		m_movement(*(Movement*) 0),
		m_task(0), m_mind(0), m_externalMind(0) {
}

Character::~Character() {
}

void Character::operation(const Operation& op, OpVector&) {
}

void Character::externalOperation(const Operation& op, Link&) {
}


void Character::ImaginaryOperation(const Operation& op, OpVector&) {
}

void Character::TickOperation(const Operation& op, OpVector&) {
}

void Character::TalkOperation(const Operation& op, OpVector&) {
}

void Character::UseOperation(const Operation& op, OpVector&) {
}

void Character::WieldOperation(const Operation& op, OpVector&) {
}

void Character::AttackOperation(const Operation& op, OpVector&) {
}

void Character::RelayOperation(const Operation& op, OpVector&) {
}

void Character::mindAttackOperation(const Operation&, OpVector&) {
}

void Character::mindCreateOperation(const Operation&, OpVector&) {
}

void Character::mindDeleteOperation(const Operation&, OpVector&) {
}

void Character::mindGoalInfoOperation(const Operation&, OpVector&) {
}

void Character::mindImaginaryOperation(const Operation&, OpVector&) {
}

void Character::mindLookOperation(const Operation&, OpVector&) {
}

void Character::mindMoveOperation(const Operation&, OpVector&) {
}

void Character::mindSetOperation(const Operation&, OpVector&) {
}

void Character::mindSetupOperation(const Operation&, OpVector&) {
}

void Character::mindTalkOperation(const Operation&, OpVector&) {
}

void Character::mindThoughtOperation(const Operation&, OpVector&) {
}

void Character::mindTickOperation(const Operation&, OpVector&) {
}

void Character::mindTouchOperation(const Operation&, OpVector&) {
}

void Character::mindUpdateOperation(const Operation&, OpVector&) {
}

void Character::mindUseOperation(const Operation&, OpVector&) {
}

void Character::mindWieldOperation(const Operation&, OpVector&) {
}


void Character::mindOtherOperation(const Operation&, OpVector&) {
}

void Character::sendMind(const Operation& op, OpVector& res) {
}

Thing::Thing(const std::string& id, long intId) :
		Entity(id, intId) {
}

Thing::~Thing() {
}

void Thing::DeleteOperation(const Operation& op, OpVector& res) {
}

void Thing::MoveOperation(const Operation& op, OpVector& res) {
}

void Thing::SetOperation(const Operation& op, OpVector& res) {
}

void Thing::LookOperation(const Operation& op, OpVector& res) {
}

void Thing::CreateOperation(const Operation& op, OpVector& res) {
}

void Thing::UpdateOperation(const Operation& op, OpVector& res) {
}

Entity::Entity(const std::string& id, long intId) :
		LocatedEntity(id, intId) {
}

Entity::~Entity() {
}

void Entity::destroy() {
	destroyed.emit();
}

void Entity::AppearanceOperation(const Operation&, OpVector&) {
}

void Entity::AttackOperation(const Operation&, OpVector&) {
}

void Entity::CreateOperation(const Operation&, OpVector&) {
}

void Entity::DeleteOperation(const Operation&, OpVector&) {
}

void Entity::DisappearanceOperation(const Operation&, OpVector&) {
}

void Entity::GetOperation(const Operation&, OpVector&) {
}

void Entity::InfoOperation(const Operation&, OpVector&) {
}

void Entity::ImaginaryOperation(const Operation&, OpVector&) {
}

void Entity::LookOperation(const Operation&, OpVector&) {
}

void Entity::MoveOperation(const Operation&, OpVector&) {
}

void Entity::SetOperation(const Operation&, OpVector&) {
}

void Entity::SightOperation(const Operation&, OpVector&) {
}

void Entity::SoundOperation(const Operation&, OpVector&) {
}

void Entity::TalkOperation(const Operation&, OpVector&) {
}

void Entity::TickOperation(const Operation&, OpVector&) {
}

void Entity::TouchOperation(const Operation&, OpVector&) {
}

void Entity::UpdateOperation(const Operation&, OpVector&) {
}

void Entity::UseOperation(const Operation&, OpVector&) {
}

void Entity::WieldOperation(const Operation&, OpVector&) {
}

void Entity::RelayOperation(const Operation&, OpVector&) {
}

void Entity::externalOperation(const Operation& op, Link&) {
}

void Entity::operation(const Operation& op, OpVector& res) {
}

void Entity::addToMessage(Atlas::Message::MapType& omap) const {
}

void Entity::addToEntity(const Atlas::Objects::Entity::RootEntity& ent) const {
}

PropertyBase* Entity::setAttr(const std::string& name,
							  const Atlas::Message::Element& attr) {
	return 0;
}

const PropertyBase* Entity::getProperty(const std::string& name) const {
	return 0;
}

PropertyBase* Entity::modProperty(const std::string& name) {
	return 0;
}

void Entity::onContainered(const LocatedEntity*) {
}

void Entity::onUpdated() {
}

void Entity::callOperation(const Operation& op, OpVector& res) {
}

LocatedEntity::LocatedEntity(const std::string& id, long intId) :
		Router(id, intId),
		m_refCount(0), m_seq(0),
		m_script(0), m_type(0), m_flags(0), m_contains(0) {
}

LocatedEntity::~LocatedEntity() {
}

bool LocatedEntity::hasAttr(const std::string& name) const {
	return false;
}

int LocatedEntity::getAttr(const std::string& name,
						   Atlas::Message::Element& attr) const {
	return -1;
}

int LocatedEntity::getAttrType(const std::string& name,
							   Atlas::Message::Element& attr,
							   int type) const {
	return -1;
}

PropertyBase* LocatedEntity::setAttr(const std::string& name,
									 const Atlas::Message::Element& attr) {
	return 0;
}

const PropertyBase* LocatedEntity::getProperty(const std::string& name) const {
	return 0;
}

void LocatedEntity::onContainered(const LocatedEntity*) {
}

void LocatedEntity::onUpdated() {
}

void LocatedEntity::makeContainer() {
	if (m_contains == 0) {
		m_contains.reset(new LocatedEntitySet);
	}
}

void LocatedEntity::merge(const Atlas::Message::MapType& ent) {
}


