import logging

from apache_conf_parser import ApacheConfParser

from release.platforms import ftp2bouncer

SCHEMA_2_OPTIONAL_ATTRIBUTES_SINGLE_VALUE = (
    'showPrompt', 'showNeverForVersion', 'showSurvey', 'licenseUrl',
    'billboardURL', 'openURL', 'notificationURL', 'alertURL', 'promptWaitTime',
)
SCHEMA_2_OPTIONAL_ATTRIBUTES_MULTI_VALUE = ('actions',)
SCHEMA_2_OPTIONAL_ATTRIBUTES = SCHEMA_2_OPTIONAL_ATTRIBUTES_SINGLE_VALUE + \
    SCHEMA_2_OPTIONAL_ATTRIBUTES_MULTI_VALUE
log = logging.getLogger()


def substitutePath(path, platform=None, locale=None, version=None):
    """Returns a platform/locale specific path based on a generic one."""
    subs = {
        'platform': platform,
        'locale': locale,
        'version': version,
        'bouncer-platform': ftp2bouncer(platform)
    }
    for sub, replacement in subs.items():
        if '%%%s%%' % sub in path:
            if replacement is None:
                raise TypeError("No substitution provided for '%s'" % sub)
            path = path.replace('%%%s%%' % sub, replacement)
    return path


class PatcherConfigError(ValueError):
    pass


class PatcherConfig(dict):
    def __init__(self, cfg=None):
        self['appName'] = None
        self['current-update'] = {}
        self['release'] = {}
        self['past-update'] = []
        if cfg:
            self.readXml(cfg)

    def _stripStringNode(self, n):
        """Returns the value section of a node, even if it contains whitespace."""
        return n.split(" ", 1)[1].strip()

    def getFromVersions(self):
        # From versions come from both the "from" value in current-update
        # as well as by analyzing the past-update section. The original patcher
        # scripts go so far as to analyze the channels in the past-update
        # sections to deal with cases where the list of channels was different
        # in earlier versions. These days we don't have that case so we simply
        # assume that all of the fromVersions in the past-update lines are
        # versions that should have update paths to the latest on all channels.
        return tuple(set([self['current-update']['from']] + [v[0] for v in
                                                             self['past-update']]))

    def getOptionalAttrs(self, version, locale):
        if version not in self['release']:
            log.debug("%s not found in config" % version)
            return {}
        schema = self['release'][version]['schema']
        # Currently, only schema 2 has optional attributes
        attrs = {}
        if schema == 2:
            if locale in self['current-update'].get('action-locales',
                                                    self['release'][version]['locales']):
                for attr in SCHEMA_2_OPTIONAL_ATTRIBUTES:
                    if attr in self['current-update']:
                        attrs[attr] = substitutePath(self['current-update'][attr],
                                                     locale=locale)
        return attrs

    def getPath(self, version, platform, locale, type_):
        if type_ == 'complete':
            path = self['current-update']['complete']['path']
        else:
            if version not in self['current-update']['partials']:
                raise PatcherConfigError(
                    "Couldn't find partial update path for %s" % version)
            path = self['current-update']['partials'][version]['path']
        return substitutePath(path, platform, locale, version)

    def getUrl(self, version, platform, locale, type_, channel):
        """Returns the final URL to a specific update. Completes come from
           the <complete> block. Partials come from their version-specific block
           inside of <partials>. In both cases if a [channel]-url exists, it
           will be returned. If it doesn't exist the generic url will be
           returned. If neither exists a PatcherConfigError will be raised.
           The returned URL will have %platform% and %locale% substitutions
           performed on it."""
        # Find a list of potential URLs....
        if type_ == 'complete':
            urls = self['current-update']['complete']
        else:
            if version not in self['current-update']['partials']:
                raise PatcherConfigError(
                    "Couldn't find partial update URL for %s" % version)
            urls = self['current-update']['partials'][version]
        # Look for a channel-specific one. If that doesn't exist, try the
        # generic one.
        try:
            url = urls.get('%s-url' % channel, urls['url'])
        except KeyError:
            raise PatcherConfigError("Couldn't find URL for (%s, %s, %s, %s, %s)" % (version, platform, locale, type_, channel))
        return substitutePath(url, platform, locale, version)

    def getUpdatePaths(self):
        """A generator that yields all of the update paths for this config.
           Each individual update path is a tuple of:
            (fromVersion, platform, locale, updateTypes, channels)

           fromVersion, platform, and locale are all single-value strings.
           updateTypes is a list of one or both of 'complete' and 'partial'
           channels is a list channels the update path is applicable to
        """
        if not self['current-update']:
            return

        fromVersions = self.getFromVersions()
        channels = tuple(self['current-update']['testchannel'] +
                         self['current-update']['channel'])
        toLocales = self['release'][self['current-update']['to']]['locales']
        toExceptions = self['release'][self['current-update']['to']]['exceptions']

        # Now that we know all of the versions that need updates to the latest
        # we can start yielding the paths.
        for version in fromVersions:
            r = self['release'][version]
            for platform in r['platforms']:
                p = r['platforms'][platform]
                for locale in r['locales']:
                    # The exception lists are a little weird. If a locale is
                    # not in the exception list at all, it is applicable to all
                    # platforms. If it *is* in the exception list it is only
                    # applicable to the platforms listed.
                    if locale in r['exceptions'] and platform not in r['exceptions'][locale]:
                        log.debug("Not generating update path for %s %s because it's not in the exception list for old release." % (platform, locale))
                        continue
                    # Make sure the locale is in the "to" release. If it's not
                    # we shouldn't generate an update for it!
                    if locale not in toLocales:
                        log.debug('Not generating update path for %s %s %s because %s isn\'t a locale for the "to" version' % (version, platform, locale, locale))
                        continue
                    # Make sure the locale isn't an exception in the "to" release
                    if locale in toExceptions and platform not in toExceptions[locale]:
                        log.debug("Not generating update path for %s %s because it's not in the exception list for new release." % (platform, locale))
                        continue
                    # Some patcher configs will have a <partial> block for
                    # backwards compatibility purposes. We don't support that
                    # though, so if a partial update isn't mentioned in
                    # the partials section we don't know anything about it.
                    if 'partials' in self['current-update'] and version in self['current-update']['partials']:
                        types = ('complete', 'partial')
                    else:
                        types = ('complete',)
                    yield (version, platform, locale, channels, types)

    def addPastUpdate(self, value):
        for existing in self['past-update']:
            if value[0] == existing[0]:
                raise PatcherConfigError("Found multiple past-updates with duplicate to/from versions: %s" % value)
        self['past-update'].append(value)

    def addRelease(self, version, value):
        if version in self['release']:
            raise PatcherConfigError(
                "Found multiple releases with same version: %s" % version)
        self['release'][version] = value

    def readXml(self, cfg):
        """Reads a patcher config file translating into a dictionary.
           This method isn't capable of parsing all of the patcher configs
           that its Perl ancestor can because we don't need to support some
           older features anymore. Scenarios known not to work are:
            - Multiple <app> subsections.
            - Channel differences between past-update lines
            - <partial> is ignored (replaced by <partials>)
            - <rc> is ignored
        """
        # Read the config, set the appName
        c = ApacheConfParser(cfg, infile=False).nodes[0]
        if not c.body.nodes:
            raise PatcherConfigError("No app found in config.")
        if len(c.body.nodes) > 1:
            raise PatcherConfigError("Too many apps found (only 1 allowed).")
        app = c.body.nodes[0]
        self['appName'] = app.name

        # Parse the config, with the heavy lifting in helper methods.
        for node in app.body.nodes:
            if node.name == 'current-update':
                if self['current-update']:
                    raise PatcherConfigError(
                        "Found multiple current-update blocks.")
                self['current-update'] = self.parseCurrentUpdate(
                    node.body.nodes)
            elif node.name == 'past-update':
                self.addPastUpdate(self.parsePastUpdate(list(node.arguments)))
            elif node.name == 'release':
                for releaseNode in node.body.nodes:
                    self.addRelease(releaseNode.name,
                                    self.parseRelease(releaseNode.body.nodes))

        # Now, a bunch of verifications
        # Make sure we have a current-update
        if not self['current-update']:
            raise PatcherConfigError(
                "Required section current-update is empty")
        # Make sure required nodes exist in <current-update> and <release>
        # nodes.
        for node in ('channel', 'testchannel', 'complete', 'details', 'from', 'to'):
            if node not in self['current-update']:
                raise PatcherConfigError(
                    "Required node '%s' not found in current-update" % node)
        for version, releaseNode in self['release'].items():
            for node in ('locales', 'version', 'platforms'):
                if node not in releaseNode:
                    raise PatcherConfigError("Required node '%s' not found in release node '%s'" % (node, version))
        # Make sure that versions mentioned have a release block.
        if self['current-update']['to'] not in self['release']:
            raise PatcherConfigError("No release found for version '%s'" %
                                     self['current-update']['to'])
        if self['current-update']['from'] not in self['release']:
            raise PatcherConfigError("No release found for version '%s'" %
                                     self['current-update']['from'])
        for version in self['current-update'].get('partials', {}):
            if version not in self['release']:
                raise PatcherConfigError(
                    "No release found for version '%s'" % version)
        for version in self['past-update']:
            if version[0] not in self['release']:
                raise PatcherConfigError(
                    "No release found for version '%s'" % version[0])

    def parsePastUpdate(self, pastUpdate):
        # A past-update node is a single block of text in the format:
        # past-update from to channel...
        if len(pastUpdate) < 3:
            raise PatcherConfigError(
                "Too few elements in past-update block: %s" % pastUpdate)
        return [pastUpdate[0], pastUpdate[1], pastUpdate[2:]]

    def parseCurrentUpdate(self, currentUpdate):
        cu = {}
        for node in currentUpdate:
            # force is the only thing we're allowed to have more than once
            if node.name != 'force' and node.name in cu:
                raise PatcherConfigError("Found multiple entries for '%s' in current-update section" % node.name)

            # These are all single-value nodes.
            if node.name in ('details', 'from', 'to', 'beta-dir') + \
                    SCHEMA_2_OPTIONAL_ATTRIBUTES_SINGLE_VALUE:
                cu[node.name] = self._stripStringNode(node.content)
            # These are potentially multiple value nodes.
            elif node.name in ('channel', 'testchannel', 'action-locales') + \
                    SCHEMA_2_OPTIONAL_ATTRIBUTES_MULTI_VALUE:
                cu[node.name] = list(node.arguments)
            # Force is weird in that it's a multiple value node, but the
            # patcher config bumping script lists it multiple times rather
            # than putting all entries on the same line.
            elif node.name in ('force',):
                if node.name not in cu:
                    cu[node.name] = []
                cu[node.name].append(self._stripStringNode(node.content))
            # The rest are subsections which are only allowed once.
            elif node.name in ('complete', 'partials'):
                cu[node.name] = {}
                for subNode in node.body.nodes:
                    if subNode.name in cu[node.name]:
                        raise PatcherConfigError("Found multiple entries for '%s' in current-update's %s section" % (subNode.name, node.name))
                    # The partials sections has an additional level of depth.
                    # After that level, everything is single-value nodes.
                    if node.name in ('partials',):
                        cu[node.name][subNode.name] = {}
                        for deepNode in subNode.body.nodes:
                            if deepNode.name in cu[node.name][subNode.name]:
                                raise PatcherConfigError("Found multiple entries for '%s' in current-update's %s/%s section" % (deepNode.name, node.name, subNode.name))
                            cu[node.name][subNode.name][deepNode.name] = self._stripStringNode(deepNode.content)
                    # The other sections only contain single-value nodes.
                    else:
                        cu[node.name][subNode.name] = self._stripStringNode(
                            subNode.content)
        return cu

    def parseRelease(self, release):
        r = {}
        for node in release:
            if node.name in r:
                raise PatcherConfigError("Found multiple entries for '%s' in release section" % node.name)

            # These are all single-value nodes.
            if node.name in ('checksumsurl', 'completemarurl',
                             'extension-version', 'prettyVersion', 'version',
                             'mar-channel-ids'):
                r[node.name] = self._stripStringNode(node.content)
            elif node.name == 'schema':
                r['schema'] = int(node.arguments[0])
            # This is a potentially multiple value node.
            elif node.name == 'locales':
                r['locales'] = list(node.arguments)
            # The rest are subsections.
            elif node.name in ('exceptions', 'platforms'):
                r[node.name] = {}
                for subNode in node.body.nodes:
                    if subNode.name in r[node.name]:
                        raise PatcherConfigError("Found multiple entries for '%s' in a release's %s section" % (subNode.name, node.name))
                    # Nodes in this section are comma-separated lists.
                    # (Unlike every other list in this file.)
                    if node.name in ('exceptions',):
                        r[node.name][subNode.name] = [
                            p.strip(',') for p in subNode.arguments]
                    # Nodes in this section are space-separated.
                    elif node.name in ('platforms',):
                        r[node.name][subNode.name] = int(subNode.arguments[0])
        return r