from ..namespaces import NS_WSA, NS_WSD
from ..envelope import SoapEnvelope
from ..util import createSkelSoapMessage, getBodyEl, getHeaderEl, addElementWithText, \
                   addTypes, addScopes, getDocAsString, getScopes, _parseAppSequence, \
                   addEPR, getXAddrs, addXAddrs, getTypes


ACTION_PROBE_MATCH = "http://schemas.xmlsoap.org/ws/2005/04/discovery/ProbeMatches"


def createProbeMatchMessage(env):
    doc = createSkelSoapMessage(ACTION_PROBE_MATCH)

    bodyEl = getBodyEl(doc)
    headerEl = getHeaderEl(doc)

    addElementWithText(doc, headerEl, "wsa:MessageID", NS_WSA, env.getMessageId())
    addElementWithText(doc, headerEl, "wsa:RelatesTo", NS_WSA, env.getRelatesTo())
    addElementWithText(doc, headerEl, "wsa:To", NS_WSA, env.getTo())

    appSeqEl = doc.createElementNS(NS_WSD, "wsd:AppSequence")
    appSeqEl.setAttribute("InstanceId", env.getInstanceId())
    appSeqEl.setAttribute("MessageNumber", env.getMessageNumber())
    headerEl.appendChild(appSeqEl)

    probeMatchesEl = doc.createElementNS(NS_WSD, "wsd:ProbeMatches")
    probeMatches = env.getProbeResolveMatches()
    for probeMatch in probeMatches:
        probeMatchEl = doc.createElementNS(NS_WSD, "wsd:ProbeMatch")
        addEPR(doc, probeMatchEl, probeMatch.getEPR())
        addTypes(doc, probeMatchEl, probeMatch.getTypes())
        addScopes(doc, probeMatchEl, probeMatch.getScopes())
        addXAddrs(doc, probeMatchEl, probeMatch.getXAddrs())
        addElementWithText(doc, probeMatchEl, "wsd:MetadataVersion", NS_WSD, probeMatch.getMetadataVersion())
        probeMatchesEl.appendChild(probeMatchEl)


    bodyEl.appendChild(probeMatchesEl)

    return getDocAsString(doc)


def parseProbeMatchMessage(dom):
    env = SoapEnvelope()
    env.setAction(ACTION_PROBE_MATCH)

    try:
        env.setMessageId(dom.getElementsByTagNameNS(NS_WSA, "MessageID")[0].firstChild.data.strip())
        env.setRelatesTo(dom.getElementsByTagNameNS(NS_WSA, "RelatesTo")[0].firstChild.data.strip())
        env.setTo(dom.getElementsByTagNameNS(NS_WSA, "To")[0].firstChild.data.strip())

        _parseAppSequence(dom, env)

        pmNodes = dom.getElementsByTagNameNS(NS_WSD, "ProbeMatch")
        for node in pmNodes:
            epr = node.getElementsByTagNameNS(NS_WSA, "Address")[0].firstChild.data.strip()

            types = []
            typeNodes = node.getElementsByTagNameNS(NS_WSD, "Types")
            if len(typeNodes) > 0:
                types = getTypes(typeNodes[0])

            scopes = []
            scopeNodes = node.getElementsByTagNameNS(NS_WSD, "Scopes")
            if len(scopeNodes) > 0:
                scopes = getScopes(scopeNodes[0])

            xAddrs = []
            xAddrNodes = node.getElementsByTagNameNS(NS_WSD, "XAddrs")
            if len(xAddrNodes) > 0:
                xAddrs = getXAddrs(xAddrNodes[0])

            mdv = node.getElementsByTagNameNS(NS_WSD, "MetadataVersion")[0].firstChild.data.strip()
            env.getProbeResolveMatches().append(ProbeResolveMatch(epr, types, scopes, xAddrs, mdv))

        return env
    except Exception:
        env = None
        return None


class ProbeResolveMatch:

    def __init__(self, epr, types, scopes, xAddrs, metadataVersion):
        self._epr = epr
        self._types = types
        self._scopes = scopes
        self._xAddrs = xAddrs
        self._metadataVersion = metadataVersion

    def getEPR(self):
        return self._epr

    def getTypes(self):
        return self._types

    def getScopes(self):
        return self._scopes

    def getXAddrs(self):
        return self._xAddrs

    def getMetadataVersion(self):
        return self._metadataVersion

    def __repr__(self):
        return "EPR: %s\nTypes: %s\nScopes: %s\nXAddrs: %s\nMetadata Version: %s" % \
            (self.getEPR(), self.getTypes(), self.getScopes(),
             self.getXAddrs(), self.getMetadataVersion())