import os, os.path, stat




class PathSet(object) :
	"""Represents an ordered set of unique normalized file paths.
		The paths may be the subject to user (~) and variable ($) expansion.
		This class fulfills the sequence contract (i.e. len(), x[], iterating etc.).
	"""

	def __init__ (self, *args, **kwds) :
		"""Construct a set. Any number of either string-like objects or the sequences of
			thereof is accepted.

			The following keywords are recognized:
				userExpand	-- (default True)
				varExpand	-- (default True)
		"""
		self.paths = []
		try :
			self.varExpand = kwds["varExpand"]
		except KeyError :
			self.varExpand = True
		try :
			self.userExpand = kwds["userExpand"]
		except KeyError :
			self.userExpand = True
		for x in args :
			self.append(x)

	def __iter__(self) :
		return self.paths.__iter__()

	def __len__(self) :
		return len(self.paths)

	def __str__(self) :
		paths = self.paths
		if len(paths) > 1 :
			s = str(paths[0])
			for x in paths[1:] :
				s += ":" + str(x)
		elif len(paths) > 0 :
			s = str(paths[0])
		else :
			s = ""
		return s

	def __contains__ (self, path) :
		return self.adopt(path) in self.paths

	def __getitem__(self, index) :
		return self.paths[index]

	def __add__(self, other) :
		x = self.__class__()
		x.append(self)
		x.append(other)
		return x

	def __iadd__(self, other) :
		self.append(other)
		return self

	def adopt(self, path) :
		"""Validates the specified path and converts it to a form suitable for inclusion
			into the set. Must either return the path or raise ValueError if an inappropriate
			path was given.
		"""
		if self.userExpand and path.startswith("~") :
			path = os.path.expanduser(path)
		if self.varExpand and "$" in path :
			path = os.path.expandvars(path)
		path = os.path.normpath(path)
		if path in self.paths :
			raise ValueError
		else :
			return path

	def append(self, arg) :
		if isinstance(arg, str) :
			try :
				self.paths.append(self.adopt(arg))
			except ValueError :
				pass
		else :
			for x in arg :
				self.append(str(x)) # WARNING : a recursive call, stay alert




class ValidPathSet(PathSet) :
	"""Represents the PathSet of the valid paths. The symbolic links are respected
		and have the preference over the real directories they point to.
	"""

	def adopt(self, path) :
		path = super(ValidPathSet, self).adopt(path)
		try :
			st = os.stat(path)
			for xst in self.stats :
				if os.path.samestat(st, xst) :
					if os.path.islink(path) and not os.path.islink(self.stats[xst]) : # FIXME : inefficiency
						# In case of real path followed by the symlink to it
						# the latter has the preference
						self.paths[self.paths.index(self.stats[xst])] = path
						del self.stats[xst]; self.stats[st] = path
					# In all other cases the path is discarded
					raise ValueError # To prevent the appending of the path
			self.stats[st] = path
			return path
		except OSError :
			raise ValueError

	def __init__(self, *args, **kwds) :
		self.stats = {}
		super(ValidPathSet, self).__init__(*args, **kwds)