import logging
logger = logging.getLogger("RoundupExport")

from config import PRIORITY_MAP, STATUS_MAP, DEFAULT_STATUS, DEFAULT_PRIORITY
from user import MaloneUser
from comment import MaloneIssueComment
from utils import escapeInvalidChars, formatDate

class MaloneIssue(object):
    """
    An issue to be exported to XML for Malone
    """
    def __init__(self, id=None):
        self._subscribers = []
        self._comments = []
        self.description = ""
        self.id = id
        self.superSeder = ""

    def getInitialReporter(self):
        return self._initialReporter

    def setInitialReporter(self, initialReporter):
        if not isinstance(initialReporter, MaloneUser):
            raise TypeError("Initial Reporter must be a MaloneUser")
        self._initialReporter = initialReporter

    initialReporter = property(getInitialReporter, setInitialReporter)

    def getSubscribers(self):
        return self._subscribers

    def addSubscriber(self, subscriber):
        if not isinstance(subscriber,MaloneUser):
            raise TypeError("Initial Reporter must be a MaloneUser")
        self._subscribers.append(subscriber)

    subscribers = property(getSubscribers)

    def getComments(self):
        return self._comments

    def addComment(self, comment):
        if not isinstance(comment,MaloneIssueComment):
            raise TypeError("Comment must be a MaloneIssueComment")
        self._comments.append(comment)

    comments = property(getComments)

    def importRoundupIssue(self, db, roundupIssue):
        if type(roundupIssue) != type({}):
            raise TypeError("A Roundup Issue must be a dictionary")
        #logger.debug('Issue: %s' % roundupIssue)
        self.summary = roundupIssue.get('title')

        self.reportDate= roundupIssue.get('creation')

        roundupPriorityId = roundupIssue.get('priority')
        self.importRoundupPriority(db, roundupPriorityId)

        roundupStatusId = roundupIssue.get('status')
        self.importRoundupStatus(db, roundupStatusId)

        roundupUserId = roundupIssue.get('creator')
        maloneUser = MaloneUser()
        maloneUser.importRoundupUser(db, roundupUserId)
        self.initialReporter = maloneUser

        roundupNosyList = roundupIssue.get('nosy')
        for roundupUserId in roundupNosyList:
            maloneSubscriber = MaloneUser()
            maloneSubscriber.importRoundupUser(db, roundupUserId)
            self.addSubscriber(maloneSubscriber)

        roundupMessageIds = roundupIssue.get('messages')
        if roundupMessageIds:
            self.importRoundupMessages(db, roundupMessageIds)

        roundupIssue.get('topic')
        roundupIssue.get('assignedto')
        roundupIssue.get('activity')
        sSeder = roundupIssue.get('superseder')
        if sSeder:
            self.superSeder = sSeder[0]
        roundupIssue.get('files')

    def importRoundupMessages(self, db, roundupMessageIds):
        """
        import and transform Roundup message to 
           * first roundup message is set as the description of the Malone bug
           * next messages if any are set as comments
        """
        #roundupMessageId = roundupMessageIds.pop(0)
        roundupMessageId = roundupMessageIds[0]
        roundupDescription = db.getnode('msg', roundupMessageId)
        self.description = db.msg.get(roundupMessageId, 'content')
        #print str(self.description)

        for roundupCommentId in roundupMessageIds:
            comment = MaloneIssueComment()
            comment.importRoundupComment(db, roundupCommentId)
            self.addComment(comment)

    def importRoundupPriority(self, db, roundupPriorityId):
        """
        import and transform a Roundup priority to a Malone importance
        """
        if roundupPriorityId is None:
            self.importance = DEFAULT_STATUS
            return
        roundupPriority = db.getnode('priority', roundupPriorityId)
        roundupPriorityName = roundupPriority.get('name')
        mappedPriority = PRIORITY_MAP.get(roundupPriorityName)
        if mappedPriority is None:
            logging.warning("Mapping of priority for %s not found" % roundupPriorityName)
            mappedPriority = DEFAULT_PRIORITY
        self.importance = mappedPriority

    def importRoundupStatus(self, db, roundupStatusId):
        """
        import and transform a Roundup status to a Malone status
        """
        if db.hasnode('status', roundupStatusId):
            roundupStatus = db.getnode('status', roundupStatusId)
            roundupStatusName = roundupStatus.get('name')
        else:
            roundupStatusName = 'bug'
        mappedStatus = STATUS_MAP.get(roundupStatusName)
        if mappedStatus is None:
            logging.warning("Mapping of status for %s not found" % roundupStatusName)
            mappedStatus = DEFAULT_STATUS
        self.status = mappedStatus


    def toXML(self, doc, xmlBug):
        # NICKNAME (optional)
        nicknameEl = doc.createElement("nickname")
        xmlBug.appendChild(nicknameEl)
        nickname = doc.createTextNode("schooltool%s" % self.id)
        nicknameEl.appendChild(nickname)

        # CREATED
        datecreatedEl = doc.createElement("datecreated")
        xmlBug.appendChild(datecreatedEl)
        formatedDate = formatDate(self.reportDate)
        date = doc.createTextNode(formatedDate)
        datecreatedEl.appendChild(date)

        # TITLE
        titleEl = doc.createElement("title")
        xmlBug.appendChild(titleEl)
        title = doc.createTextNode(self.summary)
        titleEl.appendChild(title)

        # DESCRIPTION
        descriptionEl = doc.createElement("description")
        xmlBug.appendChild(descriptionEl)
        # escape bad char in db
        description = escapeInvalidChars(self.description)
        if description == "":
            description = "None"
        description = doc.createTextNode(description)
        descriptionEl.appendChild(description)

        # REPORTER
        reporterEl = doc.createElement("reporter")
        username = self.initialReporter.username.lower()
        username = username.replace("_","")
        reporterEl.setAttribute('name', username)
        reporterEl.setAttribute('email', self.initialReporter.email)
        xmlBug.appendChild(reporterEl)
        reporter = doc.createTextNode(self.initialReporter.name)
        reporterEl.appendChild(reporter)

        # SUPERSEDER
        if self.superSeder:
            duplicateOfEl = doc.createElement("duplicateof")
            xmlBug.appendChild(duplicateOfEl)
            duplicateOf = doc.createTextNode(self.superSeder)
            duplicateOfEl.appendChild(duplicateOf)

        # STATUS
        statusEl = doc.createElement("status")
        xmlBug.appendChild(statusEl)
        status = doc.createTextNode(self.status)
        statusEl.appendChild(status)

        # IMPORTANCE
        importanceEl = doc.createElement("importance")
        xmlBug.appendChild(importanceEl)
        importance = doc.createTextNode(self.importance)
        importanceEl.appendChild(importance)

        # SUBSCRIBER
        subscribersEl = doc.createElement("subscriptions")
        xmlBug.appendChild(subscribersEl)
        for subscriber in self.subscribers:
            subscriberEl = doc.createElement("subscriber")
            username = subscriber.username.lower()
            username = username.replace("_","")
            subscriberEl.setAttribute('name', username)
            subscriberEl.setAttribute('email', subscriber.email)
            subscribersEl.appendChild(subscriberEl)
            subscriberName = doc.createTextNode(subscriber.name)
            subscriberEl.appendChild(subscriberName)

        # COMMENT
        if self.comments == []:
            logger.debug("No comment in issue! This shouldn't happen ! Adding an empty one...")
            comment = MaloneIssueComment()
            comment.subject = self.summary
            comment.date = self.reportDate
            comment.commentBody = "None"
            comment.sender = self.initialReporter
            self.addComment(comment)

        for comment in self.comments:
            comment.toXML(doc, xmlBug)