/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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 3 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, see <http://www.gnu.org/licenses/>.
 *
 *
 * Based on the original sources
 *   Faery Tale II -- The Halls of the Dead
 *   (c) 1993-1996 The Wyrmkeep Entertainment Co.
 */

#ifndef SAGA2_TARGET_H
#define SAGA2_TARGET_H

namespace Saga2 {

struct StandingTileInfo;

const   int     kMaxObjDist = kPlatformWidth * kTileUVSize * 8;
const   int     kMaxTileDist = kPlatformWidth * kTileUVSize * 2;
const   int     kMaxMetaDist = kPlatformWidth * kTileUVSize * 8;

enum TargetType {
	kLocationTarget,
	kSpecificTileTarget,
	kTilePropertyTarget,
	kSpecificMetaTileTarget,
	kMetaTilePropertyTarget,
	kSpecificObjectTarget,
	kObjectPropertyTarget,
	kSpecificActorTarget,
	kActorPropertyTarget
};

/* ===================================================================== *
   Misc. function prototypes
 * ===================================================================== */

class Target;

//  Deletes targets allocated on the heap using new
void deleteTarget(Target *t);

void readTarget(void *mem, Common::InSaveFile *in);
void writeTarget(const Target *t, Common::MemoryWriteStreamDynamic *out);
int32 targetArchiveSize(const Target *t);

/* ===================================================================== *
   TargetLocationArray structure
 * ===================================================================== */

//  This structure is used to query the target class for multiple target
//  locations
struct TargetLocationArray {
	const int16         size;   //  number of allocated elements in array
	int16               locs;   //  number of array elements with valid data

	//  These arrays must be allocated by calling function
	TilePoint *const   locArray;    //  pointer to location array
	int16 *const       distArray;   //  pointer to distance array

	//  Constructor
	TargetLocationArray(int16 s, TilePoint *arr, int16 *dArr) :
		size(s),
		locs(0),
		locArray(arr),
		distArray(dArr) {
	}
};

/* ===================================================================== *
   TargetObjectArray structure
 * ===================================================================== */

//  This structure is used to query the target class for multiple target
//  objects
struct TargetObjectArray {
	const int16         size;   //  number of allocated elements in array
	int16               objs;   //  number of array elements with valid data

	//  These arrays must be allocated by calling function
	GameObject **const objArray;    //  pointer to object pointer array
	int16 *const       distArray;   //  pointer to distance array

	//  Constructor
	TargetObjectArray(int16 s, GameObject **arr, int16 *dArr) :
		size(s),
		objs(0),
		objArray(arr),
		distArray(dArr) {
	}
};

/* ===================================================================== *
   TargetActorArray structure
 * ===================================================================== */

//  This structure is used to query the target class for multiple target
//  actors
struct TargetActorArray {
	const int16     size;       //  number of allocated elements in array
	int16           actors;     //  number of array elements with valid data

	//  These arrays must be allocated by calling function
	Actor **const  actorArray;  //  pointer to actor pointer array
	int16 *const   distArray;   //  pointer to distance array

	//  Constructor
	TargetActorArray(int16 s, Actor **arr, int16 *dArr) :
		size(s),
		actors(0),
		actorArray(arr),
		distArray(dArr) {
	}
};

/* ===================================================================== *
   Target class
 * ===================================================================== */

class Target {
public:
	//  virtual destructor
	virtual ~Target() {}

	//  Return the number of bytes needed to archive this object in
	//  a buffer
	virtual int32 archiveSize() const = 0;

	virtual void write(Common::MemoryWriteStreamDynamic *out) const = 0;

	//  Return an integer representing the type of target
	virtual int16 getType() const = 0;

	//  Virtual function returning the sizeof this target
	virtual size_t size() const = 0;

	//  Create a copy of this target at the specified address
	virtual void clone(void *mem) const = 0;

	//  Determine if the specified target is equivalent to this target
	virtual bool operator == (const Target &t) const = 0;
	bool operator != (const Target &t) const {
		return !operator == (t);
	}

	//  Overloaded memory management functions for constructing and
	//  destructing Targets in place.
	void *operator new (size_t, void *p) {
		return p;
	}

	virtual bool isObjectTarget() const;
	virtual bool isActorTarget() const;

	//  Return location of closest instance of target
	virtual TilePoint where(GameWorld *world, const TilePoint &tp) const = 0;
	//  Fill array with locations of closest instances of target
	virtual int16 where(
	    GameWorld *world,
	    const TilePoint &tp,
	    TargetLocationArray &tla) const = 0;
};

/* ===================================================================== *
   LocationTarget class
 * ===================================================================== */

class LocationTarget : public Target {
	TilePoint   _loc;

public:
	//  Constructor -- initial construction
	LocationTarget(const TilePoint &tp) : _loc(tp) {}

	LocationTarget(Common::SeekableReadStream *stream);

	//  Return the number of bytes needed to archive this object in
	//  a buffer
	int32 archiveSize() const;

	void write(Common::MemoryWriteStreamDynamic *out) const;

	//  Return an integer representing the type of target
	int16 getType() const;

	//  Virtual function returning the sizeof this target
	size_t size() const;

	//  Create a copy of this target at the specified address
	void clone(void *mem) const;

	//  Determine if the specified target is equivalent to this target
	bool operator == (const Target &t) const;

	//  Determine if the specified location target is equivalent to this
	//  location target
	bool operator == (const LocationTarget &lt) const {
		return _loc == lt._loc;
	}
	bool operator != (const LocationTarget &lt) const {
		return _loc != lt._loc;
	}

	TilePoint where(GameWorld *world, const TilePoint &tp) const;
	int16 where(
	    GameWorld *world,
	    const TilePoint &tp,
	    TargetLocationArray &tla) const;
};

/* ===================================================================== *
   TileTarget class
 * ===================================================================== */

class TileTarget : public Target {
public:
	virtual bool isTarget(StandingTileInfo &sti) const = 0;

	TilePoint where(GameWorld *world, const TilePoint &tp) const;
	int16 where(
	    GameWorld *world,
	    const TilePoint &tp,
	    TargetLocationArray &tla) const;
};

/* ===================================================================== *
   SpecificTileTarget class
 * ===================================================================== */

class SpecificTileTarget : public TileTarget {
	TileID  _tile;

public:
	//  Constructor -- initial construction
	SpecificTileTarget(TileID t) : _tile(t) {}

	SpecificTileTarget(Common::SeekableReadStream *stream);

	//  Return the number of bytes needed to archive this object in
	//  a buffer
	int32 archiveSize() const;

	void write(Common::MemoryWriteStreamDynamic *out) const;

	//  Return an integer representing the type of target
	int16 getType() const;

	//  Virtual function returning the sizeof this target
	size_t size() const;

	//  Create a copy of this target at the specified address
	void clone(void *mem) const;

	//  Determine if the specified target is equivalent to this target
	bool operator == (const Target &t) const;

	bool isTarget(StandingTileInfo &sti) const;
};

/* ===================================================================== *
   TilePropertyTarget class
 * ===================================================================== */

class TilePropertyTarget : public TileTarget {
	TilePropertyID  _tileProp;

public:
	//  Constructor -- initial construction
	TilePropertyTarget(TilePropertyID tProp) : _tileProp(tProp) {}

	TilePropertyTarget(Common::SeekableReadStream *stream);

	//  Return the number of bytes needed to archive this object in
	//  a buffer
	int32 archiveSize() const;

	void write(Common::MemoryWriteStreamDynamic *out) const;

	//  Return an integer representing the type of target
	int16 getType() const;

	//  Virtual function returning the sizeof this target
	size_t size() const;

	//  Create a copy of this target at the specified address
	void clone(void *mem) const;

	//  Determine if the specified target is equivalent to this target
	bool operator == (const Target &t) const;

	bool isTarget(StandingTileInfo &sti) const;
};

/* ===================================================================== *
   MetaTileTarget class
 * ===================================================================== */

class MetaTileTarget : public Target {
public:
	virtual bool isTarget(
	    MetaTile *mt,
	    int16 mapNum,
	    const TilePoint &tp) const = 0;

	TilePoint where(GameWorld *world, const TilePoint &tp) const;
	int16 where(
	    GameWorld *world,
	    const TilePoint &tp,
	    TargetLocationArray &tla) const;
};

/* ===================================================================== *
   SpecificMetaTileTarget class
 * ===================================================================== */

class SpecificMetaTileTarget : public MetaTileTarget {
	MetaTileID  _meta;

public:
	//  Constructor -- initial construction
	SpecificMetaTileTarget(MetaTileID mt) : _meta(mt) {}

	SpecificMetaTileTarget(Common::SeekableReadStream *stream);

	//  Return the number of bytes needed to archive this object in
	//  a buffer
	int32 archiveSize() const;

	void write(Common::MemoryWriteStreamDynamic *out) const;

	//  Return an integer representing the type of target
	int16 getType() const;

	//  Virtual function returning the sizeof this target
	size_t size() const;

	//  Create a copy of this target at the specified address
	void clone(void *mem) const;

	//  Determine if the specified target is equivalent to this target
	bool operator == (const Target &t) const;

	bool isTarget(MetaTile *mt, int16 mapNum, const TilePoint &tp) const;
};

/* ===================================================================== *
   MetaTilePropertyTarget class
 * ===================================================================== */

class MetaTilePropertyTarget : public MetaTileTarget {
	MetaTilePropertyID  _metaProp;

public:
	//  Constructor -- initial construction
	MetaTilePropertyTarget(MetaTilePropertyID mtProp) :
		_metaProp(mtProp) {
	}

	MetaTilePropertyTarget(Common::SeekableReadStream *stream);

	//  Return the number of bytes needed to archive this object in
	//  a buffer
	int32 archiveSize() const;

	void write(Common::MemoryWriteStreamDynamic *out) const;

	//  Return an integer representing the type of target
	int16 getType() const;

	//  Virtual function returning the sizeof this target
	size_t size() const;

	//  Create a copy of this target at the specified address
	void clone(void *mem) const;

	//  Determine if the specified target is equivalent to this target
	bool operator == (const Target &t) const;

	bool isTarget(MetaTile *mt, int16 mapNum, const TilePoint &tp) const;
};

/* ===================================================================== *
   ObjectTarget class
 * ===================================================================== */

class ObjectTarget : public Target {

	//  These are recursive functions used to fill a target array
	//  by inspecting an object and all of the objects contained in
	//  that object
	void searchObject(
	    GameObject *obj,
	    int16 dist,
	    TargetObjectArray &toa) const;
	void searchObject(
	    GameObject *obj,
	    const TilePoint &tp,
	    int16 dist,
	    TargetLocationArray &tla) const;

public:
	bool isObjectTarget() const;

	TilePoint where(GameWorld *world, const TilePoint &tp) const;
	int16 where(
	    GameWorld *world,
	    const TilePoint &tp,
	    TargetLocationArray &tla) const;

	//  Determine if the specified object meets the target criterion
	virtual bool isTarget(GameObject *testObj) const = 0;

	//  Return closest instance of target object
	virtual GameObject *object(GameWorld *world, const TilePoint &tp) const;
	//  Fill array with closest instances of target object
	virtual int16 object(
	    GameWorld *world,
	    const TilePoint &tp,
	    TargetObjectArray &toa) const;
};

/* ===================================================================== *
   SpecificObjectTarget class
 * ===================================================================== */

class SpecificObjectTarget : public ObjectTarget {
	ObjectID    _obj;

public:
	//  Constructors -- initial construction
	SpecificObjectTarget(ObjectID id) :
		_obj(id) {
		assert(isObject(_obj));
	}
	SpecificObjectTarget(GameObject *ptr) : _obj((assert(isObject(ptr)), ptr->thisID())) {}

	SpecificObjectTarget(Common::SeekableReadStream *stream);

	//  Return the number of bytes needed to archive this object in
	//  a buffer
	int32 archiveSize() const;

	void write(Common::MemoryWriteStreamDynamic *out) const;

	//  Return an integer representing the type of target
	int16 getType() const;

	//  Virtual function returning the sizeof this target
	size_t size() const;

	//  Create a copy of this target at the specified address
	void clone(void *mem) const;

	//  Determine if the specified target is equivalent to this target
	bool operator == (const Target &t) const;

	bool isTarget(GameObject *testObj) const;

	TilePoint where(GameWorld *world, const TilePoint &tp) const;
	int16 where(
	    GameWorld *world,
	    const TilePoint &tp,
	    TargetLocationArray &tla) const;

	GameObject *object(GameWorld *world, const TilePoint &tp) const;
	int16 object(
	    GameWorld *world,
	    const TilePoint &tp,
	    TargetObjectArray &toa) const;

	//  Return a pointer to the target object, unconditionally
	GameObject *getTargetObject() const {
		return GameObject::objectAddress(_obj);
	}
};

/* ===================================================================== *
   ObjectPropertTarget class
 * ===================================================================== */

class ObjectPropertyTarget : public ObjectTarget {
	ObjectPropertyID    _objProp;

public:
	//  Constructor -- initial construction
	ObjectPropertyTarget(ObjectPropertyID prop) : _objProp(prop) {}

	ObjectPropertyTarget(Common::SeekableReadStream *stream);

	//  Return the number of bytes needed to archive this object in
	//  a buffer
	int32 archiveSize() const;

	void write(Common::MemoryWriteStreamDynamic *out) const;

	//  Return an integer representing the type of target
	int16 getType() const;

	//  Virtual function returning the sizeof this target
	size_t size() const;

	//  Create a copy of this target at the specified address
	void clone(void *mem) const;

	//  Determine if the specified target is equivalent to this target
	bool operator == (const Target &t) const;

	bool isTarget(GameObject *testObj) const;
};

/* ===================================================================== *
   ActorTarget class
 * ===================================================================== */

class ActorTarget : public ObjectTarget {

public:
	bool isActorTarget() const;

	bool isTarget(GameObject *testObj) const;
	virtual bool isTarget(Actor *testActor) const = 0;

	virtual Actor *actor(GameWorld *world, const TilePoint &tp) const;
	virtual int16 actor(
	    GameWorld *world,
	    const TilePoint &tp,
	    TargetActorArray &taa) const;
};

/* ===================================================================== *
   SpecificActorTarget class
 * ===================================================================== */

class SpecificActorTarget : public ActorTarget {
	Actor   *_a;

public:
	//  Constructor -- initial construction
	SpecificActorTarget(Actor *actor_) : _a(actor_) {}

	SpecificActorTarget(Common::SeekableReadStream *stream);

	//  Return the number of bytes needed to archive this object in
	//  a buffer
	int32 archiveSize() const;

	void write(Common::MemoryWriteStreamDynamic *out) const;

	//  Return an integer representing the type of target
	int16 getType() const;

	//  Virtual function returning the sizeof this target
	size_t size() const;

	//  Create a copy of this target at the specified address
	void clone(void *mem) const;

	//  Determine if the specified target is equivalent to this target
	bool operator == (const Target &t) const;

	bool isTarget(Actor *testActor) const;

	TilePoint where(GameWorld *world, const TilePoint &tp) const;
	int16 where(
	    GameWorld *world,
	    const TilePoint &tp,
	    TargetLocationArray &tla) const;

	GameObject *object(GameWorld *world, const TilePoint &tp) const;
	int16 object(
	    GameWorld *world,
	    const TilePoint &tp,
	    TargetObjectArray &toa) const;

	Actor *actor(GameWorld *world, const TilePoint &tp) const;
	int16 actor(
	    GameWorld *world,
	    const TilePoint &tp,
	    TargetActorArray &taa) const;

	//  Return a pointer to the target actor, unconditionally
	Actor *getTargetActor() const {
		return _a;
	}
};

/* ===================================================================== *
   ActorPropertyTarget class
 * ===================================================================== */

class ActorPropertyTarget : public ActorTarget {
	ActorPropertyID     _actorProp;

public:
	//  Constructor -- initial construction
	ActorPropertyTarget(ActorPropertyID aProp) : _actorProp(aProp) {}

	ActorPropertyTarget(Common::SeekableReadStream *stream);

	//  Return the number of bytes needed to archive this object in
	//  a buffer
	int32 archiveSize() const;

	void write(Common::MemoryWriteStreamDynamic *out) const;

	//  Return an integer representing the type of target
	int16 getType() const;

	//  Virtual function returning the sizeof this target
	size_t size() const;

	//  Create a copy of this target at the specified address
	void clone(void *mem) const;

	//  Determine if the specified target is equivalent to this target
	bool operator == (const Target &t) const;

	bool isTarget(Actor *testActor) const;
};

/* ===================================================================== *
   Constants
 * ===================================================================== */

//	This const and typedef are used to define an area of memory large enough
//	to contain any target.  The sizeof( LocationTarget ) is used because
//	the LocationTarget takes the most memory.

const size_t    kTargetBytes = sizeof(LocationTarget);

typedef uint8 TargetPlaceHolder[kTargetBytes];

} // end of namespace Saga2

#endif