from common import *

TILE_SIZE = (24,24)
MAP_SIZE_IN_TILES = (512,512)
MAP_SIZE = (MAP_SIZE_IN_TILES[0] * TILE_SIZE[0], MAP_SIZE_IN_TILES[1] * TILE_SIZE[1])

class KPLayer(object):
	def __repr__(self):
		return "<KPLayer %r>" % self.name

	def __init__(self):
		self.name = ''
		self._visible = True
	
	@property
	def visible(self):
		return self._visible

	@visible.setter
	def visible(self, value):
		if self._visible == value:
			return
		self._visible = value

		self._visibilityChanged(value)
	
	def _visibilityChanged(self, value):
		pass


class KPObject(object):
	def __init__(self):
		self.position = (0,0)
		self.size = (1,1)
		self.kind = 0
		self.cache = []
		self.tileset = None
		self.qtItem = None
	
	def updateCache(self):
		self.cache = self.kind.render(self.size)


class KPTileLayer(KPLayer):
	def __repr__(self):
		return "<KPTileLayer %r with %r>" % (self.name, self.tileset)

	def __init__(self):
		KPLayer.__init__(self)
		self.tileset = ''
		self.objects = []
		self.cache = ['DUMMY_FLAG']
		self.updateCache()
	
	def _visibilityChanged(self, value):
		for obj in self.objects:
			item = obj.qtItem
			if item:
				item.setVisible(value)
	
	def updateCache(self):
		if len(self.objects) == 0:
			if len(self.cache) != 0:
				self.cache = []
				self.cacheBasePos = (0,0)
				self.cacheSize = (0,0)
			return

		x1, x2 = MAP_SIZE_IN_TILES[0] - 1, 0
		y1, y2 = MAP_SIZE_IN_TILES[1] - 1, 0

		for obj in self.objects:
			x, y = obj.position
			w, h = obj.size
			right, bottom = (x+w-1), (y+h-1)

			if x < x1:
				x1 = x
			if y < y1:
				y1 = y
			if right > x2:
				x2 = right
			if bottom > y2:
				y2 = bottom


		# create the cache
		# I was going to just resize it, but setting every tile to -1
		# in Python would probably be slower than creating a new one ...
		size = (x2 - x1 + 1, y2 - y1 + 1)
		width, height = size

		cache = [[-1 for i in xrange(width)] for j in xrange(height)]
		self.cache = cache

		self.cacheBasePos = (x1, y1)
		self.cacheSize = size

		# now generate the thing
		for obj in self.objects:
			oX, oY = obj.position
			baseX = oX - x1
			y = oY - y1

			for row in obj.cache:
				destRow = cache[y]
				x = baseX
				for tile in row:
					destRow[x] = tile
					x += 1
				y += 1


class KPDoodad(object):
	def __init__(self):
		self.position = (0,0)
		self.size = (0,0)
		self.angle = 0
		self.index = 0
	
	def setDefaultSize(self):
		source = KP.mainWindow.doodadSelector.getDoodad(self.index)
		pixmap = source.icon().pixmap(source.icon().availableSizes()[0])
		self.size = pixmap.width(), pixmap.height()



class KPDoodadLayer(KPLayer):
	def __repr__(self):
		return "<KPDoodadLayer %r>" % self.name

	def __init__(self):
		KPLayer.__init__(self)
		self.objects = []
	
	def _visibilityChanged(self, value):
		for obj in self.objects:
			item = obj.qtItem
			if item:
				item.setVisible(value)



class KPNodeAction(object):
	def __init__(self):
		pass


class KPNode(object):
	def __init__(self):
		self.position = (0,0)
		self.actions = []


class KPPathSegment(object):
	def __init__(self):
		self.start = None
		self.end = None
		self.animation = None # default


class KPPath(object):
	def __init__(self):
		self.startNode = None
		self.endNode = None
		self.segments = []


class KPPathLayer(KPLayer):
	def __repr__(self):
		return "<KPPathLayer %r>" % self.name

	def __init__(self):
		KPLayer.__init__(self)
		self.nodes = []
		self.paths = []
	
	def _visibilityChanged(self, value):
		for obj in self.objects:
			item = obj.qtItem
			if item:
				item.setVisible(value)





class KPMap(object):
	def __init__(self):
		self.nextLayerNumber = 1

		self.layers = [self.createNewTileLayer('Test') for x in range(4)]
		self.layerModel = KPMap.LayerModel(self.layers)
		self.nodes = []
		self.paths = []
		self.tilesets = {}
		self.loadedTilesets = {}

		# TESTING CRAP
		import os.path
		if os.path.exists('/Users/Tempus'):
			self.tilesets['Test'] = {'path': '/Users/Tempus/Dropbox/NEWERsmbw/Test3.arc'}
		else:
			self.tilesets['Test'] = {'path': '/home/me/Dropbox/NEWERsmbw/Test3.arc'}
		self.reloadTileset('Test')


	# LAYERS
	class LayerModel(QtCore.QAbstractListModel):
		def __init__(self, layerList):
			QtCore.QAbstractListModel.__init__(self)
			self.list = layerList


		def headerData(self, section, orientation, role = Qt.DisplayRole):
			return 'Layer'

		def rowCount(self, parent):
			return len(self.list)

		def data(self, index, role = Qt.DisplayRole):
			try:
				if index.isValid():
					layer = self.list[index.row()]

					if (role == Qt.DisplayRole or role == Qt.EditRole):
						return layer.name
					elif role == Qt.CheckStateRole:
						return (Qt.Checked if layer.visible else Qt.Unchecked)

			except IndexError:
				pass

			return QtCore.QVariant()

		def flags(self, index):
			if not index.isValid():
				return Qt.ItemIsEnabled
			
			return Qt.ItemIsEditable | Qt.ItemIsUserCheckable \
					| QtCore.QAbstractListModel.flags(self, index)

		def setData(self, index, value, role = Qt.EditRole):
			if index.isValid():
				layer = self.list[index.row()]

				if role == Qt.EditRole:
					value = str(value.toString())
					if len(value) > 0:
						layer.name = value
						self.dataChanged.emit(index, index)
						return True

				elif role == Qt.CheckStateRole:
					layer.visible = value.toBool()
					self.dataChanged.emit(index, index)
					return True

			return False


	def createNewTileLayer(self, tilesetName):
		layer = KPTileLayer()
		layer.name = "Tilemap - Layer %d" % self.nextLayerNumber
		self.nextLayerNumber += 1
		layer.tileset = tilesetName
		return layer

	def createNewDoodadLayer(self):
		layer = KPDoodadLayer()
		layer.name = "Doodads - Layer %d" % self.nextLayerNumber
		self.nextLayerNumber += 1
		return layer

	def appendLayer(self, layer):
		return self.insertLayer(len(self.layers), layer)
	
	def insertLayer(self, index, layer):
		self.layerModel.beginInsertRows(QtCore.QModelIndex(), index, index)
		self.layers.insert(index, layer)
		self.layerModel.endInsertRows()
		return index

	def moveLayer(self, fromIndex, toIndex):
		if fromIndex == toIndex:
			return
		if fromIndex < 0 or toIndex < 0:
			raise ValueError
		if fromIndex >= len(self.layers) or toIndex > len(self.layers):
			raise ValueError

		self.layerModel.beginMoveRows(
				QtCore.QModelIndex(), fromIndex, fromIndex,
				QtCore.QModelIndex(), toIndex)

		toMove = self.layers[fromIndex]
		newIndex = ((toIndex > fromIndex) and (toIndex - 1)) or toIndex

		del self.layers[fromIndex]
		self.layers.insert(newIndex, toMove)

		self.layerModel.endMoveRows()

		return newIndex

	def removeLayer(self, layer):
		if layer not in self.layers:
			raise ValueError

		index = self.layers.index(layer)
		self.layerModel.beginRemoveRows(QtCore.QModelIndex(), index, index)
		del self.layers[index]
		self.layerModel.endRemoveRows()
	

	def reloadTileset(self, name):
		info = self.tilesets[name]
		self.loadedTilesets[name] = KPTileset.loadFromArc(info['path'])
		# TODO: handle relative paths properly in relation to the map file
		# TODO: add some sort of callback/signal to regenerate objects/layers
		# and refresh the view