import re

import codecs

from cone.public import exceptions, utils, api, settings, rules, parsecontext

def uses_ref(refs, impl_refs):

    """

    Compare two lists of setting references and return whether any of the

    references in ``refs`` is used in ``impl_refs``.

    """

    for ref in refs:

        for impl_ref in impl_refs:

            if ref.startswith(impl_ref):

                if len(ref) == len(impl_ref):

                    return True

                elif ref[len(impl_ref)] == '.':

                    return True

    return False

class GenerationContext(rules.DefaultContext):

    def __init__(self, **kwargs):

        self.tags = kwargs.get('tags', {})

        self.tags_policy = kwargs.get('tags_policy', "OR")

        #: A string for the phase of the generation.

        #: If None, no filtering based on phase is done when

        #: running the implementations

        self.phase = kwargs.get('phase', None)

        self.configuration = kwargs.get('configuration', None)

        #: If True, then all implementation filtering done by

        #: should_run() is disabled, and it always returns True.

        self.filtering_disabled = False

        #: if True, then the execution flow should normal except 

        #: no output files are actually generated

        self.dry_run= kwargs.get('dry_run', None)

        #: the output folder for generation

        #: ensure already here that the output exists

        self.output= kwargs.get('output', 'output')

        #: List of references of the settings that have been modified in 

        #: listed layers and should trigger an implementation to be executed.

        #: None if ref filtering is not used

        self.changed_refs = kwargs.get('changed_refs', None)

        #: A boolean flag to determine whether to use ref filtering or not

        self.filter_by_refs = kwargs.get('filter_by_refs', False)

        #: Temp features

        self.temp_features = kwargs.get('temp_features', [])

        #: Executed implementation objects. This is a set so that a 

        #: implementation would exist only once in it. Even if it executed 

        #: more than once. The generation_output will show the actual 

        #: output several times if a implementation is executed several times.

        self.executed = set()

        #: Set of all implementation objects in the configuration context 

        self.impl_set = kwargs.get('impl_set', ImplSet())

        #: Generation output elements as a list 

        self.generation_output = []

        #: possible log elemement 

        self.log = []

        self.log_file = ""

    def __getstate__(self):

        state = self.__dict__

        state['impl_data_dict'] = {}

        return state

    def eval(self, ast, expression, value, **kwargs):

            if isinstance(expression, basestring): 

                try:

                    dview = self.configuration.get_default_view()

                    return dview.get_feature(expression).value

                except Exception, e:

                    logging.getLogger('cone').error("Could not dereference feature %s. Exception %s" % (expression, e))

                    raise e

    def convert_value(self, value):

        try:

            # Handle some special literals

            if value == 'true':     return True

            if value == 'false':    return False

            if value == 'none':     return None

            # Values can be any Python literals, so eval() the string to

            # get the value

            return eval(value)

        except Exception:

            ref_regex = re.compile('^[\w\.\*]*$', re.UNICODE) 

            if ref_regex.match(value) is None:

                raise RuntimeError("Could not evaluate '%s'" % value)

            else:

                raise RuntimeError("Could not evaluate '%s'. Did you mean a setting reference and forgot to use ${}?" % value)

    def set(self, expression, value, **kwargs):

        log = logging.getLogger('cone.ruleml')

        try:

            feature = self.configuration.get_default_view().get_feature(expression)

            feature.set_value(value)

            relation = kwargs.get('relation')

            if relation:

                log.info("Set %s = %r from %r" % (expression, value, relation))

            else:

                log.info("Set %s = %r" % (expression, value))

            refs = [feature.fqr]

            if feature.is_sequence():

                refs = ["%s.%s" % (feature.fqr,subref) for subref in feature.list_features()]

            self.add_changed_refs(refs, relation)

            if relation:

                self.generation_output.append(GenerationOutput(expression, 

                                                               relation,

                                                               type='ref'))

            return True

        except exceptions.NotFound,e:

            log.error('Set operation for %s failed, because feature with that reference was not found! Exception %s', expression, e) 

            raise e

    def should_run(self, impl, log_debug_message=True):

        """

        Return True if the given implementation should be run (generated).

        Also optionally log a message that the implementation is

        filtered out based on phase, tags or setting references.

        Calling this method also affects the output of executed_impls. Every

        implementation for which a call to this method has returned True

        will also be in that list.

        @param impl: The implementation to check.

        @param log_debug_message: If True, a debug message will be logged

            if the implementation is filtered out based on phase, tags

            or setting references.

        """

        if self.filtering_disabled:

            return True

        if isinstance(impl, ImplContainer):

            # Don't perform any filtering on containers

            return True

        impl_phases = impl.invocation_phase()

        if isinstance(impl_phases, basestring):

            impl_phases = [impl_phases]

        if self.phase is not None and self.phase not in impl_phases:

            # Don't log a debug message for phase-based filtering to

            # avoid unnecessary spamming (uncomment if necessary

            # during development)

            #logging.getLogger('cone').debug('Filtered out based on phase: %r (%r not in %r)' % (impl, self.phase, impl_phases))

            return False

        if self.tags and not impl.has_tag(self.tags, self.tags_policy):

            if log_debug_message:

                logging.getLogger('cone').debug('Filtered out based on tags: %r' % impl)

            return False

        if self.filter_by_refs and self.changed_refs and impl.has_ref(self.changed_refs) == False:

            if log_debug_message:

                logging.getLogger('cone').debug('Filtered out based on refs: %r' % impl)

            return False

        # Assumption is that when a implementation should be run it is added to the executed pile

        self.executed.add(impl)

        return True

    def have_run(self, impl):

        """

        This function will add the given implementation 

        outputs to the list of generation_outputs.

        """

        # Add outputs only from actual leaf implementations

        # not from ImplContainers

        if not isinstance(impl, ImplContainer):

            self.generation_output += impl.get_outputs()

    def create_file(self, filename, **kwargs):

        """

        Create a file handle under the output folder. Also adds the output file to the generation outputs list.

        @param filename: the filename with path, that is created under the output folder of the generation context.

        @param **kwargs: the keyword arguments that can provide essential information for the GenerationOutput 

        object creation. They should at least contain the implementation argument for the GenerationObject.

          @param **kwargs implementation: the implementation object that created this output

          @param **kwargs mode: the mode of the output file created 

          @param **kwargs encoding: the possible encoding of the output file. When this parameter is given the create_file will 

          use codecs.open method to create the file. 

        @return: the filehandle of the new file. 

        """

        implml   = kwargs.get('implementation', None)

        mode     = kwargs.get('mode', 'wb')

        encoding = kwargs.get('encoding', None)

        targetfile = os.path.normpath(os.path.join(self.output, filename))

        if not os.path.exists(os.path.dirname(targetfile)):

            os.makedirs(os.path.dirname(targetfile))

        if not encoding:

            outfile = open(targetfile, mode)

        else: 

            outfile = codecs.open(targetfile, mode, encoding)

        # Add the generation output

        self.generation_output.append(GenerationOutput(utils.resourceref.norm(targetfile), 

                                                       implml, 

                                                       phase=self.phase,

                                                       type='file',

                                                       output=self.output))

        return outfile

    def add_file(self, filename, **kwargs):

        """

        Add a file to the generation outputs list.

        @param filename: the filename with path, that is added. If the path is a relative path

        the path is added under the output folder of the generation context. Absolute path is added as such and not manipulated.

        @param **kwargs: the keyword arguments that can provide essential information for the GenerationOutput 

        object creation. They should at least contain the implementation argument for the GenerationObject.

        @return: None 

        """

        if not os.path.isabs(filename):

            targetfile = os.path.join(self.output, filename)

        else:

            targetfile = filename

        # Add the generation output

        self.generation_output.append(GenerationOutput(utils.resourceref.norm(targetfile), 

                                                       kwargs.get('implementation'), 

                                                       phase=self.phase,

                                                       type='file',

                                                       output=self.output))

    def get_output(self, **kwargs):

        """

        Get a output object from the generation_output list.

        @param **kwargs: the keyword arguments. 

            @param implml_type: a filter for generation outputs to filter generation outputs only with given implementation type. 

        @return: list of generation output objects

        """

        filters = []

        if kwargs.get('implml_type'):

            filters.append(lambda x: x.implementation and x.implementation.IMPL_TYPE_ID == kwargs.get('implml_type'))

        outputs = []

        # go through all the generation_output items with all provided filters

        # if the item passes all filters add it to the outputs list 

        for item in self.generation_output:

            passed = True

            for filter in filters:

                if not filter(item):

                    passed = False

                    continue

            if passed:

                outputs.append(item)

        return outputs

    def add_changed_refs(self, refs, implml=None):

        """

        Add changed refs to the current set of changed refs if necessary.

        If there are new refs and they are added, log also a debug message.

        """

        if self.changed_refs is None:

            return

        for ref in refs:

            self.add_changed_ref(ref, implml)

    def add_changed_ref(self, ref, implml=None):

        """

        Add changed ref to the current set of changed refs if necessary.

        If there are new refs and they are added, log also a debug message.

        """

        if self.changed_refs is None:

            return

        if ref not in self.changed_refs:

            self.changed_refs.append(ref)

            logging.getLogger('cone').debug('Added ref %s from implml %s' % (ref, implml))

    def get_refs_with_no_output(self, refs=None):

        if not refs:

            refs = self.changed_refs

        if refs:

            # create a set from the changed refs 

            # then remove the refs that have a generation output

            # and return the remaining refs as a list

            refsset = set(refs)

            implrefs = set()

            for output in self.generation_output:

                if output.implementation:

                    implrefs |= set(output.implementation.get_refs() or [])

                    if output.type == 'ref':

                        implrefs.add(output.name)

            # Add all sequence subfeatures to the list of implementation references

            dview = self.configuration.get_default_view()

            for fea in dview.get_features(list(implrefs)):

                if fea.is_sequence():

                    seqfeas = ["%s.%s" % (fea.fqr,fearef) for fearef in fea.get_sequence_parent().list_features()] 

                    implrefs |= set(seqfeas)

            refsset = refsset - implrefs

            return sorted(list(refsset))

        else:

            return []

    def get_refs_with_no_implementation(self, refs=None):

        if not refs:

            refs = self.changed_refs

        if refs:

            # create a set from the changed refs 

            # then remove the refs that have a generation output

            # and return the remaining refs as a list

            refsset = set(refs)

            implrefs = set(self.impl_set.get_implemented_refs())

            logging.getLogger('cone').debug("changed_refs: %s" % refsset)

            logging.getLogger('cone').debug("implrefs: %s" % implrefs)

            # Add all sequence subfeatures to the list of implementation references

            dview = self.configuration.get_default_view()

            for fea in dview.get_features(list(implrefs)):

                if fea.is_sequence():

                    seqfeas = ["%s.%s" % (fea.fqr,fearef) for fearef in fea.get_sequence_parent().list_features()] 

                    implrefs |= set(seqfeas)

            refsset = refsset - implrefs

            return sorted(list(refsset))

        else:

            return []

    @property

    def executed_impls(self):

        """

        List of all executed implementations (implementations for which

        a call to should_run() has returned True).

        """

        return list(self.executed)

    @property

    def features(self):

        """

        return the default view of the context configuration to access all features of the configuration.

        """

        return self.configuration.get_default_view()

    def grep_log(self, entry):

        """

        Grep the self.log entries for given entry and return a list of tuples with line (index, entry) 

        """

        return utils.grep_tuple(entry, self.log)

class MergedContext(GenerationContext):

    def __init__(self, contexts):

        self.contexts = contexts

        self.configuration = None

        self.changed_refs = []

        self.temp_features = []

        self.executed = set()

        self.impl_set = ImplSet()

        self.impl_dict = {}

        self.generation_output = []

        self.log = []

        self.log_files = []

        self.outputs = {}

        for context in contexts:

            self.changed_refs += context.changed_refs

            self.temp_features += context.temp_features

            self.configuration = context.configuration

            self.executed |= context.executed

            self.generation_output += context.generation_output

            self.log += context.log

            self.log_files.append(context.log_file)

            for output in context.generation_output:

                self.outputs[output.name] = output

            for impl in context.impl_set:

                self.impl_dict[impl.ref] = impl

        self.impl_set = ImplSet(self.impl_dict.values())

    def get_changed_refs(self, **kwargs):

        changed_refs = set()

        operation = kwargs.get('operation', 'union')

        for context in self.contexts:

            if not changed_refs:

                # set the base set from the first context

                changed_refs = set(context.changed_refs)

            else:

                if operation == 'union':

                    changed_refs |= set(context.changed_refs)

                elif operation == 'intersection':

                    changed_refs &= set(context.changed_refs)

                elif operation == 'difference':

                    changed_refs -= set(context.changed_refs)

                elif operation == 'symmetric_difference':

                    changed_refs ^= set(context.changed_refs)

                else:

                    raise exceptions.NotSupportedException('Illegal opration %s for get_changed_refs!' % operation)

        #remove temp features

        if kwargs.get('ignore_temps'):

            changed_refs = changed_refs - set(self.temp_features)

        return list(changed_refs)