import sys
import re
import types
import ag
import exceptions

class OrphanAnnotation(exceptions.Exception):
    def __init__(self):
	return
    def __str__(self):
	print "", "An annotation pointing to a non-existent token was detected"


def createAllTokens(agId, textObject):
    id2Token={}
    token2Id={}
    for ann in ag.GetAnnotationSet(agId, "Token"):
	t=Token(agId, annId=ann, textObject=textObject)
	id2Token[ann]=t
	token2Id[t]=ann
    return (id2Token, token2Id)

def createAllParses(agId, id2Token):
    id2Parse={}
    parse2Id={}
    for ann in ag.GetAnnotationSet(agId, "Parse"):
	t=ag.GetFeature(ann,"token")
	try:
	    p=Parse(agId, annId=ann, token=id2Token[t])
	    id2Parse[ann]=p
	    parse2Id[p]=ann
	except OrphanAnnotation:
	    print "An orphan annotation was detected and deleted."
	    p.delete()
    return (id2Parse, parse2Id)

def createAllProblemNotes(agId, id2Token):
    id2Note={}
    note2Id={}
    for ann in ag.GetAnnotationSet(agId, "ProblemNote"):
	t=ag.GetFeature(ann,"token")
	try:
	    p=ProblemNote(agId, annId=ann, token=id2Token[t])
	    id2Note[ann]=p
	    note2Id[p]=ann
	except OrphanAnnotation:
	    p.delete()
    return (id2Note,note2Id)

class Token:
    def __init__(self, AGId=None, annId=None, startOffset=None, endOffset=None, currentParse=None, textObject=None, parsing=True):
        self.parses=[]
        self.problemNotes=[]
        self.tokenBox=None
        self.startOffset=None
        self.endOffset=None
        
	if annId:
	    startOffset=ag.GetStartOffset(annId)
	    endOffset=ag.GetEndOffset(annId)
            if ag.ExistsFeature(annId,"parsing"):
                parsing=(ag.GetFeature(annId,"parsing") == "True")
            self.currentParse=None
	else:
	    startAnchor=ag.CreateAnchor(AGId)
	    endAnchor=ag.CreateAnchor(AGId)
	    annId=ag.CreateAnnotation(AGId,startAnchor,endAnchor,"Token")
            self.annId=annId
            self.setCurrentParse(currentParse)

	self.textObject=textObject
	self.text="What is my text?"

	self.annId=annId
	self.setStartOffset(startOffset)
	self.setEndOffset(endOffset)
        self.setParsing(parsing)
    def isParsing(self):
	return self.getParsing()
    def isAmbiguous(self):
	return len(self.parses) > 1
    def isUnambiguous(self):
	return len(self.parses) == 1 and not self.currentParse
    def isSelected(self):
	return self.currentParse is not None
    def isUnparsed(self):
        return not(self.parses)
    def getParsing(self):
	return self.parsing
    def setParsing(self, b):
	self.parsing=b
        if b:
            ag.SetFeature(self.annId,"parsing","True")
        else:
            ag.SetFeature(self.annId,"parsing","False")
	if self.tokenBox: self.tokenBox.refreshDisplay()
    def getTokenBox(self):
	return self.tokenBox
    def setTokenBox(self, b):
	self.tokenBox=b
    def getText(self):
	return self.text
    def setText(self):
	if self.startOffset is not None and self.endOffset is not None and self.textObject:
	    self.text = self.textObject.getText(self.startOffset, self.endOffset)
	else:
	    self.text="<Error getting token text>"
	if self.tokenBox: self.tokenBox.refreshDisplay()
	
    def getParses(self):
	return self.parses
    def addParse(self, p):
	if p not in self.parses:
	    self.parses.append(p)
        if self.tokenBox: self.tokenBox.refreshDisplay()
    def removeParse(self, p):
	self.parses.remove(p)
        if p == self.currentParse:
            self.setCurrentParse(None)
	if self.tokenBox: self.tokenBox.refreshDisplay()
    def getProblemNotes(self):
	return self.problemNotes
    def addProblemNote(self, p):
	if p not in self.problemNotes:
	    self.problemNotes.append(p)
    def removeProblemNote(self, p):
	self.problemNotes.remove(p)
    def getStartOffset(self):
	return self.startOffset
    def setStartOffset(self, s):
	self.startOffset=int(s)
	ag.SetStartOffset(self.annId,int(s))
	self.setText()
    def getEndOffset(self):
	return self.endOffset
    def setEndOffset(self, e):
	self.endOffset=int(e)
	ag.SetEndOffset(self.annId,int(e))
	self.setText()
    def shift(self, delta=0):
	s=self.getStartOffset()
	e=self.getEndOffset()
	self.setStartOffset(s+delta)
	self.setEndOffset(e+delta)
    def loadCurrentParse(self):
        if ag.ExistsFeature(self.annId,"SelectedParse"):
            p=ag.GetFeature(self.annId,"SelectedParse")
            if p:
                myparses=[x for x in self.parses if x.annId==p]
                if myparses:
                    self.setCurrentParse(myparses[0])
    def getCurrentParse(self):
	return self.currentParse
    def setCurrentParse(self, p):
        if not(p): p=None
	self.currentParse=p
	if p and p in self.parses:
            ag.SetFeature(self.annId,"SelectedParse",str(p.annId))
	else:
	    ag.SetFeature(self.annId,"SelectedParse","")
	if self.tokenBox: self.tokenBox.refreshDisplay()
    def deleteParses(self):
	for p in [x for x in self.parses]:
	    p.delete()
    def clear(self):
        self.setStartOffset(None)
	self.setEndOffset(None)
	self.setCurrentParse(None)
	for p in self.parses:
	    p.clear()
    def delete(self):
	start=ag.GetStartAnchor(self.annId)
	end=ag.GetEndAnchor(self.annId)
	ag.DeleteAnnotation(self.annId)
	ag.DeleteAnchor(start)
	ag.DeleteAnchor(end)
	for p in [x for x in self.parses]:
	    p.delete()
	for p in [x for x in self.problemNotes]:
	    p.delete()

class Parse:
    def __init__(self, AGId=None, annId=None, gloss=None, underlyingForm=None, isManual=0, token=None):
	if annId:
	    gloss=ag.GetFeature(annId,"Gloss")
	    underlyingForm=ag.GetFeature(annId,"UnderlyingRepresentation")
	    isManual=(ag.GetFeature(annId,"IsManualParse")=="YES")
	else:
	    startAnchor=ag.CreateAnchor(AGId)
	    endAnchor=ag.CreateAnchor(AGId)
	    annId=ag.CreateAnnotation(AGId,startAnchor,endAnchor,"Parse")

	self.annId=annId
	self.setGloss(gloss)
	self.setUnderlyingForm(underlyingForm)
	self.setIsManual(isManual)
	self.token=None
	if token:
	    self.setToken(token)
    def getGloss(self):
	return self.gloss
    def setGloss(self, g):
	self.gloss=g
	if g:
	    ag.SetFeature(self.annId,"Gloss",str(g))
	else:
	    ag.SetFeature(self.annId,"Gloss","")
    def getUnderlyingForm(self):
	return self.underlyingForm
    def setUnderlyingForm(self, u):
        self.underlyingForm=u
	if u:
	    ag.SetFeature(self.annId,"UnderlyingRepresentation",str(u))
	else:
	    ag.SetFeature(self.annId,"UnderlyingRepresentation","")
    def getIsManual(self):
	return self.isManual
    def setIsManual(self, m):
	self.isManual=m
	if m:
	    ag.SetFeature(self.annId,"IsManualParse","YES")
	else:
	    ag.SetFeature(self.annId,"IsManualParse","NO")
    def getToken(self):
	return self.token
    def setToken(self, t):
	if self.token:
	    self.token.removeParse(self)
	self.token=t
	if t:
	    t.addParse(self)
	    ag.SetFeature(self.annId,"token",t.annId)
	else:
	    ag.SetFeature(self.annId,"token","")
    def clear(self):
	self.setToken(None)
	self.setIsManual(False)
	self.setGloss(None)
	self.setUnderlyingForm(None)
    def delete(self):
	self.token.removeParse(self)
	start=ag.GetStartAnchor(self.annId)
	end=ag.GetEndAnchor(self.annId)
	ag.DeleteAnnotation(self.annId)
	ag.DeleteAnchor(start)
	ag.DeleteAnchor(end)


class ProblemNote:
    def __init__(self, AGId=None, annId=None, token=None, text=None, pType=None):
	if annId:
	    text=ag.GetFeature(annId,"text")
	    pType=ag.GetFeature(annId,"type")
	    token=ag.GetFeature(annId,"token")
	else:
	    startAnchor=ag.CreateAnchor(AGId)
	    endAnchor=ag.CreateAnchor(AGId)
	    annId=ag.CreateAnnotation(AGId,startAnchor,endAnchor,"ProblemNote")

	self.annId=annId
        self.token=None
	self.setToken(token)
      	self.setText(text)
      	self.setType(pType)
    def getToken(self):
	return self.token
    def setToken(self, t):
	if self.token:
	    self.token.removeProblemNote(self)
	self.token=t
	if t:
	    t.addProblemNote(self)
	    ag.SetFeature(self.annId,"token",t.annId)
	else:
	    ag.SetFeature(self.annId,"token","")
    def getText(self):
	return self.text
    def setText(self, t):
	"""Need to add some escaping here!"""
	self.text=t
	if t:
	    ag.SetFeature(self.annId,"text",t)
	else:
	    ag.SetFeature(self.annId,"text","")
    def getType(self):
        return self.type
    def setType(self, t):
        self.type=t
        if t:
            ag.SetFeature(self.annId,"type",t)
        else:
            ag.SetFeature(self.annId,"type","")
    def clear(self):
	self.setToken(None)
	self.setText(None)
	self.setType(None)
    def delete(self):
        if self.token:
            self.token.removeProblemNote(self)
	start=ag.GetStartAnchor(self.annId)
	end=ag.GetEndAnchor(self.annId)
	ag.DeleteAnnotation(self.annId)
	ag.DeleteAnchor(start)
	ag.DeleteAnchor(end)