#!/usr/bin/env python
# -*- coding: utf-8 mode: python -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8

import os, sys, re
from os import path
from argparse import ArgumentParser, REMAINDER
from glob import glob

USER_CONFDIR = '~/etc/deploy'
SYSTEM_CONFDIR = '/var/local/deploy'

################################################################################
# Base de données

class HostObject(object):
    @staticmethod
    def genid(host):
        host = re.sub(r'\..*', '', host)
        host = re.sub(r'[^a-zA-Z0-9]', '_', host)
        host = host.lower()
        return host
    @staticmethod
    def genib(id):
        if re.match(r'\d+$', id): return id
        ib = re.sub(r'^(.*?)\d+$', r'\1', id)
        return ib

    _id = None
    _hosts = None
    _attrs = None

    def __init__(self, id):
        self._id = id
        self._hosts = []
        self._attrs = {}
    def get_id(self): return self._id
    id = property(get_id)

    def get_hosts(self): return self._hosts
    hosts = property(get_hosts)
    def add_host(self, host):
        if host not in self._hosts: self._hosts.append(host)

    def get_attrs(self): return self._attrs
    attrs = property(get_attrs)

    def get_attr(self, name): return self._attrs.get(name, None)
    def set_attr(self, name, value):
        if name not in self._attrs: self._attrs[name] = []
        if value not in self._attrs[name]: self._attrs[name].append(value)
    def reset_attr(self, name, value=None):
        if name in self._attrs: del self._attrs[name]
        if value is not None: self.set_attr(name, value)
    def add_attr(self, name, value):
        if name not in self._attrs: self._attrs[name] = []
        self._attrs[name].append(value)
    def del_attr(self, name, value):
        if name not in self._attrs: return
        self._attrs[name].remove(value)
        if not self._attrs[name]: del self._attrs[name]
    def modify_attr(self, name, value, method='set'):
        if method == 'set': self.set_attr(name, value)
        elif method == 'reset': self.reset_attr(name, value)
        elif method == 'add': self.add_attr(name, value)
        elif method == 'del': self.del_attr(name, value)
    def copy_attrs(self, other, method='set'):
        for name, values in other.attrs.items():
            for value in values:
                self.modify_attr(name, value, method)

    def dump(self, indent=''):
        print "%s%s" % (indent, self.id)
        print "%s  hosts: %s" % (indent, ' '.join(self.hosts))
        if self.attrs:
            print "%s  attrs:" % indent
            for name, values in self.attrs.items():
                if len(values) == 1:
                    print "%s    %s=%s" % (indent, name, repr(values[0]))
                else:
                    print "%s    %s=(%s)" % (indent, name, ', '.join(map(repr, values)))

class Database(object):
    _known_profiles = None
    _default_profile = None
    _default_domain = None

    _objects = None
    _objects_classes = None

    def __init__(self):
        self._known_profiles = {}
        self._objects = {}
        self._objects_classes = {}

    def get_known_profiles(self):
        return self.known_profiles.keys()
    known_profiles = property(get_known_profiles)

    def has_default_profile(self):
        return self._default_profile is not None
    def get_default_profile(self):
        return self._default_profile
    def set_default_profile(self, profile):
        if profile: self._known_profiles[profile] = True
        self._default_profile = profile or None
    default_profile = property(get_default_profile, set_default_profile)

    def has_default_domain(self):
        return self._default_domain is not None
    def get_default_domain(self):
        return self._default_domain
    def set_default_domain(self, domain):
        if domain is not None:
            #XXX si le domaine a été corrigé, l'indiquer en warning
            if domain.startswith('.'): domain = domain[1:]
            if domain.endswith('.'): domain = domain[:-1]
        self._default_domain = domain or None
    default_domain = property(get_default_domain, set_default_domain)

    def register_object(self, otype, oclass):
        if not self._objects.has_key(otype):
            self._objects[otype] = {}
        self._objects_classes[otype] = oclass
    def get_objects(self, otype):
        objects = self._objects.get(otype, None)
        if objects is None: return None
        return [objects[id] for id in objects if id is not None]
    objects = property(get_objects)
    def has_object(self, otype, id):
        objects = self._objects.get(otype, None)
        if objects is None: return False
        return objects.has_key(id)
    def get_object(self, otype, id):
        objects = self._objects.get(otype, None)
        if objects is None: return None
        object = objects.get(id, None)
        if object is None:
            object_class = self._objects_classes.get(otype, None)
            if object_class is not None:
                object = object_class(id)
                self._objects[otype][id] = object
        return object

################################################################################
# Analyse des fichiers de configuration

class EOL(object):
    __repr__ = __string__ = lambda self: 'EOL'
EOL = EOL()
class EOF(object):
    __repr__ = __string__ = lambda self: 'EOF'
EOF = EOF()

class Lexer(object):
    file = None
    lexems = None
    _inf = None
    _lcount = None
    _line = None

    def __init__(self, file, parse=True):
        self.file = file
        if parse: self.parse()

    def next_line(self):
        line = self._inf.readline()
        if line == '': return None
        if line.endswith("\r\n"): line = line[:-2]
        elif line.endswith("\n"): line = line[:-1]
        elif line.endswith("\r"): line = line[:-1]
        self._lcount += 1
        self._line = line
        return line

    def is_empty(self): return self._line == ''
    def isa_comment(self): return self._line[:1] == '#'
    def isa_squote(self): return self._line[:1] == "'"
    def isa_dquote(self): return self._line[:1] == '"'

    RE_SPACE = re.compile(r'\s+')
    RE_COMMENT = re.compile(r'#.*')
    def parse_ws(self):
        mo = self.RE_SPACE.match(self._line)
        if mo is not None:
            self._line = self._line[mo.end(0):]
        mo = self.RE_COMMENT.match(self._line)
        if mo is not None:
            self._line = self._line[mo.end(0):]
    def isa_space(self): return self.RE_SPACE.match(self._line) is not None
    def isa_comment(self): return self.RE_COMMENT.match(self._line) is not None

    RE_SQUOTE = re.compile(r"'")
    def parse_sstring(self):
        slos = self._lcount
        lexem = ''
        self._line = self._line[1:]
        mo = self.RE_SQUOTE.search(self._line)
        while mo is None:
            lexem += self._line
            if self.next_line() is None:
                raise ValueError("unterminated quoted string starting at line %i" % slos)
            lexem += "\n"
            mo = self.RE_SQUOTE.search(self._line)
        lexem += self._line[0:mo.start(0)]
        self._line = self._line[mo.end(0):]
        return lexem

    RE_DQUOTE = re.compile(r'"')
    def parse_dstring(self):
        slos = self._lcount
        lexem = ''
        self._line = self._line[1:]
        mo = self.RE_DQUOTE.search(self._line)
        while mo is None:
            lexem += self._line
            if self.next_line() is None:
                raise ValueError("unterminated double-quoted string starting at line %i" % slos)
            lexem += "\n"
            mo = self.RE_DQUOTE.search(self._line)
        lexem += self._line[0:mo.start(0)]
        self._line = self._line[mo.end(0):]
        lexem = lexem.replace('\\"', '"')
        lexem = lexem.replace("\\'", "'")
        lexem = lexem.replace('\\\\', '\\')
        return lexem

    RE_EOS = re.compile(r'''\s|(?<!\\)['"]''')
    def parse_string(self):
        mo = self.RE_EOS.search(self._line)
        if mo is not None:
            lexem = self._line[0:mo.start(0)]
            self._line = self._line[mo.start(0):]
        else:
            lexem = self._line
            self._line = ''
        lexem = lexem.replace('\\"', '"')
        lexem = lexem.replace("\\'", "'")
        lexem = lexem.replace('\\\\', '\\')
        return lexem

    def parse(self):
        if self.lexems is not None: return self.lexems

        lexems = self.lexems = []
        self._inf = open(self.file, 'rb')
        self._lcount = 0
        self._line = ''
        try:
            SOL = False
            while True:
                # Ignorer lignes vides et commentaires
                self.parse_ws()
                stop = False
                while self.is_empty():
                    if SOL:
                        lexems.append(EOL)
                        SOL = False
                    if self.next_line() is None:
                        stop = True
                        break
                    self.parse_ws()
                if stop: break
                SOL = True
                # Construire une chaine
                lexem = ''
                while True:
                    if self.is_empty(): break
                    elif self.isa_space(): break
                    if self.isa_squote(): lexem += self.parse_sstring()
                    elif self.isa_dquote(): lexem += self.parse_dstring()
                    else: lexem += self.parse_string()
                lexems.append(lexem)
            lexems.append(EOF)
            return lexems
        finally:
            self._inf.close()
            self._inf = None
        return lexems

    def get_predicates(self):
        predicates = []
        predicate = []
        for lexem in self.parse():
            if lexem is EOF: break
            elif lexem is EOL:
                predicates.append(predicate)
                predicate = []
            else:
                predicate.append(lexem)
        return predicates

def split_scalar(arg):
    if '=' in arg:
        name, value = arg.split('=', 1)
    else:
        name = arg
        value = None
    if name.endswith('%'):
        name = name[:-1]
        method = 'reset'
    elif name.endswith('+'):
        name = name[:-1]
        method = 'add'
    elif name.endswith('-'):
        name = name[:-1]
        method = 'del'
    else:
        method = 'set'
    return name, method, value

def split_list(arg):
    if '=' in arg:
        name, values = arg.split('=', 1)
        values = values.split(',')
    else:
        name = None
        values = arg.split(',')
    return name, values

class Parser(object):
    db = None
    groups = None
    attr_otype = None

    def __init__(self, db=None):
        if db is None: db = Database()
        self.db = db
        self.groups = {}
        self.__setup_hosts()

    def parse(self, predicates):
        for p in predicates:
            cmd = p[0]
            args = p[1:]
            if cmd == 'default_profile': self.handle_default_profile(args)
            elif cmd == 'default_domain': self.handle_default_domain(args)
            elif cmd == 'group': self.handle_group(args)
            elif cmd == 'attr': self.handle_attr(args)
            elif cmd == 'host': self.handle_host(args)
        return self

    ############################################################################
    def reset_group(self, otype):
        self.groups[otype]['current'] = {}
    def reset_group_maybe(self, otype):
        if self.groups[otype]['type'] in ('defaults', 'once'):
            self.reset_group(otype)
            self.groups[otype]['type'] = 'once'
    def add_group(self, otype, id):
        self.groups[otype]['current'][id] = True

    def handle_group(self, args):
        """group otype gtype
        gtype peut valoir:
        - defaults: revenir à l'état initial, permettant de spécifier les
          attributs et liens pour tous les hôtes définis à partir de cette ligne
        - once: un nouveau groupe est défini à chaque nouvelle ligne 'group'
        - until: définir un groupe qui va jusqu'à la prochaine ligne 'group'
        """
        otype = args[0:1] and args[0] or 'host'
        if otype not in self.groups:
            raise ValueError('%s: invalid object type' % otype)
        gtype = args[1:2] and args[1] or 'until'
        self.groups[otype]['type'] = gtype
        if gtype == 'defaults':
            self.groups[otype]['current'] = {None: True}
        elif gtype in ('once', 'until'):
            self.groups[otype]['current'] = {}
        else:
            raise ValueError('%s: invalid group type' % gtype)

    ############################################################################
    def handle_attr(self, args):
        otype = self.attr_otype
        assert otype is not None, "attr_otype should not be None"
        for nv in args:
            name, method, value = split_scalar(nv)
            if value is None:
                method = 'set'
                value = '1'
            for id in self.groups[otype]['current']:
                self.db.get_object(otype, id).modify_attr(name, value, method)

    ############################################################################
    def handle_default_profile(self, args):
        if not args or not args[0]: profile = None
        else: profile = args[0]
        self.db.default_profile = profile

    ############################################################################
    def handle_default_domain(self, args):
        if not args or not args[0]: domain = None
        else: domain = args[0]
        self.db.default_domain = domain

    ############################################################################
    def __setup_hosts(self):
        self.db.register_object('host', HostObject)
        self.db.get_object('host', None)
        self.groups['host'] = {}
        self.handle_group(['host', 'defaults'])
        self.attr_otype = 'host'
    def __fix_host(self, host):
        if host.endswith('.'):
            host = host[:-1]
        elif '.' not in host and self.db.has_default_domain():
            host = '%s.%s' % (host, self.db.default_domain)
        return host

    def handle_host(self, args):
        """host [id=]host,...
        """
        AP = ArgumentParser()
        AP.add_argument('-b', '--basedir', action='append', dest='basedirs')
        AP.add_argument('-d', '--dirspec', action='append', dest='dirspecs')
        AP.add_argument('nvss', nargs=REMAINDER)
        o = AP.parse_args(args)
        # construire la liste des hôtes à traiter
        nvss = []
        if o.basedirs is not None:
            for basedir in [path.expanduser(basedir) for basedir in o.basedirs]:
                nvss.extend([path.abspath(path.join(basedir, name))
                             for name in os.listdir(basedir)
                             if path.isdir(path.join(basedir, name))])
        if o.dirspecs is not None:
            for dirspec in [path.expanduser(dirspec) for dirspec in o.dirspecs]:
                nvss.extend([path.abspath(dir)
                             for dir in glob(dirspec)
                             if path.isdir(dir)])
        nvss.extend(o.nvss)
        # préparer la mise à jour du groupe courant
        self.reset_group_maybe('host')
        self.attr_otype = 'host'
        default_ho = self.db.get_object('host', None)
        # traiter les hôtes
        for nvs in nvss:
            name, values = split_list(nvs)
            for host in values:
                dir = None
                if host:
                    if '/' in host:
                        dir, host = path.split(path.abspath(path.expanduser(host)))
                    host = self.__fix_host(host)
                if name:
                    ho = self.db.get_object('host', name)
                    if host: ho.add_host(host)
                    ho.copy_attrs(default_ho)
                    if dir is not None: ho.reset_attr('dir', dir)
                    self.add_group('host', name)
                else:
                    id = HostObject.genid(host)
                    ho = self.db.get_object('host', id)
                    ho.add_host(host)
                    ho.copy_attrs(default_ho)
                    if dir is not None: ho.reset_attr('dir', dir)
                    self.add_group('host', id)

                    ib = HostObject.genib(id)
                    ho = self.db.get_object('host', ib)
                    ho.add_host(host)
                    ho.copy_attrs(default_ho)
                    if dir is not None: ho.reset_attr('dir', dir)
                    self.add_group('host', ib)

def run_qdd(o):
    # fichier de configuration
    confname = o.confname or 'deploy'
    if '/' in confname:
        conf = path.abspath(confname)
    elif path.exists('%s.conf' % confname):
        conf = '%s.conf' % confname
    else:
        conf = confname
        if not conf.endswith('.conf'): conf = '%s.conf' % conf
        user_conf = path.join(path.expanduser(USER_CONFDIR), conf)
        system_conf = path.join(SYSTEM_CONFDIR, conf)
        if path.exists(user_conf): conf = user_conf
        elif path.exists(system_conf): conf = system_conf
    lexer = Lexer(conf)
    db = Database()

    if o.action == 'nop':
        pass
    elif o.action == 'dump': #XXX
        predicates = lexer.get_predicates()
        parser = Parser(db).parse(predicates)
        print "=== predicates"
        for p in predicates:
            print ' '.join(map(repr, p))
        print "=== hosts"
        for ho in db.get_objects('host'):
            ho.dump()
    elif o.action == 'query':
        parser = Parser(db).parse(lexer.get_predicates())

if __name__ == '__main__':
    from argparse import ArgumentParser, HelpFormatter
    if sys.argv[1:2] == ['--compat']:
        # Avec l'argument --compat, désactiver la classe FancyHelpFormatter qui
        # se base sur une API non documentée
        sys.argv = sys.argv[0:1] + sys.argv[2:]
        FancyHelpFormatter = HelpFormatter
    else:
        class FancyHelpFormatter(HelpFormatter):
            """Comme HelpFormatter, mais ne touche pas aux lignes qui commencent par les
            caractères '>>>'. Cela permet de mixer du texte formaté et du texte non
            formaté.
            """
            def _fill_text(self, text, width, indent):
                return ''.join([indent + line for line in text.splitlines(True)])
            def _split_lines(self, text, width):
                lines = ['']
                for line in text.splitlines():
                    if line.startswith('>>>'):
                        lines.append(line)
                        lines.append('')
                    else:
                        lines[-1] += '\n' + line
                lines = filter(None, lines)
                texts = []
                for line in lines:
                    if line.startswith('>>>'):
                        line = line[3:]
                        if line: texts.append(line)
                    else:
                        texts.extend(super(FancyHelpFormatter, self)._split_lines(line, width))
                return texts
    AP = ArgumentParser(
        usage=u"%(prog)s --query FILTER",
        description=__doc__,
        formatter_class=FancyHelpFormatter,
    )
    AP.set_defaults(action='query')
    AP.add_argument('-Q', '--query-action', action='store_const', dest='action', const='query',
                    help=u"Interroger la base de données. C'est l'option par défaut")
    AP.add_argument('-N', '--nop-action', action='store_const', dest='action', const='nop',
                    help=u"Ne rien faire. Utile pour vérifier si le fichier ne contient pas d'erreur de syntaxe.")
    AP.add_argument('-P', '--dump-action', action='store_const', dest='action', const='dump',
                    help=u"Afficher le contenu de la base de données.")
    AP.add_argument('-c', '--config', dest='confname',
                    help=u"Spécifier le nom de la configuration à utiliser. Par défaut, utiliser le nom générique deploy.")
    AP.add_argument('-q', '--query-type', dest='query_type',
                    help=u"")
    AP.add_argument('-j', '--object-type', dest='object_type',
                    help=u"")
    AP.add_argument('-t', '--link-type', dest='link_type',
                    help=u"")
    AP.add_argument('-p', '--profile', dest='profile',
                    help=u"Spécifier le profil de déploiement")
    AP.add_argument('-F', '--format', dest='format',
                    help=u"Spécifier le format pour la sortie. La valeur par défaut est shell.")
    AP.add_argument('-v', '--include-vars', dest='vars', metavar='VARS...',
                    help=u"Spécifier les variables qui doivent être affichées. Par défaut, toutes les variables sont affichées.")
    AP.add_argument('-o', '--object-vars', action='store_true', dest='object_vars',
                    help=u"Afficher les variables associées aux objets.")
    AP.add_argument('-d', '--dest-vars', action='store_true', dest='dest_vars',
                    help=u"Afficher les variables associées aux hôtes destination.")
    AP.add_argument('-l', '--link-vars', action='store_true', dest='link_vars',
                    help=u"Afficher les variables associées aux liens.")
    AP.add_argument('--of', '--object-func', dest='object_func', metavar='FUNC',
                    help=u"Avec le format shell, spécifier le nom d'une fonction à afficher après les variables associées aux objets.")
    AP.add_argument('--df', '--dest-func', dest='dest_func', metavar='FUNC',
                    help=u"Avec le format shell, spécifier le nom d'une fonction à afficher après les variables associées aux hôtes destination.")
    AP.add_argument('--lf', '--link-func', dest='link_func', metavar='FUNC',
                    help=u"Avec le format shell, spécifier le nom d'une fonction à afficher après les variables associées aux liens.")
    o = AP.parse_args()

    run_qdd(o)