/* 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/>.
 *
 */

#ifndef NUVIE_CORE_MAP_H
#define NUVIE_CORE_MAP_H

#include "ultima/shared/std/string.h"
#include "ultima/nuvie/core/obj_manager.h"

namespace Ultima {
namespace Nuvie {

class Configuration;
class U6LList;
class Actor;
class ActorManager;
class MapCoord;
class TileManager;
class Screen;

#define MAP_ORIGINAL_TILE true

enum LineTestFlags {
	LT_HitActors            = (1 << 0),
	LT_HitUnpassable        = (1 << 1),
	LT_HitForcedPassable        = (1 << 2),
	LT_HitLocation          = (1 << 3), /* hit location in Result */
	LT_HitObjects           = (1 << 4), /* hit any object */
	LT_HitMissileBoundary           = (1 << 5)
};

class LineTestResult {
public:
	LineTestResult() { // clears properties not set by init() (SB-X)
		hit_x = 0;
		hit_y = 0;
		hit_level = 0;
		hitActor = nullptr;
		hitObj = nullptr;
		hitLoc = nullptr;
		loc_to_hit = nullptr;
	}
	void    init(int x, int y, uint8 level, Actor *actorHit, Obj *objHit) {
		hit_x = x;
		hit_y = y;
		hit_level = level;
		hitActor = actorHit;
		hitObj = objHit;
	}

	int     hit_x;      // x coord where object / actor was hit
	int     hit_y;      // y coord where object / actor was hit
	int     pre_hit_x;
	int     pre_hit_y;
	uint8   hit_level;  // map level where object / actor was hit
	Actor  *hitActor;
	Obj    *hitObj;
	MapCoord   *hitLoc;
	MapCoord   *loc_to_hit; // set hitLoc if hit x,y (z changes)
};

//typedef   (*LineTestFilter)(int x, int y, int level, LineTestResult &Result);

/* Map Location with 2D X,Y coordinates and plane (map number)
 */
class MapCoord {
public:
	union {
		uint16 x;
		sint16 sx;
	};
	union {
		uint16 y;
		sint16 sy;
	};
	uint8 z; // plane

	MapCoord(uint16 nx, uint16 ny, uint16 nz = 0) {
		x = nx;
		y = ny;
		z = nz;
	}
	MapCoord(Obj *obj) {
		x = obj->x;
		y = obj->y;
		z = obj->z;
	}
	MapCoord() : x(0), y(0), z(0) { }

	uint32 xdistance(const MapCoord &c2) const {
		uint32 dist = abs(c2.x - x);
		if (dist > 512)
			dist = 1024 - dist;

		return dist;
	}
	uint32 ydistance(const MapCoord &c2) const {
		return abs(c2.y - y);
	}
	// greatest 2D distance X or Y (estimate of shortest)
	uint32 distance(const MapCoord &c2) const {
		uint16 dx = xdistance(c2), dy = ydistance(c2);
		return (dx >= dy ? dx : dy);
	}
	// get absolute coordinates for relative destination (dx,dy)
	MapCoord abs_coords(sint16 dx, sint16 dy) const;
	// location is on screen?
	bool is_visible() const;
	void print_d(DebugLevelType level) const {
		DEBUG(1, level, "%d, %d, %d", x, y, z);
	}
	void print_h(DebugLevelType level) const {
		DEBUG(1, level, "%x, %x, %x", x, y, z);
	}
	void print_s(DebugLevelType level) const {
		DEBUG(1, level, "%d, %d", sx, sy);
	}

	bool operator==(const MapCoord &c2) const {
		return (x == c2.x && y == c2.y && z == c2.z);
	}
	bool operator!=(const MapCoord &c2) const {
		return (!(*this == c2));
	}
//    MapCoord operator+(MapCoord &c2) { return(abs_coords(c2)); }
};


class Map {
	const Configuration *config;
	TileManager *tile_manager;
	ObjManager *obj_manager;
	ActorManager *actor_manager;

	uint8 *surface;
	uint8 *dungeons[5];

	bool roof_mode;
	uint16 *roof_surface;

public:

	Map(const Configuration *cfg);
	~Map();

	void set_actor_manager(ActorManager *am) {
		actor_manager = am;
	}
	Actor *get_actor(uint16 x, uint16 y, uint8 z, bool inc_surrounding_objs = true);

	bool loadMap(TileManager *tm, ObjManager *om);
	byte *get_map_data(uint8 level);
	uint16 *get_roof_data(uint8 level);
	const Tile *get_tile(uint16 x, uint16 y, uint8 level, bool original_tile = false);
	uint16 get_width(uint8 level) const;
	bool is_passable(uint16 x, uint16 y, uint8 level);
	bool is_water(uint16 x, uint16 y, uint16 level, bool ignore_objects = false);
	bool is_boundary(uint16 x, uint16 y, uint8 level);
	bool is_missile_boundary(uint16 x, uint16 y, uint8 level, Obj *excluded_obj = nullptr);
	bool is_damaging(uint16 x, uint16 y, uint8 level, bool ignore_objects = false);
	bool can_put_obj(uint16 x, uint16 y, uint8 level);
	bool actor_at_location(uint16 x, uint16 y, uint8 level, bool inc_surrounding_objs = true);
	uint8 get_impedance(uint16 x, uint16 y, uint8 level, bool ignore_objects = false);
	const Tile *get_dmg_tile(uint16 x, uint16 y, uint8 level);
	bool is_passable(uint16 x, uint16 y, uint8 level, NuvieDir dir);
	bool is_passable(uint16 x1, uint16 y1, uint16 x2, uint16 y2, uint8 level);
	bool is_passable_from_dir(uint16 x, uint16 y, uint8 level, NuvieDir dir);
	bool has_roof(uint16 x, uint16 y, uint8 level) const;
	void set_roof_mode(bool roofs);

	const char *look(uint16 x, uint16 y, uint8 level);

	bool lineTest(int start_x, int start_y, int end_x, int end_y, uint8 level,
	              uint8 flags, LineTestResult &Result, uint32 skip = 0, Obj *excluded_obj = nullptr, bool want_screen_space = false); // excluded_obj only works for LT_HitUnpassable

	bool testIntersection(int x, int y, uint8 level, uint8 flags, LineTestResult &Result, Obj *excluded_obj = nullptr); // excluded_obj only works for LT_HitUnpassable

	void saveRoofData();
	Common::Path getRoofTilesetFilename() const;

protected:
	Common::Path getRoofDataFilename() const;
	void insertSurfaceSuperChunk(const unsigned char *schunk_ptr, const unsigned char *chunk_data, uint8 schunk_num);
	void insertSurfaceChunk(const unsigned char *chunk, uint16 x, uint16 y);

	void insertDungeonSuperChunk(const unsigned char *schunk_ptr, const unsigned char *chunk_data, uint8 level);
	void insertDungeonChunk(const unsigned char *chunk, uint16 x, uint16 y, uint8 level);


	void loadRoofData();

};

} // End of namespace Nuvie
} // End of namespace Ultima

#endif