#!/usr/bin/python
# encoding: UTF-8

#===============================================================================
# Define global imports
#===============================================================================
import os
import re
import sys
import codecs
import hashlib
import subprocess as sp
from . import constants
from .GLError import GLError
from .GLConfig import GLConfig
from .GLFileSystem import GLFileSystem


#===============================================================================
# Define module information
#===============================================================================
__author__ = constants.__author__
__license__ = constants.__license__
__copyright__ = constants.__copyright__


#===============================================================================
# Define global constants
#===============================================================================
PYTHON3 = constants.PYTHON3
NoneType = type(None)
APP = constants.APP
DIRS = constants.DIRS
ENCS = constants.ENCS
UTILS = constants.UTILS
MODES = constants.MODES
TESTS = constants.TESTS
compiler = constants.compiler
joinpath = constants.joinpath
cleaner = constants.cleaner
string = constants.string
isabs = os.path.isabs
isdir = os.path.isdir
isfile = os.path.isfile
normpath = os.path.normpath
relpath = os.path.relpath
filter_filelist = constants.filter_filelist


#===============================================================================
# Define GLModuleSystem class
#===============================================================================
class GLModuleSystem(object):
    '''GLModuleSystem is used to operate with module system using dynamic
    searching and patching.'''

    def __init__(self, config):
        '''GLModuleSystem.__init__(config) -> GLModuleSystem

        Create new GLModuleSystem instance. Some functions use GLFileSystem class
        to look up a file in localdir or gnulib directories, or combine it through
        'patch' utility.'''
        self.args = dict()
        if type(config) is not GLConfig:
            raise(TypeError('config must be a GLConfig, not %s' %
                            type(config).__name__))
        self.config = config
        self.filesystem = GLFileSystem(self.config)

    def __repr__(self):
        '''x.__repr__ <==> repr(x)'''
        result = '<pygnulib.GLModuleSystem %s>' % hex(id(self))
        return(result)

    def exists(self, module):
        '''GLModuleSystem.exists(module) -> bool

        Check whether the given module exists.
        GLConfig: localdir.'''
        if type(module) is bytes or string:
            if type(module) is bytes:
                module = module.decode(ENCS['default'])
        else:  # if module has not bytes or string type
            raise(TypeError(
                'module must be a string, not %s' % type(module).__name__))
        result = bool()
        badnames = ['ChangeLog', 'COPYING', 'README', 'TEMPLATE',
                    'TEMPLATE-EXTENDED', 'TEMPLATE-TESTS']
        if isfile(joinpath(DIRS['modules'], module)) or \
                all([  # Begin all(iterable) function
                    self.config['localdir'],
                    isdir(joinpath(self.config['localdir'], 'modules')),
                    isfile(
                        joinpath(self.config['localdir'], 'modules', module))
                ]):  # Close all(iterable) function
            if module not in badnames:
                result = True
        return(result)

    def find(self, module):
        '''GLModuleSystem.find(module) -> GLModule

        Find the given module.'''
        if type(module) is bytes or string:
            if type(module) is bytes:
                module = module.decode(ENCS['default'])
        else:  # if module has not bytes or string type
            raise(TypeError(
                'module must be a string, not %s' % type(module).__name__))
        if self.exists(module):
            path, istemp = self.filesystem.lookup(joinpath('modules', module))
            result = GLModule(self.config, path, istemp)
            return(result)
        else:  # if not self.exists(module)
            if self.config['errors']:
                raise(GLError(3, module))
            else:  # if not self.config['errors']
                sys.stderr.write('gnulib-tool: warning: ')
                sys.stderr.write('file %s does not exist\n' % str(module))

    def list(self):
        '''GLModuleSystem.list() -> list

        Return the available module names as tuple. We could use a combination
        of os.walk() function and re module. However, it takes too much time to
        complete, so this version uses subprocess to run shell commands.'''
        result = string()
        listing = list()
        localdir = self.config['localdir']
        find_args = ['find', 'modules', '-type', 'f', '-print']
        sed_args = \
            [
                'sed',
                '-e', r's,^modules/,,',
                '-e', r'/^ChangeLog$/d',
                '-e', r'/\/ChangeLog$/d',
                '-e', r'/^COPYING$/d',
                '-e', r'/\/COPYING$/d',
                '-e', r'/^README$/d',
                '-e', r'/\/README$/d',
                '-e', r'/^TEMPLATE$/d',
                '-e', r'/^TEMPLATE-EXTENDED$/d',
                '-e', r'/^TEMPLATE-TESTS$/d',
                '-e', r'/^\..*/d',
                '-e', r'/~$/d',
                '-e', r'/-tests$/d',
            ]

        # Read modules from gnulib root directory.
        os.chdir(constants.DIRS['root'])
        find = sp.Popen(find_args, stdout=sp.PIPE)
        result += find.stdout.read().decode("UTF-8")

        # Read modules from local directory.
        if localdir and isdir(joinpath(localdir, 'modules')):
            os.chdir(localdir)
            find = sp.Popen(find_args, stdout=sp.PIPE)
            result += find.stdout.read().decode("UTF-8")
            sed_args += ['-e', r's,\.diff$,,']

        # Save the list of the modules to file.
        os.chdir(DIRS['cwd'])
        path = joinpath(self.config['tempdir'], 'list')
        with codecs.open(path, 'wb', 'UTF-8') as file:
            file.write(result)

        # Filter the list of the modules.
        stdin = codecs.open(path, 'rb', 'UTF-8')
        sed = sp.Popen(sed_args, stdin=stdin, stdout=sp.PIPE)
        result = sed.stdout.read().decode("UTF-8")
        stdin.close()
        os.remove(path)
        listing = [line for line in result.split('\n') if line.strip()]
        listing = sorted(set(listing))
        return(listing)


#===============================================================================
# Define GLModule class
#===============================================================================
class GLModule(object):
    '''GLModule is used to create a module object from the file with the given
    path. GLModule can get all information about module, get its dependencies,
    files, etc.'''

    def __init__(self, config, module, patched=False):
        '''GLModule.__init__(config, module[, patched]) -> GLModule

        Create new GLModule instance. Arguments are module and patched, where
        module is a string representing the path to the module and patched is a
        bool indicating that module was created after applying patch.'''
        self.args = dict()
        self.cache = dict()
        self.content = string()
        if type(config) is not GLConfig:
            raise(TypeError('config must be a GLConfig, not %s' %
                            type(config).__name__))
        if type(module) is bytes or type(module) is string:
            if type(module) is bytes:
                module = module.decode(ENCS['default'])
        else:  # if module has not bytes or string type
            raise(TypeError('module must be a string, not %s' %
                            type(module).__name__))
        if type(patched) is not bool:
            raise(TypeError('patched must be a bool, not %s' %
                            type(module).__name__))
        self.module = module
        self.patched = patched
        self.config = config
        self.filesystem = GLFileSystem(self.config)
        self.modulesystem = GLModuleSystem(self.config)
        with codecs.open(module, 'rb', 'UTF-8') as file:
            self.content = file.read()
        self.regex = '(?:Description:|Comment:|Status:|Notice:|Applicability:|\
Files:|Depends-on:|configure\\.ac-early:|configure\\.ac:|Makefile\\.am:|\
Include:|Link:|License:|Maintainer:)'

    def __eq__(self, module):
        '''x.__eq__(y) <==> x==y'''
        result = bool()
        if type(module) is GLModule:
            if self.module == module.module:
                result = True
        return(result)

    def __ne__(self, module):
        '''x.__ne__(y) <==> x!=y'''
        result = bool()
        if type(module) is GLModule:
            if self.module != module.module:
                result = True
        return(result)

    def __ge__(self, module):
        '''x.__ge__(y) <==> x>=y'''
        result = bool()
        if type(module) is GLModule:
            if self.module >= module.module:
                result = True
        return(result)

    def __gt__(self, module):
        '''x.__gt__(y) <==> x>y'''
        result = bool()
        if type(module) is GLModule:
            if self.module > module.module:
                result = True
        return(result)

    def __hash__(self):
        '''x.__hash__() <==> hash(x)'''
        module = hash(self.module)
        patched = hash(self.patched)
        result = module ^ patched
        return(result)

    def __le__(self, module):
        '''x.__le__(y) <==> x<=y'''
        result = bool()
        if type(module) is GLModule:
            if self.module <= module.module:
                result = True
        return(result)

    def __lt__(self, module):
        '''x.__lt__(y) <==> x<y'''
        result = bool()
        if type(module) is GLModule:
            if self.module < module.module:
                result = True
        return(result)

    def __str__(self):
        '''x.__str__() <==> str(x)'''
        result = self.getName()
        return(result)

    def __repr__(self):
        '''x.__repr__ <==> repr(x)'''
        result = '<pygnulib.GLModule %s %s>' % \
            (repr(self.getName()), hex(id(self)))
        return(result)

    def getName(self):
        '''GLModule.getName() -> string

        Return the name of the module.'''
        pattern = compiler(joinpath('modules', '(.*?)$'))
        result = pattern.findall(self.module)[0]
        return(result)

    def isPatched(self):
        '''GLModule.isPatched() -> bool

        Check whether module was created after applying patch.'''
        return(self.patched)

    def isTests(self):
        '''GLModule.isTests() -> bool

        Check whether module is a -tests version of module.'''
        result = self.getName().endswith('-tests')
        return(result)

    def isNonTests(self):
        '''GLModule.isTests() -> bool

        Check whether module is not a -tests version of module.'''
        result = not(self.isTests())
        return(result)

    def getTestsName(self):
        '''Return -tests version of the module name.'''
        result = self.getName()
        if not result.endswith('-tests'):
            result += '-tests'
        return(result)

    def getTestsModule(self):
        '''Return -tests version of the module as GLModule.'''
        result = self.modulesystem.find(self.getTestsName())
        return(result)

    def getShellFunc(self):
        '''GLModule.getShellFunc() -> string

        Computes the shell function name that will contain the m4 macros for the
        module.'''
        isalnum = True
        macro_prefix = self.config['macro_prefix']
        for char in str(module):
            if char not in constants.ALPHANUMERIC:
                isalnum = False
                break
        if isalnum:
            module = str(self)
        else:  # if not isalnum
            module = '%s\n' % str(self)
            if type(module) is string:
                module = module.encode(ENCS['default'])
            module = hashlib.md5(module).hexdigest()
        result = 'func_%s_gnulib_m4code_%s' % (macro_prefix, module)
        if type(result) is bytes:
            result = result.decode(ENCS['default'])
        return(result)

    def getShellVar(self):
        '''GLModule.getShellVar() -> string

        Compute the shell variable name the will be set to true once the m4 macros
        for the module have been executed.'''
        isalnum = True
        macro_prefix = self.config['macro_prefix']
        for char in str(module):
            if char not in constants.ALPHANUMERIC:
                isalnum = False
                break
        if isalnum:
            module = str(self)
        else:  # if not isalnum
            module = '%s\n' % str(self)
            if type(module) is string:
                module = module.encode(ENCS['default'])
            module = hashlib.md5(module).hexdigest()
        result = '%s_gnulib_enabled_%s' % (macro_prefix, module)
        if type(result) is bytes:
            result = result.decode(ENCS['default'])
        return(result)

    def getConditionalName(self):
        '''GLModule.getConditionalName() -> string

        Return the automake conditional name.
        GLConfig: macro_prefix.'''
        macro_prefix = self.config['macro_prefix']
        nonascii = \
            [  # Begin to filter non-ascii chars
                char for char in self.getName() if char not in \
                'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'
            ]  # Finish to filter non-ascii chars
        if nonascii:
            name = self.getName().encode(ENCS['default'])
            name = hashlib.md5(name).hexdigest()
            conditional = '%s_GNULIB_ENABLED_%s' % (macro_prefix, name)
        else:  # if not nonascii
            result = '%s_GNULIB_ENABLED_%s' (macro_prefix, name)
        if type(result) is bytes:
            result = result.decode(ENCS['default'])
        return(result)

    def getDescription(self):
        '''GLModule.getDescription() -> string

        Return description of the module.'''
        section = 'Description:'
        if 'description' not in self.cache:
            if section not in self.content:
                result = string()
            else:  # if section in self.content
                pattern = '^%s[\t ]*(.*?)%s' % (section, self.regex)
                pattern = compiler(pattern, re.S | re.M)
                result = pattern.findall(self.content)
                if type(result) is list:
                    if not result:
                        result = string()
                    else:  # if result
                        result = result[-1]
            result = result.strip()
            self.cache['description'] = result
        return(self.cache['description'])

    def getComment(self):
        '''GLModule.getComment() -> string

        Return comment to module.'''
        section = 'Comment:'
        if 'comment' not in self.cache:
            if section not in self.content:
                result = string()
            else:  # if section in self.content
                pattern = '^%s[\t ]*(.*?)%s' % (section, self.regex)
                pattern = compiler(pattern, re.S | re.M)
                result = pattern.findall(self.content)
                if type(result) is list:
                    if not result:
                        result = string()
                    else:  # if result
                        result = result[-1]
            result = result.strip()
            self.cache['comment'] = result
        return(self.cache['comment'])

    def getStatus(self):
        '''GLModule.getStatus() -> string

        Return module status.'''
        section = 'Status:'
        if 'status' not in self.cache:
            if section not in self.content:
                result = string()
            else:  # if section in self.content
                snippet = self.content.split(section)[-1]
                snippet = snippet.replace('\r\n', '\n')
                lines = ['%s\n' % line for line in snippet.split('\n')]
                parts = list()
                for line in lines:
                    regex = '^(Description|Comment|Status|Notice|Applicability|'
                    regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|'
                    regex += 'Makefile\\.am|Include|Link|License|Maintainer):$'
                    pattern = compiler(regex)
                    findflag = pattern.findall(line)
                    if findflag:
                        break
                    parts += [line]
                result = [part.strip() for part in parts if part.strip()]
            self.cache['status'] = list(result)
        return(list(self.cache['status']))

    def getNotice(self):
        '''GLModule.getNotice() -> string

        Return notice to module.'''
        section = 'Notice:'
        if 'notice' not in self.cache:
            if section not in self.content:
                result = string()
            else:  # if section in self.content
                snippet = self.content.split(section)[-1]
                snippet = snippet.replace('\r\n', '\n')
                lines = ['%s\n' % line for line in snippet.split('\n')]
                parts = list()
                for line in lines:
                    regex = '^(Description|Comment|Status|Notice|Applicability|'
                    regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|'
                    regex += 'Makefile\\.am|Include|Link|License|Maintainer):$'
                    pattern = compiler(regex)
                    findflag = pattern.findall(line)
                    if findflag:
                        break
                    parts += [line]
                result = ''.join(parts)
            self.cache['notice'] = result
        return(self.cache['notice'])

    def getApplicability(self):
        '''GLModule.getApplicability() -> string

        Return applicability of module.'''
        section = 'Applicability:'
        if 'applicability' not in self.cache:
            if section not in self.content:
                result = string()
            else:  # if section in self.content
                snippet = self.content.split(section)[-1]
                snippet = snippet.replace('\r\n', '\n')
                lines = ['%s\n' % line for line in snippet.split('\n')]
                parts = list()
                for line in lines:
                    regex = '^(Description|Comment|Status|Notice|Applicability|'
                    regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|'
                    regex += 'Makefile\\.am|Include|Link|License|Maintainer):$'
                    pattern = compiler(regex)
                    findflag = pattern.findall(line)
                    if findflag:
                        break
                    parts += [line]
                parts = [part.strip() for part in parts]
                result = ''.join(parts)
            if not result.strip():
                if self.getName().endswith('-tests'):
                    result = 'tests'
                else:  # if not self.getName().endswith('-tests')
                    result = 'main'
            if type(result) is bytes:
                result = result.decode(ENCS['default'])
            result = result.strip()
            self.cache['applicability'] = result
        return(self.cache['applicability'])

    def getFiles(self):
        '''GLModule.getFiles() -> list

        Return list of files.
        GLConfig: ac_version.'''
        ac_version = self.config['ac_version']
        section = 'Files:'
        result = list()
        if 'files' not in self.cache:
            if section not in self.content:
                result = list()
            else:  # if section in self.content
                snippet = self.content.split(section)[-1]
                snippet = snippet.replace('\r\n', '\n')
                lines = ['%s\n' % line for line in snippet.split('\n')]
                parts = list()
                for line in lines:
                    regex = '^(Description|Comment|Status|Notice|Applicability|'
                    regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|'
                    regex += 'Makefile\\.am|Include|Link|License|Maintainer):$'
                    pattern = compiler(regex)
                    findflag = pattern.findall(line)
                    if findflag:
                        break
                    parts += [line]
                result = [part.strip() for part in parts if part.strip()]
            result += [joinpath('m4', '00gnulib.m4')]
            result += [joinpath('m4', 'gnulib-common.m4')]
            self.cache['files'] = list(result)
        return(list(self.cache['files']))

    def getDependencies(self):
        '''GLModule.getDependencies() -> list

        Return list of dependencies.
        GLConfig: localdir.'''
        localdir = self.config['localdir']
        result = list()
        section = 'Depends-on:'
        if 'dependencies' not in self.cache:
            if section not in self.content:
                depmodules = list()
            else:  # if section in self.content
                snippet = self.content.split(section)[-1]
                snippet = snippet.replace('\r\n', '\n')
                lines = ['%s\n' % line for line in snippet.split('\n')]
                parts = list()
                for line in lines:
                    regex = '^(Description|Comment|Status|Notice|Applicability|'
                    regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|'
                    regex += 'Makefile\\.am|Include|Link|License|Maintainer):$'
                    pattern = compiler(regex)
                    findflag = pattern.findall(line)
                    if findflag:
                        break
                    parts += [line]
                modules = ''.join(parts)
                modules = [line for line in modules.split(
                    '\n') if line.strip()]
                modules = [
                    module for module in modules if not module.startswith('#')]
                for line in modules:
                    split = [part for part in line.split(' ') if part.strip()]
                    if len(split) == 1:
                        module = line.strip()
                        condition = None
                    else:  # if len(split) != 1
                        module = split[0]
                        condition = split[1]
                        if type(condition) is bytes:
                            condition = condition.decode(ENCS['default'])
                    result += [tuple([self.modulesystem.find(module), condition])]
            self.cache['dependencies'] = result
        return(list(self.cache['dependencies']))

    def getAutoconfSnippet_Early(self):
        '''GLModule.getAutoconfSnippet_Early() -> string

        Return autoconf-early snippet.'''
        section = 'configure.ac-early:'
        if 'autoconf-early' not in self.cache:
            if section not in self.content:
                result = string()
            else:  # if section in self.content
                snippet = self.content.split(section)[-1]
                snippet = snippet.replace('\r\n', '\n')
                lines = ['%s\n' % line for line in snippet.split('\n')]
                parts = list()
                for line in lines:
                    regex = '^(Description|Comment|Status|Notice|Applicability|'
                    regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|'
                    regex += 'Makefile\\.am|Include|Link|License|Maintainer):$'
                    pattern = compiler(regex)
                    findflag = pattern.findall(line)
                    if findflag:
                        break
                    parts += [line]
                result = ''.join(parts)
            self.cache['autoconf-early'] = result
        return(self.cache['autoconf-early'])

    def getAutoconfSnippet(self):
        '''GLModule.getAutoconfSnippet() -> string

        Return autoconf snippet.'''
        section = 'configure.ac:'
        if 'autoconf' not in self.cache:
            if section not in self.content:
                result = string()
            else:  # if section in self.content
                snippet = self.content.split(section)[-1]
                snippet = snippet.replace('\r\n', '\n')
                lines = ['%s\n' % line for line in snippet.split('\n')]
                parts = list()
                for line in lines:
                    regex = '^(Description|Comment|Status|Notice|Applicability|'
                    regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|'
                    regex += 'Makefile\\.am|Include|Link|License|Maintainer):$'
                    pattern = compiler(regex)
                    findflag = pattern.findall(line)
                    if findflag:
                        break
                    parts += [line]
                result = ''.join(parts)
            self.cache['autoconf'] = result
        return(self.cache['autoconf'])

    def getAutomakeSnippet(self):
        '''getAutomakeSnippet() -> string

        Get automake snippet.
        GLConfig: auxdir, ac_version.'''
        result = string()  # Define stack variable
        conditional = self.getAutomakeSnippet_Conditional()
        if conditional.strip():
            result += self.getAutomakeSnippet_Conditional()
        else:  # if not conditional.strip()
            result += '\n'
        result += self.getAutomakeSnippet_Unconditional()
        return(result)

    def getAutomakeSnippet_Conditional(self):
        '''GLModule.getAutomakeSnippet_Conditional() -> string

        Return conditional automake snippet.'''
        section = 'Makefile.am:'
        if 'makefile-conditional' not in self.cache:
            if section not in self.content:
                result = string()
            else:  # if section in self.content
                snippet = self.content.split(section)[-1]
                snippet = snippet.replace('\r\n', '\n')
                lines = ['%s\n' % line for line in snippet.split('\n')]
                parts = list()
                for line in lines:
                    regex = '^(Description|Comment|Status|Notice|Applicability|'
                    regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|'
                    regex += 'Makefile\\.am|Include|Link|License|Maintainer):$'
                    pattern = compiler(regex)
                    findflag = pattern.findall(line)
                    if findflag:
                        break
                    parts += [line]
                result = ''.join(parts)
            self.cache['makefile-conditional'] = result
        return(self.cache['makefile-conditional'])

    def getAutomakeSnippet_Unconditional(self):
        '''GLModule.getAutomakeSnippet_Unconditional() -> string

        Return unconditional automake snippet.
        GLConfig: auxdir, ac_version.'''
        auxdir = self.config['auxdir']
        ac_version = self.config['ac_version']
        result = string()
        if 'makefile-unconditional' not in self.cache:
            if self.isTests():
                files = self.getFiles()
                extra_files = filter_filelist(constants.NL, files,
                                              'tests/', '', 'tests/', '').split(constants.NL)
                extra_files = sorted(set(extra_files))
                if extra_files:
                    result += string('EXTRA_DIST += %s' %
                                     ' '.join(extra_files))
                    result += constants.NL * 2
            else:  # if not tests module
                # TODO: unconditional automake snippet for nontests modules
                snippet = self.getAutomakeSnippet_Conditional()
                snippet = constants.combine_lines(snippet)
                pattern = compiler(
                    '^lib_SOURCES[\t ]*\\+=[\t ]*(.*?)$', re.S | re.M)
                mentioned_files = pattern.findall(snippet)
                if mentioned_files != list():
                    mentioned_files = mentioned_files[-1].split(' ')
                    mentioned_files = [f.strip() for f in mentioned_files]
                    mentioned_files = [f for f in mentioned_files if f != '']
                    mentioned_files = sorted(set(mentioned_files))
                all_files = self.getFiles()
                lib_files = filter_filelist(constants.NL, all_files,
                                            'lib/', '', 'lib/', '').split(constants.NL)
                extra_files = [
                    f for f in lib_files if f not in mentioned_files]
                extra_files = sorted(set(extra_files))
                if extra_files != [''] and extra_files:
                    result += string('EXTRA_DIST += %s' %
                                     ' '.join(extra_files))
                    result += '\n\n'
                # Synthesize also an EXTRA_lib_SOURCES augmentation
                if str(self) != 'relocatable-prog-wrapper' and str(self) != 'pt_chown':
                    extra_files = filter_filelist(constants.NL, extra_files,
                                                  '', '.c', '', '').split(constants.NL)
                    extra_files = sorted(set(extra_files))
                    if extra_files != ['']:
                        result += string('EXTRA_lib_SOURCES += %s' %
                                         ' '.join(extra_files))
                        result += '\n\n'
                # Synthesize an EXTRA_DIST augmentation also for the files in build-aux
                buildaux_files = filter_filelist(constants.NL, all_files,
                                                 'build-aux/', '', 'build-aux/', '').split(constants.NL)
                buildaux_files = sorted(set(buildaux_files))
                if buildaux_files != ['']:
                    buildaux_files = ''.join(buildaux_files)
                    buildaux_files = joinpath(
                        '$(top_srcdir)', auxdir, buildaux_files)
                    result += string('EXTRA_DIST += %s' % buildaux_files)
                    result += '\n\n'
                # Synthesize an EXTRA_DIST augmentation also for the files from top/.
                top_files = filter_filelist(constants.NL, all_files,
                                            'top/', '', 'top/', '').split(constants.NL)
                top_files = sorted(set(top_files))
                if top_files != ['']:
                    top_files = ''.join(top_files)
                    top_files = joinpath('$(top_srcdir)', top_files)
                    result += string('EXTRA_DIST += %s' % top_files)
                    result += '\n\n'
            result = constants.nlconvert(result)
            self.cache['makefile-unconditional'] = result
        return(self.cache['makefile-unconditional'])

    def getInclude(self):
        '''GLModule.getInclude() -> string

        Return include directive.'''
        section = 'Include:'
        if 'include' not in self.cache:
            if section not in self.content:
                result = string()
            else:  # if section in self.content
                snippet = self.content.split(section)[-1]
                snippet = snippet.replace('\r\n', '\n')
                lines = ['%s\n' % line for line in snippet.split('\n')]
                parts = list()
                for line in lines:
                    regex = '^(Description|Comment|Status|Notice|Applicability|'
                    regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|'
                    regex += 'Makefile\\.am|Include|Link|License|Maintainer):$'
                    pattern = compiler(regex)
                    findflag = pattern.findall(line)
                    if findflag:
                        break
                    parts += [line]
                result = ''.join(parts)
            result = result.strip()
            pattern = compiler('^(["<].*?[>"])', re.S | re.M)
            result = pattern.sub('#include \\1', result)
            self.cache['include'] = result
        return(self.cache['include'])

    def getLink(self):
        '''GLModule.getLink() -> string

        Return link directive.'''
        section = 'Link:'
        if 'link' not in self.cache:
            if section not in self.content:
                result = string()
            else:  # if section in self.content
                snippet = self.content.split(section)[-1]
                snippet = snippet.replace('\r\n', '\n')
                lines = ['%s\n' % line for line in snippet.split('\n')]
                parts = list()
                for line in lines:
                    regex = '^(Description|Comment|Status|Notice|Applicability|'
                    regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|'
                    regex += 'Makefile\\.am|Include|Link|License|Maintainer):$'
                    pattern = compiler(regex)
                    findflag = pattern.findall(line)
                    if findflag:
                        break
                    parts += [line]
                parts = [part.strip() for part in parts if part.strip()]
                result = ''.join(parts)
            self.cache['link'] = result
        return(self.cache['link'])

    def getLicense(self):
        '''GLModule.getLicense(self) -> string

        Get license and warn user if module lacks a license.'''
        license = self.getLicense_Raw()
        if not self.isTests():
            if not license:
                if self.config['errors']:
                    raise(GLError(18, string(self)))
                else:  # if not self.config['errors']
                    sys.stderr.write('gnulib-tool: warning: ')
                    sys.stderr.write('module %s lacks a license\n' % str(self))
        if not license:
            license = 'GPL'
        return(license)

    def getLicense_Raw(self):
        '''GLModule.getLicense_Raw() -> string

        Return module license.'''
        section = 'License:'
        if 'license' not in self.cache:
            if section not in self.content:
                result = string()
            else:  # if section in self.content
                pattern = '^%s[\t ]*(.*?)%s' % (section, self.regex)
                pattern = compiler(pattern, re.S | re.M)
                result = pattern.findall(self.content)
                if type(result) is list:
                    if not result:
                        result = string()
                    else:  # if result
                        result = result[-1]
            result = result.strip()
            self.cache['license'] = result
        return(self.cache['license'])

    def getMaintainer(self):
        '''GLModule.getMaintainer() -> string

        Return maintainer directive.'''
        section = 'Maintainer:'
        if 'maintainer' not in self.cache:
            if section not in self.content:
                result = string()
            else:  # if section in self.content
                snippet = self.content.split(section)[-1]
                snippet = snippet.replace('\r\n', '\n')
                lines = ['%s\n' % line for line in snippet.split('\n')]
                parts = list()
                for line in lines:
                    regex = '^(Description|Comment|Status|Notice|Applicability|'
                    regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|'
                    regex += 'Makefile\\.am|Include|Link|License|Maintainer):$'
                    pattern = compiler(regex)
                    findflag = pattern.findall(line)
                    if findflag:
                        break
                    parts += [line]
                result = ''.join(parts)
            result = result.strip()
            self.cache['maintainer'] = result
        return(self.cache['maintainer'])


#===============================================================================
# Define GLModuleTable class
#===============================================================================
class GLModuleTable(object):
    '''GLModuleTable is used to work with the list of the modules.'''

    def __init__(self, config, avoids=list()):
        '''GLModuleTable.__init__(config, avoids) -> GLModuleTable

        Create new GLModuleTable instance. If modules are specified, then add
        every module from iterable as unconditional module. If avoids is specified,
        then in transitive_closure every dependency which is in avoids won't be
        included in the final modules list. If testflags iterable is enabled, then
        don't add module which status is in the testflags. If conddeps are enabled,
        then store condition for each dependency if it has a condition.
        The only necessary argument is localdir, which is needed just to create
        modulesystem instance to look for dependencies.'''
        self.avoids = list()  # Avoids
        self.dependers = dict()  # Dependencies
        self.conditionals = dict()  # Conditional modules
        self.unconditionals = dict()  # Unconditional modules
        self.base_modules = list()  # Base modules
        self.main_modules = list()  # Main modules
        self.tests_modules = list()  # Tests modules
        self.final_modules = list()  # Final modules
        if type(config) is not GLConfig:
            raise(TypeError('config must be a GLConfig, not %s' %
                            type(config).__name__))
        for avoid in avoids:
            if type(avoid) is not GLModule:
                raise(TypeError('each avoid must be a GLModule instance'))
            self.avoids += [avoids]
        self.config = config
        self.filesystem = GLFileSystem(self.config)
        self.modulesystem = GLModuleSystem(self.config)

    def __repr__(self):
        '''x.__repr__() <==> repr(x)'''
        result = '<pygnulib.GLModuleTable %s>' % hex(id(self))
        return(result)

    def __getitem__(self, y):
        '''x.__getitem__(y) <==> x[y]'''
        if y in ['base', 'final', 'main', 'tests', 'avoids']:
            if y == 'base':
                return(self.getBaseModules())
            elif y == 'final':
                return(self.getFinalModules())
            elif y == 'main':
                return(self.getMainModules())
            elif y == 'tests':
                return(self.getTestsModules())
            else:  # if y == 'avoids'
                return(self.getAvoids())
        else:  # if y is not in list
            raise(KeyError('GLModuleTable does not contain key: %s' % repr(y)))

    def addConditional(self, parent, module, condition):
        '''GLModuleTable.addConditional(module, condition)

        Add new conditional dependency from parent to module with condition.'''
        if type(parent) is not GLModule:
            raise(TypeError('parent must be a GLModule, not %s' %
                            type(parent).__name__))
        if type(module) is not GLModule:
            raise(TypeError('module must be a GLModule, not %s' %
                            type(module).__name__))
        if type(condition) is bytes or type(condition) is string \
                or condition == True:
            if type(condition) is bytes:
                condition = condition.decode(ENCS['default'])
        else:  # if condition has not bytes or string type or is not True
            raise(TypeError('condition must be a string or True, not %s' %
                            type(condition).__name__))
        if not str(module) in self.unconditionals:
            if str(module) not in self.dependers:
                self.dependers[module] = list()
            self.dependers[module] += [module]
            key = '%s---%s' % (str(parent), str(module))
            self.conditionals[key] = condition

    def addUnconditional(self, module):
        '''GLModuleTable.addUnconditional(module)

        Add module as unconditional dependency.'''
        if type(module) is not GLModule:
            raise(TypeError('module must be a GLModule, not %s' %
                            type(module).__name__))
        if str(module) in self.dependers:
            self.dependers.pop(str(module))
        self.unconditionals[str(module)] = True

    def isConditional(self, module):
        '''GLModuleTable.isConditional(module) -> bool

        Check whether module is unconditional.'''
        if type(module) is not GLModule:
            raise(TypeError('module must be a GLModule, not %s' %
                            type(module).__name__))
        result = str(module) in self.dependers
        return(result)

    def getCondition(self, parent, module):
        '''GLModuleTable.getCondition(module) -> string or True

        Return condition from parent to module. Condition can be string or True.
        If module is not in the list of conddeps, method returns None.'''
        if type(parent) is not GLModule:
            raise(TypeError('parent must be a GLModule, not %s' %
                            type(parent).__name__))
        if type(module) is not GLModule:
            raise(TypeError('module must be a GLModule, not %s' %
                            type(module).__name__))
        key = '%s---%s' % (str(parent), str(module))
        result = None
        if key in self.conditionals:
            result = self.conditionals[key]
        return(result)

    def transitive_closure(self, modules):
        '''GLModuleTable.transitive_closure(modules) -> list

        Use transitive closure to add module and its dependencies. Add every
        module and its dependencies from modules list, but do not add dependencies
        which contain in avoids list. If any testflag is enabled, then do not add
        dependencies which have the status as this flag. If conddeps are enabled,
        then store condition for each dependency if it has a condition. This method
        is used to update final list of modules. Method returns list of modules.
        GLConfig: testflags.'''
        for module in modules:
            if type(module) is not GLModule:
                raise(TypeError('each module must be a GLModule instance'))
        handledmodules = list()
        inmodules = modules
        outmodules = list()
        if self.config['conddeps']:
            for module in modules:
                self.addUnconditional(module)
        while inmodules:
            inmodules_this_round = inmodules
            inmodules = list()
            for module in inmodules_this_round:
                outmodules += [module]
                if self.config['conddeps']:
                    automake_snippet = \
                        module.getAutomakeSnippet_Conditional()
                    pattern = compiler('^if')
                    if not pattern.findall(automake_snippet):
                        self.addUnconditional(module)
                    conditional = self.isConditional(module)
                dependencies = module.getDependencies()
                depmodules = [pair[0] for pair in dependencies]
                conditions = [pair[1] for pair in dependencies]
                if TESTS['tests'] in self.config['testflags']:
                    testsname = module.getTestsName()
                    if self.modulesystem.exists(testsname):
                        testsmodule = self.modulesystem.find(testsname)
                        depmodules += [testsmodule]
                        conditions += [None]
                for depmodule in depmodules:
                    include = True
                    includes = list()
                    status = depmodule.getStatus()
                    for word in status:
                        if word == 'obsolete':
                            if TESTS['obsolete'] in self.config['testflags'] or \
                                    TESTS['all-test'] in self.config['testflags']:
                                includes += [False]
                        elif word == 'c++-test':
                            if TESTS['c++-test'] in self.config['testflags'] or \
                                    TESTS['all-test'] in self.config['testflags']:
                                includes += [False]
                        elif word == 'longrunning-test':
                            if TESTS['longrunning-test'] in self.config['testflags'] or \
                                    TESTS['all-test'] in self.config['testflags']:
                                includes += [False]
                        elif word == 'privileged-test':
                            if TESTS['privileged-test'] in self.config['testflags'] or \
                                    TESTS['all-test'] in self.config['testflags']:
                                includes += [False]
                        elif word == 'all-test':
                            if TESTS['all-test'] in self.config['testflags'] or \
                                    TESTS['all-test'] in self.config['testflags']:
                                includes += [False]
                        else:  # if any other word
                            if word.endswith('-tests'):
                                if TESTS['all-test'] in self.config['testflags']:
                                    includes += [False]
                        include = any(includes)
                    if include and depmodule not in self.avoids:
                        inmodules += [depmodule]
                        if self.config['conddeps']:
                            index = depmodules.index(depmodule)
                            condition = conditions[index]
                            if condition:
                                self.addConditional(
                                    module, depmodule, condition)
                            else:  # if condition
                                if conditional:
                                    self.addConditional(
                                        module, depmodule, True)
                                else:  # if not conditional
                                    self.addUnconditional(module)
            listing = list()  # Create empty list
            inmodules = sorted(set(inmodules))
            handledmodules = sorted(set(handledmodules + inmodules_this_round))
            inmodules = \
                [  # Begin to filter inmodules
                    module for module in inmodules if module not in handledmodules
                ]  # Finish to filter inmodules
            inmodules = sorted(set(inmodules))
        modules = sorted(set(outmodules))
        self.modules = modules
        return(list(modules))

    def transitive_closure_separately(self, basemodules, finalmodules):
        '''GLModuleTable.transitive_closure_separately(*args, **kwargs) -> tuple

        Determine main module list and tests-related module list separately.
        The main module list is the transitive closure of the specified modules,
        ignoring tests modules. Its lib/* sources go into $sourcebase/. If lgpl is
        specified, it will consist only of LGPLed source.
        The tests-related module list is the transitive closure of the specified
        modules, including tests modules, minus the main module list excluding
        modules of applicability 'all'. Its lib/* sources (brought in through
        dependencies of *-tests modules) go into $testsbase/. It may contain GPLed
        source, even if lgpl is specified.
        Arguments are basemodules and finalmodules, where basemodules argument
        represents modules specified by user and finalmodules represents modules
        list after previous transitive_closure.
        Method returns tuple which contains two lists: the list of main modules and
        the list of tests-related modules. Both lists contain dependencies.
        GLConfig: testflags.'''
        inctests = False
        main_modules = list()
        tests_modules = list()
        if TESTS['tests'] in self.config['testflags']:
            self.config['testflags'].pop(TESTS['tests'])
            inctests = True
        for module in basemodules:
            if type(module) is not GLModule:
                raise(TypeError('each module must be a GLModule instance'))
        for module in finalmodules:
            if type(module) is not GLModule:
                raise(TypeError('each module must be a GLModule instance'))
        main_modules = self.transitive_closure(basemodules)
        tests_modules = \
            [m for m in finalmodules if m not in main_modules] + \
            [m for m in main_modules if m.getApplicability() != 'main']
        tests_modules = sorted(set(tests_modules))
        if inctests:
            testflags = sorted(
                set(self.config['testflags'] + [TESTS['tests']]))
            self.config.setTestFlags(testflags)
        result = tuple([main_modules, tests_modules])
        return(result)

    def add_dummy(self, modules):
        '''GLModuleTable.add_dummy(modules) -> list

        Add dummy package to list of modules if dummy package is needed. If not,
        return original list of modules.
        GLConfig: auxdir, ac_version.'''
        auxdir = self.config['auxdir']
        ac_version = self.config['ac_version']
        have_lib_sources = False
        for module in modules:
            if type(module) is not GLModule:
                raise(TypeError('each module must be a GLModule instance'))
            snippet = module.getAutomakeSnippet()
            snippet = constants.remove_backslash_newline(snippet)
            pattern = compiler(
                '^lib_SOURCES[\t ]*\\+=[\t ]*(.*?)$', re.S | re.M)
            files = pattern.findall(snippet)
            if files:  # if source files were found
                files = files[-1].split(' ')
                for file in files:
                    if not file.endswith('.h'):
                        have_lib_sources = True
                        break
        if not have_lib_sources:
            dummy = self.modulesystem.find('dummy')
            modules = sorted(set(modules + [dummy]))
        return(list(modules))

    def filelist(self, modules):
        '''GLModuleTable.filelist(modules) -> list

        Determine the final file list for the given list of modules. The list of
        modules must already include dependencies.
        GLConfig: ac_version.'''
        ac_version = self.config['ac_version']
        filelist = list()
        for module in modules:
            if type(module) is not GLModule:
                raise(TypeError('each module must be a GLModule instance'))
        listings = [module.getFiles() for module in modules]
        for listing in listings:
            for file in listing:
                if file not in filelist:
                    filelist += [file]
        return(filelist)

    def filelist_separately(self, main_modules, tests_modules):
        '''GLModuleTable.filelist_separately(**kwargs) -> list

        Determine the final file lists. They must be computed separately, because
        files in lib/* go into $sourcebase/ if they are in the main file list but
        into $testsbase/ if they are in the tests-related file list. Furthermore
        lib/dummy.c can be in both.'''
        ac_version = self.config['ac_version']
        main_filelist = self.filelist(main_modules)
        tests_filelist = self.filelist(tests_modules)
        tests_filelist = \
            [  # Begin to sort filelist
                file.replace('lib/', 'tests=lib/', 1) \
                if file.startswith('lib/') else file
                for file in tests_filelist
            ]  # Finish to sort filelist
        result = tuple([main_filelist, tests_filelist])
        return(result)

    def getAvoids(self):
        '''GLModuleTable.getAvoids() -> list

        Return list of avoids.'''
        return(list(self.avoids))

    def setAvoids(self, modules):
        '''GLModuleTable.setAvoids(modules)

        Specify list of avoids.'''
        for module in modules:
            if type(module) is not GLModule:
                raise(TypeError('each module must be a GLModule instance'))
        self.avoids = sorted(set(modules))

    def getBaseModules(self):
        '''GLModuleTable.getBaseModules() -> list

        Return list of base modules.'''
        return(list(self.base_modules))

    def setBaseModules(self, modules):
        '''GLModuleTable.setBaseModules(modules)

        Specify list of base modules.'''
        for module in modules:
            if type(module) is not GLModule:
                raise(TypeError('each module must be a GLModule instance'))
        self.base_modules = sorted(set(modules))

    def getFinalModules(self):
        '''GLModuleTable.getFinalModules() -> list

        Return list of final modules.'''
        return(list(self.final_modules))

    def setFinalModules(self, modules):
        '''GLModuleTable.setFinalModules(modules)

        Specify list of final modules.'''
        for module in modules:
            if type(module) is not GLModule:
                raise(TypeError('each module must be a GLModule instance'))
        self.final_modules = sorted(set(modules))

    def getMainModules(self):
        '''GLModuleTable.getMainModules() -> list

        Return list of main modules.'''
        return(list(self.main_modules))

    def setMainModules(self, modules):
        '''GLModuleTable.setMainModules(modules)

        Specify list of main modules.'''
        for module in modules:
            if type(module) is not GLModule:
                raise(TypeError('each module must be a GLModule instance'))
        self.main_modules = sorted(set(modules))

    def getTestsModules(self):
        '''GLModuleTable.getTestsModules() -> list

        Return list of tests modules.'''
        return(list(self.tests_modules))

    def setTestsModules(self, modules):
        '''GLModuleTable.setTestsModules(modules)

        Specify list of tests modules.'''
        for module in modules:
            if type(module) is not GLModule:
                raise(TypeError('each module must be a GLModule instance'))
        self.tests_modules = sorted(set(modules))