# -*- encoding: iso-8859-1 -*-

"""Veränderung der Lemmata
"""

import re, copy, sys


class LemmaModifyer:
	"""korrigiert schematisierte Muster innerhalb der Lemmata, die nicht 
	erwünscht sind unter Beibehaltung des originalen Lemmas.
	"""


	def __init__(self, p):
		"""bekommt ein Objekt der Klasse Entry02. Ruft folgende Module auf: 
		_treatBracket(), _treatLetter9Letter(), _treatNonAlphas(), _treatSonderZ()
		"""
		self.p = p
		self._treatBracket()
		self._treatLetter9Letter()
		self._treatNonAlphas()
		self._treatSonderZ()

		
		
	def _treatBracket(self):
		"""ruft für Wl1 und Wl2 die Funktion _rmBracket auf. 
		Den Returnwert übergibt sie an p.setWl1 bzw. p.setWl2.
		"""
		self.p.setWl1(self._rmBracket(self.p.getWl1()))
		self.p.setWl2(self._rmBracket(self.p.getWl2()))
		
	
	def _rmBracket(self, wlList):
		"""überprüft, ob dem WL1 eine eingeklammerte Informationseinheit wie:
		(POP), (SUB), (AKK), (ADV), (UKO), (NKO), (DAT), (REL), (PRP), (VZS), 
		(VRB), (MASK), (POSS), (ADJ), (ABK.), (ARTB), (ARTU), (SUBSTANTIV) folgt, z.B.
		"AB (PRP)". In einer zusätzlichen Variante wird das Lemma ohne Klammerung 
		angehängt, z.B. [AB (PRP), AB ]
		"""	
		newList = wlList[:]
		tmp = "(\(POP\)|\(SUB\)|\(AKK\)|\(ADV\)|\(UKO\)|\(NKO\)|\(DAT\)|\(REL\)|\(PRP\)|\(VZS\)" 
		tmp = tmp + "|\(VRB\)|\(MASK\)|\(POSS\)|\(ADJ\)|\(ABK.\)|\(ARTB\)|\(ARTU\)|\(SUBSTANTIV\))" 
		for lem in wlList:
			if re.search(tmp, lem):
				f = open("../../res/teilergebnisse/02rmBracket.txt", "a")
				newList.append(re.sub(tmp, "", lem))
				f.write("ID: " + self.p.getIdent() + "\t " + wlList[0] +
					"\t -> \t" + re.sub(tmp, "", lem) + "\n")			
		return newList

		
	def _treatLetter9Letter(self):
		"""ruft für Wl1 und Wl2 die Funktion _rmLetter9Letter auf. 
		Den Returnwert übergibt sie an p.setWl1 bzw. p.setWl2.
		"""	
		self.p.setWl1(self._rmLetter9Letter(self.p.getWl1()))
		self.p.setWl2(self._rmLetter9Letter(self.p.getWl2()))	
			
		
	def _rmLetter9Letter(self, wlList):
		"""überprüft, ob das Lemma folgende Charakterfolge aufweist: Buchstabe b + 9 + 
		Buchstabe b, z.B. SCHIF9FAHRT. Ersetzt die 9 durch den
		Buchstaben b, z.B.SCHIF9FAHRT->SCHIFFFAHRT, WOL9LAPPEN->WOLLLAPPEN.
		Die neue Variante wird an das Lemma angehängt. 
		"""
		newList = wlList[:]
		for lem in wlList:
			for letter in lem:
				if letter =="9":
					i = lem.index("9")
					if i-1>=0 and i+1<len(lem):
						if cmp(lem[i-1],lem[i+1]) == 0:	
							f = open("../../res/teilergebnisse/02rmLetter9Letter.txt", "a")
 							lem = re.sub("9", lem[i-1], lem)
							f.write("ID: " + self.p.getIdent() + "\t " + wlList[0] +
								"\t -> \t" + re.sub("9", lem[i-1], lem) + "\n")
							newList.append(lem)		
		return newList							
		
		
	def _treatNonAlphas(self):
		"""ruft für Wl1 und Wl2 die Funktion _rmNonAlphas auf. 
		Den Returnwert übergibt sie an p.setWl1 bzw. p.setWl2.
		"""	
		self.p.setWl1(self._rmNonAlphas(self.p.getWl1()))
		self.p.setWl2(self._rmNonAlphas(self.p.getWl2()))			


	def _rmNonAlphas(self, wlList):
		"""sucht alle WLs, die: "<", ">", "[", "]", "&" Anführungszeichen
		oder Apostroph enhalten. In einer zusätzlichen Variante wird das 
		Lemma ohne diese Zeichen der Wortlemmaliste angehängt.
		"""
		newList = wlList[:]
		for lem in wlList:
			if re.search("[><\"'&\[\]]+", lem):
				f = open("../../res/teilergebnisse/02rmNonAlphas.txt", "a")
				newList.append(re.sub("[><\"'&\[\]]+","", lem))
				f.write("ID: " + self.p.getIdent() + "\t " + wlList[0] +
					"\t -> \t" + re.sub("[><\"'&\[\]]+","", lem) + "\n")
		return newList	
		
		
	def _treatSonderZ(self):
		"""ruft für Wl1 und Wl2 die Funktion _placeSonderZ auf. 
		Den Returnwert übergibt sie an p.setWl1 bzw. p.setWl2.
		"""	
		self.p.setWl1(self._placeSonderZ(self.p.getWl1()))
		self.p.setWl2(self._placeSonderZ(self.p.getWl2()))			
				

	def _placeSonderZ(self, wlList):
		"""Lemmate bei denen potentiell ein Umlaut oder ß stehen könnte, 
		werden mit Umlautschreibung in einer Liste hinter das Originallemma 
		geschrieben. Das Original bleibt immer an erster Stelle: 
		['AALFAENGE', 'AALFÄNGE']
		Bei mehreren Sonderzeichen wird permutiert: 
		['HUEHNERHOEFE', 'HÜHNERHOEFE', 'HUEHNERHÖFE', 'HÜHNERHÖFE'].
		
		Bildet die Varianten von Lemmata mit Sonderzeichen. 
		"""
		newList = wlList[:]
		for lem in wlList:
			orgSzList = re.findall("AE|OE|UE|SS", lem)
			newSzList = re.findall("AE|OE|UE|SS", lem)
			if orgSzList:
				f = open("../../res/teilergebnisse/02sonderZ.txt", "a")
				szList = []
				self._permut(orgSzList, 0, szList, newSzList)
				for szLem in self._insertSzInList(szList, lem):
					newList.append(szLem)
				f.write("ID: " + self.p.getIdent() + "\t " + " ".join(wlList) + 
					"\t -> \t " + " ".join(newList) + "\n")	
		return newList						
		
				
	def _permut(self, szOrg, pos, szList, szNew):
		"""gibt eine Liste zurück, in der die Sonderzeichen in allen
		Kombinationen aufgeführt sind. Für das Lemma 'HUEHNERHOEFE' wäre das:
		['UE,OE', 'UE,\xd6', '\xdc,OE', '\xdc,\xd6']
		"""
		if pos < len(szOrg) :
			self._permut(szOrg, pos+1, szList, szNew)
			szNew[pos] = self._setSonderZ(szOrg[pos])
			self._permut(szOrg, pos+1, szList, szNew)
			szNew[pos] = szOrg[pos]
		else:
			szList.append(",".join(szNew))
			return szList
			
		
		
	def _insertSzInList(self, szList, lemma):
		"""setzt die Liste der Sonderzeichen wieder in das Lemma ein
		"""
		lemList = []
		aktSz = []
		count = 0
		splitLem = re.split("(AE|OE|UE|SS)", lemma)
		for i in szList:
			aktSz = i.split(",")
			for substr in splitLem:
				if re.match("AE|OE|UE|SS|Ä|Ö|Ü|ß", substr):
					splitLem[count] = aktSz[0]
					aktSz.remove(aktSz[0])
				count +=1
			count = 0
			lemList.append("".join(splitLem).strip())
		return lemList[1:]
	
	
	
	def _setSonderZ(self, stri):
		"""ersetzt die vorliegende Buchstabenfolge in das entsprechende 
		Sonderzeichen """
		if re.search("AE",stri):
			return re.sub("AE", "Ä", stri)
		elif re.search("OE",stri):
			return re.sub("OE", "Ö", stri)
		elif re.search("UE",stri):
			return re.sub("UE", "Ü", stri)
		elif re.search("SS",stri):
			return re.sub("SS", "ß", stri)