#

# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

# All rights reserved.

# This component and the accompanying materials are made available

# under the terms of "Eclipse Public License v1.0"

# which accompanies this distribution, and is available

# at the URL "http://www.eclipse.org/legal/epl-v10.html".

#

# Initial Contributors:

# Nokia Corporation - initial contribution.

#

# Contributors:

#

# Description:

#

## 

# @author <author>

'''

ConE plugin to run external applications/tools with given parameters in .commandml file. Notice that values can be also

fecthed from ConfML to maximize portability and minimize maintenance.

'''

import re

import os

import logging

import types

import pkg_resources

import subprocess

from cone.public import plugin,utils

def get_folder_set(folder):

    """

    Get a set object containing all files of given folder

    @param folder: the folder to create set for

    @return: a python set 

    """

    fileset = set()

    for (root, _, filenames) in os.walk(folder):

        for filename in filenames:

            fname = utils.relpath(os.path.join(root,filename), folder)

            fileset.add(fname)

    return fileset

class CommandImpl(plugin.ImplBase):

    """

    Plugin implementation class. 

    """

    IMPL_TYPE_ID = "commandml"

    def __init__(self,ref,configuration, reader):

        """

        Overloading the default constructor

        """

        plugin.ImplBase.__init__(self,ref,configuration)###3

        self.desc = ""

        self.logger = logging.getLogger('cone.commandml(%s)' % self.ref)

        self.reader = reader

        for element in self.reader.elements:

            element.set_logger(self.logger)

    def generate(self, context=None):

        """

        Generate the given implementation.

        """

        self.create_output(context)

        return 

    def generate_layers(self,layers):

        """

        Generate the given Configuration layers.

        """

        self.logger.info('Generating layers %s' % layers)

        self.create_output(layers)

        return 

    def create_output(self, context, layers=None):

        """

        Function to generate output files.

        """

        self.context = context

        tmpDict = self.__create_helper_variables()

        # Get the contents of output folder before the generation

        outset_before = get_folder_set(context.output)

        for element in self.reader.elements:

            #Element can be either command or condition.

            element.set_logger(self.logger)

            element.execute(context, tmpDict)        

        # Get the contents of output folder after the generation 

        # and get the new files created by the set difference.

        # NOTE! this does not recognize files outside output folder!

        outset_after = get_folder_set(context.output)

        outset = outset_after - outset_before

        for outfile in outset:

            context.add_file(outfile, implementation=self)

        return

    def __create_helper_variables(self):

        """

        Internal function to create dictionary containing most often used ConE "environment" variables.

        """        

        tmp = {}

        tmp["%CONE_OUT%"] = os.path.join(self.context.output, self.output).rstrip('\\')

        tmp["%CONE_OUT_ABSOLUTE%"] = os.path.abspath(os.path.join(self.context.output, self.output)).rstrip('\\')

        return tmp    

    def has_ref(self, refs):

        """

        @returns True if the implementation uses the given ref as input value.

        Otherwise return False.

        """

        # return true for now so that content copying is not filtered 

        return None

class CommandImplReader(plugin.ReaderBase):

    """

    Parses a single commandml file

    """ 

    NAMESPACE = 'http://www.s60.com/xml/commandml/1'

    NAMESPACE_ID = 'commandml'

    ROOT_ELEMENT_NAME = 'commandml'

    FILE_EXTENSIONS = ['commandml']

    def __init__(self):

        """

        Constructor

        """

        self.output_dir = None

        self.input_dir = None

        self.namespaces = [self.NAMESPACE]

        self.dview = None

        self.elements = []

        self.tags = None

    @classmethod

    def read_impl(cls, resource_ref, configuration, etree):

        reader = CommandImplReader()

        reader.set_default_view(configuration.get_default_view())

        reader.from_etree(etree)

        impl = CommandImpl(resource_ref, configuration, reader)

        if reader.tags:

            impl.set_tags(reader.tags)

        return impl

    @classmethod

    def get_schema_data(cls):

        return pkg_resources.resource_string('commandplugin', 'xsd/commandml.xsd')

    def set_default_view(self, dview):

        """

        Function to set default view that is needed when solving out ConfML reference information

        """        

        self.dview = dview

    def from_etree(self, etree):

        """

        Parser function for commandml element.

        """

        self.parse_tree(etree)

    def parse_tree(self, etree):

        """

        General parse function for condition and command elements.

        """        

        elements = list(etree)

        for element in elements:

            if element.tag == "{%s}condition" % self.namespaces[0]:

                self.elements.append(self.parse_condition(element))

            elif element.tag == "{%s}command" % self.namespaces[0]:

                self.elements.append(self.parse_command(element))

            else:

                pass

        self.tags = self.parse_tags(etree)

    def parse_condition(self, etree):

        """

        Parse function for condition element.

        """        

        condition = Condition()

        condition.set_condition(etree.get("value"))

        condition.set_commands(self.parse_commands(etree))

        condition.set_default_view(self.dview)

        return condition                                   

    def parse_commands(self,etree):

        """

        Parser function for commands.

        """

        commands = []

        for com_elem in etree.findall("{%s}command" % self.namespaces[0]):

            commands.append(self.parse_command(com_elem))

        return commands

    def parse_command(self,etree):

        """

        Parser function for single command.

        """

        cmd = Command()

        cmd.set_executable(etree.get("executable"))

        cmd.set_shell(etree.get("shell"))

        cmd.set_bufsize(etree.get("bufsize"))

        cmd.set_cwd(etree.get("cwd")) 

        cmd.set_all_envs(etree.get("env"))

        cmd.set_all_arguments(self.parse_arguments(etree))

        cmd.set_all_pipes(self.parse_pipes(etree))

        cmd.set_filters(self.parse_filters(etree))

        cmd.set_default_view(self.dview)

        return cmd

    def parse_arguments(self,etree):

        """

        Parser function for command's arguments.

        """

        arguments = []

        for argument in etree.findall("{%s}argument" % self.namespaces[0]):

            value = argument.get("value")

            if value:

                arguments.append(value)

        return arguments

    def parse_pipes(self,etree):

        """

        Parser function for command's pipes.

        """

        pipes = {}

        for argument in etree.findall("{%s}pipe" % self.namespaces[0]):

            name = argument.get("name")

            value = argument.get("value")

            if name:

                pipes[name] = value        

        return pipes

    def parse_filters(self,etree):

        """

        Parser function for command's filters.

        """

        filters = []

        for argument in etree.findall("{%s}filter" % self.namespaces[0]):

            f = Filter()

            f.set_severity(argument.get("severity"))

            f.set_condition(argument.get("condition"))

            f.set_input(argument.get("input"))

            f.set_formatter(argument.get("formatter"))

            filters.append(f)

        return filters

    def parse_tags(self,etree):

        tags = {}

        for tag in etree.getiterator("{%s}tag" % self.namespaces[0]):

            tagname = tag.get('name','')

            tagvalue = tag.get('value')

            values = tags.get(tagname,[])

            values.append(tagvalue)

            tags[tagname] = values

        return tags

class Condition(object):

    """

    Condition class is a simple wrapper class for commands so that commands are executed

    only if condition is True. Otherwise class does nothing. Class has similar interface 

    than Command class so that they can be used similar way from plugin perspective. 

    """

    def __init__(self):

        self.condition = None

        self.commands = []

        self.logger = None

        self.dview = None

    def set_condition(self, condition):

        self.condition = condition

    def set_default_view(self, dview):

        self.dview = dview

    def set_commands(self, commands):

        self.commands = commands

    def set_logger(self, logger):

        self.logger = logger

        for cmd in self.commands:

            cmd.set_logger(logger)        

    def add_command(self, command):

        self.commands.append(command)

    def execute(self, context, replaceDict=None):

        if self._solve_condition(self.condition, context):

            #Condition is true -> running command

            for command in self.commands:                

                command.execute(context, replaceDict)

        else:

            self.logger.info("Ignoring %s because it is evaluated as False." % self.condition)

    def _solve_condition(self, condition_str, context):

        """

        Internal function to handle condition

        """

        if condition_str != "":

            #Expanding ConfML information

            modstr = utils.expand_delimited_tokens(

                condition_str,

                lambda ref, index: repr(context.configuration.get_default_view().get_feature(ref).get_value()))

            return eval(modstr)

        else:

            #Empty condition is true always.

            return True

class Command(object):

    """

    Command is a class that executes actual commands. It provides ways to handle input, output and error 

    streams and to control execution parameters.

    """

    def __init__(self):

        """

        Constructor

        """        

        self.executable = None

        self.shell = False

        self.bufsize = 0

        self.cwd = None

        self.envs = None

        self.arguments = []

        self.streams = {}

        self.filters = []

        self.logger = None

        self.dview = None

    def set_executable(self, executable):

        self.executable = executable

    def set_shell(self, shell):

        if shell and shell.lower() in ('true', 'yes', '1', 1, True):

            self.shell = True

        else:

            self.shell = False

    def set_bufsize(self, bufsize):

        if bufsize:

            self.bufsize = int(bufsize)

    def set_cwd(self, cwd):

        self.cwd = cwd

    def set_all_envs(self, envs):

        self.envs = envs

    def set_default_view(self, dview):

        self.dview = dview

    def set_env(self, name, value):

        self.envs[name] = value

    def set_all_arguments(self, args):

        self.arguments = args

    def get_arguments_string(self):

        """

        Function to return arguments as a string

        """

        arg_string = ""        

        for value in self.arguments:            

            arg_string += value

            arg_string += " "                

        return arg_string

    def get_pipe(self, name, mode='w'):

        """

        Function to return pipe based on the pipe name in requested mode.

        """

        if self.pipes.has_key(name) and isinstance(self.pipes[name], types.IntType):

        #Subprocess pipe

            return self.pipes[name]

        elif self.pipes.has_key(name) and isinstance(self.pipes[name], types.StringType):            

            return file(self.pipes[name], mode)

        else:

            return None

    def set_streams(self, stdin, stdout, stderr):

        self.streams["stdin"] = stdin

        self.streams["stdout"] = stdout

        self.streams["stderr"] = stderr

    def get_streams(self, name, mode="r"):

        if self.streams.has_key(name) and self.streams[name]:

        #OK for streams set with subprocess.PIPE

            return self.streams[name]

        else:

        #For file objects

            return self.get_pipe(name, mode)

    def set_filters(self, filters):

        self.filters = filters

        for f in self.filters:

            f.set_command(self)

    def get_filters(self):

        return self.filters

    def set_argument(self, value):

        self.arguments.append(value)

    def set_all_pipes(self, pipes):

        for pipe in pipes.keys():

            self.set_pipe(pipe, pipes[pipe])

    def set_pipe(self, name, value):

        if value == "PIPE":

            #Creating new stream for this.

            self.pipes[name] = subprocess.PIPE

        elif value == "STDOUT":

            self.pipes[name] = subprocess.STDOUT

        else:

            #Setting filename

            self.pipes[name] = value

            #self.pipes[name] = file(value, 'w')

    def handle_filters(self):

        """

        """

        for filter in self.filters:

            filter.report(self.logger)

    def execute(self, context, replaceDict=None):

        self.dview = context.configuration.get_default_view()

        self.solve_refs()

        try:

            if self.envs:   env_dict = eval(self.envs)

            else:           env_dict = None

        except Exception, e:

            raise RuntimeError("Failed to evaluate env dictionary: %s: %s" % (e.__class__.__name__, e))

        exit_code = 0

        try:

            try:

                if self.cwd is not None:

                    cwd = self.__replace_helper_variables(self.cwd, replaceDict)

                else:

                    cwd = self.cwd

                command_str = self.executable + " " + self.__replace_helper_variables(self.get_arguments_string(), replaceDict)

                self.logger.info("Running command: \"%s\"" % command_str)

                self.logger.info("with args: shell=%s envs=%s cwd=%s bufsize=%s stdin=%s stdout=%s stderr=%s" \

                                 % (self.shell, self.envs, cwd, self.bufsize, \

                                    self.get_pipe("stdin", 'r'),self.get_pipe("stdout"), self.get_pipe("stderr")))

                pid = subprocess.Popen(command_str, shell=self.shell, env=env_dict, cwd=cwd,\

                                          bufsize=self.bufsize, stdin = self.get_pipe("stdin", 'r'),\

                                          stdout = self.get_pipe("stdout"), stderr = self.get_pipe("stderr"))

                #Waiting for process to complete

                retcode = pid.wait()

                #Storing stream information for possible further processing.

                self.set_streams(pid.stdin, pid.stdout, pid.stderr)

                if retcode < 0:

                    self.logger.error("Child was terminated by signal %s" % (-retcode))

                else:

                    self.logger.info("Child returned: %s" % retcode)

            except OSError, e:

                self.logger.error("Execution failed: %s", repr(e))            

            self.handle_filters()

        except Exception,e:

            utils.log_exception(self.logger, "Failed to execute command: %s" % e)

    def set_logger(self, logger):

        self.logger = logger        

    def __replace_helper_variables(self, inputstr, dictionary):

        retstr = inputstr

        for key in dictionary.keys():

            retstr = retstr.replace(key, dictionary[key])            

        return retstr

    def solve_refs(self):

        """

        Function to solve references just before generation.

        """

        self.executable = self.__solve_ref(self.executable)

        self.shell = self.__solve_ref(self.shell)

        self.bufsize = self.__solve_ref(self.bufsize)

        self.cwd = self.__solve_ref(self.cwd)

        self.envs = self.__solve_ref(self.envs)

        for argument in self.arguments:

            self.arguments[self.arguments.index(argument)] = self.__solve_ref(argument) 

        for pipe in self.pipes.keys():

            self.pipes[pipe] = self.__solve_ref(self.pipes[pipe])

    def __solve_ref(self, inputstr):

        """

        Internal function to solve whether input is ref or just normal input string. 

        For refs actual ConfML value is resolved and returned. Non-refs are returned 

        as such.

        """        

        if inputstr and isinstance(inputstr, types.StringType):

            return utils.expand_refs_by_default_view(inputstr, self.dview)

        else:

            return inputstr

class Filter(object):

    """