#

# 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: 

#

import logging

from optparse import OptionParser, OptionGroup

import cone_common

import time

from cone.public import api, plugin, utils, exceptions

ROOT_PATH = os.path.dirname(os.path.abspath(__file__))

VERSION = '1.0'

    parser = OptionParser(version="%%prog %s" % VERSION)

    parser.add_options(cone_common.COMMON_OPTIONS)

    parser.add_option("-c", "--configuration",\

                        dest="configuration",\

                        help="defines the name of the configuration for the action",\

                        metavar="CONFIG")

    parser.add_option("-p", "--project",\

                       dest="project",\

                       help="defines the location of current project. Default is the current working directory.",\

                       default=".",\

                       metavar="STORAGE")

    gen_group = OptionGroup(parser, 'Generate options',

                    'The generate function will create target files from a specific configuration.'\

                    'The generate will always work with read-only mode of the project, so no changes are saved to project')

    gen_group.add_option("-o", "--output",\

                   dest="output",\

                   help="defines the target folder where the files are is generated or copied",\

                   metavar="FOLDER",\

                   default="output")

    gen_group.add_option("-i", "--impl",\

                   dest="impls",\

                   action="append",

                   help=\

"""Define a Python regular expression filter for actual ImplML plugin(s) that needs to be executed. The whole path to ImplML filename is used in the regexp matching.

The impl operation can be used several times in a single command.

Example1 --impl crml => matches for any ImplML file that has a CrML string in the path.

Example2 --impl makeml$ => matches for ImplML file that has ends with MakeML string.

""",

                   metavar="IMPLS",\

                   default=None)

    gen_group.add_option("--impl-tag",\

                   dest="tags",\

                   type="string",

                   action="append",

                   help="define a tag for the implementations that are included to the output. "\

                        "A tag is name value pair and has the following format: name:value, e.g. target:rofs3."\

                        "Example --impl-tag=target:uda --impl-tag=target:content, which would include impls include both tags.",

                   metavar="TAG",\

                   default=None)

    gen_group.add_option("--impl-tag-policy",\

                   dest="tags_policy",\

                   type="string",

                   action="append",

                   help="Policy for implementation tags. May have one of the following values: --impl-tag-policy=AND, --impl-tag-policy=OR. "\

                   "Default is OR.",

                   metavar="TAGS_POLICY",\

                   default=None)

    gen_group.add_option("-s", "--set",\

                   dest="overrides",\

                   action="append",

                   type="string",

                   help="Override a ConfML reference in the execution."\

                        "The set operation can be used several times in a single command."\

                        "Example -s foo.bar=10 -s foo.fea='test'.",

                   metavar="SET",\

                   default=None)

    gen_group.add_option("--add",\

                   dest="added",\

                   action="append",

                   type="string",

                   help="Add a given configuration to the given configuration as last element."\

                        "The add operation can be used several times in a single command."\

                        "Example --add foo/root.confml --add bar/root-confml.",

                   metavar="CONF",\

                   default=None)

    gen_group.add_option("-r", "--report",\

                   dest="report",\

                   action="store",

                   type="string",

                   help="Generates a report about settings that are properly generated."\

                        "Example -r report.html.",

                   metavar="FILE",\

                   default=None)

    gen_group.add_option("-t", "--template",\

                   dest="template",\

                   action="store",

                   type="string",

                   help="Template used in report generation."\

                        "Example -t report_template.html.",

                   metavar="FILE",\

                   default=None)

    gen_group.add_option("--report-data-output",\

                   type="string",

                   help="Specifies a file where intermediary report data is generated.",

                   metavar="FILE",\

                   default=None)

    gen_group.add_option("-n", "--dryrun",\

                   dest="dryrun",\

                   action="store_true",

                   help="Executes generation without generation output.",

                   default=False)

    gen_group.add_option("--add-setting-file",\

                   dest="settings",\

                   action="append",

                   type="string",

                   help="Generate specific settings in ini format."\

                        "Example -o my_generate_settings.cfg.",

                   metavar="FILE",\

                   default=None)

    start_time = time.time()

    parser.add_option_group(gen_group)

    settinglist = [os.path.join(ROOT_PATH,'conesub_generate.cfg')]

    if options.settings:

        for setting_file in options.settings:

            settinglist.append(os.path.normpath(os.path.join(ROOT_PATH, setting_file)))            

    gset = cone_common.get_settings(settinglist)

    cone_common.handle_common_options(options, settings=gset)

    current = api.Project(api.Storage.open(options.project,"r"))

    active_root = current.get_storage().get_active_configuration()

    if not options.configuration:

        if active_root == "":

            parser.error("configuration must be given")

        else:

            logging.getLogger('cone').info('No configuration given! Using active root configuration %s' % active_root)

            options.configuration = active_root

    try:

        config  = current.get_configuration(options.configuration)

    except exceptions.NotFound:

        parser.error("No such configuration: %s" % options.configuration)

    reffilters = None

    implfilters = None

    impltags = None

    # Include possible additional configurations

    if options.added:

        for configname in options.added:

            logging.getLogger('cone').info('Adding configuration %s' % configname) 

            config.include_configuration(utils.resourceref.norm(configname))

    try:

        implfilters = (config.get_default_view().get_feature('imakerapi.cone_impls').get_value() or '').split(',')

    except exceptions.NotFound:

        implfilters = []

    # Get filters from command line if they exist => cmd overrides configuration

    if options.impls:

        implfilters = options.impls

    if options.tags and len(options.tags) > 0:

        impltags = {}

        for tag in options.tags:

            (name,value) = tag.split(':',2)

            existingvalue = impltags.get(name,[])

            existingvalue.append(value)

            impltags[name] = existingvalue

        logging.getLogger('cone').info('Tag filter %s' % impltags)

    else:

        impltags = None

    tags_policy = 'OR'

    if options.tags_policy:

        tags_policy = options.tags_policy[0]

    if len(layerdefs) > 0:

        # get the data references from given layers

        logging.getLogger('cone').info('Getting layer specific data reference from %s' % layerdefs)

        reffilters = []

            refs = _get_new_refs(reffilters, layer.list_leaf_datas())

            reffilters += refs

    # Make sure that the output folder exists

    if not os.path.exists(options.output):

        os.makedirs(options.output)

    impls = plugin.filtered_impl_set(config,implfilters)

    impls.output = options.output

    logging.getLogger('cone').info("Supported implementation file extensions: %r" % plugin.get_supported_file_extensions())

#    logging.getLogger('cone').debug('Loaded implementations:')

#    for impl in impls:

#        msg = "File '%s', impl. type '%s', class '%s', phase '%s'" % \

#              (impl.ref, impl.IMPL_TYPE_ID, type(impl).__name__, impl.invocation_phase())

#        logging.getLogger('cone').debug(msg)

    # Create temporary variables

    temp_feature_refs = impls.create_temp_features(config)

    if reffilters is not None:

        reffilters.extend(temp_feature_refs)

        logging.getLogger('cone').info('Refs from temporary variables:\n%s' % '\n'.join(temp_feature_refs))

    # ---------------

    # Generate output

    # ---------------

        context.phase = phase

    print "Generated %s to %s!" % (options.configuration, impls.output)

    # ---------------

    # Generate report

    # ---------------

    # If reporting is enabled collect data for report

    if options.report != None or options.report_data_output != None:

        logging.getLogger('cone').info('Collecting data for report.')

        logging.getLogger('cone').info('Collecting data found rep_data  %s' % rep_data)

        duration = str("%.3f" % (time.time() - start_time) )

        rep_data.set_duration( duration )

        # Save intermediary report data file if necessary

        if options.report_data_output != None:

            logging.getLogger('cone').info('Dumping report data to %s' % options.report_data_output)

            print "Dumping report data to '%s'" % options.report_data_output

            generation_report.save_report_data(rep_data, options.report_data_output)

        # Generate the report if necessary

        if options.report != None:

            print_summary(rep_data)

    if current: current.close()

def _get_new_refs(old_refs, new_refs):

    """

    Return a distinct array of refs in ``new_refs`` that are not present in ``old_refs``.

    """

    result = []

    for ref in new_refs:

        if ref not in old_refs and ref not in result:

            result.append(ref)

    return result