#

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

import logging

from optparse import OptionParser, OptionGroup

import cone_common

from cone.public import api, utils, exceptions

VERSION = '1.0'

logger    = logging.getLogger('cone')

class MergeFailedException(Exception):

    """

    Exception raised if the merge failed for some reason.

    """

    pass

class MergePolicy(object):

    """

    Merge policy constants.

    """

    #: Replace/add files from the source layer into the

    #: target layer, preserving files in the target layer

    #: that do not exist in the source layer

    REPLACE_ADD = 'replace-add'

    #: Overwrite the entire target layer, so that it contains

    #: only the contents of the source layer

    OVERWRITE_LAYER = 'overwrite-layer'

    ALL = (REPLACE_ADD, OVERWRITE_LAYER)

    @classmethod

    def is_valid(cls, policy):

        return policy in cls.ALL

def get_new_layer_name(oldname,rootconfig):

    newpath = utils.resourceref.get_path(oldname)

    newpath+= "_" + utils.resourceref.remove_ext(utils.resourceref.get_filename(rootconfig))

    newpath+= "/" + utils.resourceref.get_filename(oldname)

    return newpath

def merge_configuration_layer(sourceconfig, targetconfig, merge_policy):

    """

    Merge the contents of the source layer into the target layer.

    @param sourceconfig: Source layer root configuration object.

    @param targetconfig: Target layer root configuration object.

    @param merge_policy: The used layer merge policy.

    """

    # If policy tells to entirely overwrite the layer, remove all

    # resources from the layer first

    if merge_policy == MergePolicy.OVERWRITE_LAYER:

        # Remove configurations from the layer root

        confs = targetconfig.list_configurations()

        for conf in confs:

            targetconfig.remove_configuration(conf)

        # Remove all related resources

        layerobj = targetconfig.get_layer()

        # Round one: remove all files

        resources = layerobj.list_all_related(empty_folders=False)

        for res in resources: layerobj.delete_resource(res)

        # Round two: remove any remaining empty directories

        resources = layerobj.list_all_related(empty_folders=True)

        for res in resources: layerobj.delete_folder(res)

    # Find all ConfML files

    confml_resources = sourceconfig.list_configurations()

    # Find all other related files and folders (content/, doc/ etc.)

    layerobj = sourceconfig.get_layer()

    targetobj = targetconfig.get_layer()

    other_resources = layerobj.list_all_related(empty_folders=True)

    # Copy the resources to the target configuration

    for res_path in confml_resources + other_resources:

        try:

            rres = layerobj.open_resource(res_path,"rb")

            wres = targetobj.open_resource(res_path,"wb")

            print "Copying %s" % rres.path

            logger.info('Copying layer resource %s to %s' % (rres.path, wres.path))

            wres.write(rres.read())

            wres.close()

            rres.close()

        except exceptions.NotResource:

            # If it isn't a resource (file), it's a folder

            targetobj.create_folder(res_path)

    # Remove all configurations from the target layer root

    already_included = targetconfig.list_configurations()

    for confml_path in already_included:

        targetconfig.remove_configuration(confml_path)

    # Include them back

    for confml_path in already_included:

        targetconfig.include_configuration(confml_path)

    # Include all added configurations

    for confml_path in confml_resources:

        if confml_path not in already_included:

            print "Including %s in layer root %s" % (confml_path, targetconfig.path)

            targetconfig.include_configuration(confml_path)

def find_layers_to_merge(layer_indices, rename, sourceconfig, targetconfig):

    """

    Return a list of layers to merge.

    @param layer_indices: List of layer indices to merge, can also be

        None to indicate that all layers are to be merged.

    @param rename: True if the layers should be renamed in the target

        config, False if not.

    @return: A list of tuples (layer_root, target_layer_root), where

        layer_root is the path to the layer root in the source

        configuration and target_layer_root the one in the target

        configuration.

    """

    # Get a list of all configurations to merge

    if layer_indices is None:

        mergeconfigs = sourceconfig.list_configurations()

    else:

        mergeconfigs = sort_mergeconfigs(layer_indices, sourceconfig.list_configurations())

    result = []

    if rename:

        for source_path in mergeconfigs:

            target_path = get_new_layer_name(source_path, targetconfig.path)

            result.append((source_path, target_path))

    else:

        for source_path in mergeconfigs:

            result.append((source_path, source_path))

    return result

def sort_mergeconfigs(layers, sourceconfigs):

    """

    Return a correctly sorted list of source configuration layers.

    @param layers: List of the indices of the layers to merg. Can be None, in

        which case all layers are returned.

    @param sourceconfigs: List of all configuration layer root paths in the

        source project.

    @return: List of configuration layer root paths.

    """

    sorted_configs = [None for _ in xrange(len(sourceconfigs))]

    for layer in layers:

        sorted_configs[layer]=sourceconfigs[layer]

    sorted_configs = filter(lambda x: x != None, sorted_configs)

    return sorted_configs

def merge_config_root_to_config_root(source_project, target_project,

                                     source_config, target_config,

                                     layer_indices, rename,

                                     merge_policy):

    """

    Merge the source configuration root to the target configuration root.

    @param layer_indices: List of layer indices to specify the layers

        to merge, can be None.

    @param rename: If True, the merged layers are renamed based on the

        name of the target configuration root.

    @param merge_policy: The used merge policy.

    """

    def get_active_root_if_necessary(project, configuration, name):

        if configuration:

            return configuration

        else:

            active_root = project.get_storage().get_active_configuration()

            if active_root == "":

                raise MergeFailedException("No %s configuration given and the project does not have an active root" % name)

            else:

                return active_root

    target_root = get_active_root_if_necessary(target_project, target_config, 'target')

    source_root = get_active_root_if_necessary(source_project, source_config, 'source')

    print "Target config:  %s" % target_root

    print "Source config:  %s" % source_root

    try:

        source_config = source_project.get_configuration(source_root)

    except exceptions.NotFound:

        raise MergeFailedException("Configuration root '%s' not found in source project" % source_root)

    # Create or get the target configuration root

    try:

        target_config = target_project.get_configuration(target_root)

    except exceptions.NotFound:

        logger.info('Creating new root configuration %s' % (target_config))

        target_config  = target_project.create_configuration(target_config)

        for sourcelayer_path in source_config.list_configurations():

            sourcelayer = source_config.get_configuration(sourcelayer_path)

            sourcelayer_path = sourcelayer.path

            if target_config.get_storage().is_resource(sourcelayer.path):

                logger.info('Including layer %s to root %s' % (sourcelayer_path, target_config.path))

                target_config.include_configuration(sourcelayer_path)

            else:

                logger.info('Creating new layer %s to root %s' % (sourcelayer_path, target_config.path))

                target_config.create_configuration(sourcelayer_path)

    # Collect a correctly sorted list of all layer paths to merge

    layers_to_merge = find_layers_to_merge(

        layer_indices   = layer_indices,

        rename          = rename,

        sourceconfig    = source_config,

        targetconfig    = target_config)

    print "Merging %d layer(s)..." % len(layers_to_merge)

    # Merge the layers

    for source_path, target_path in layers_to_merge:

        print "Merging %s -> %s" % (source_path, target_path)

        source_layer = source_project.get_configuration(source_path)

        if source_path != target_path:

            try:

                target_config.remove_configuration(source_path)

            except exceptions.NotFound:

                pass

            target_config.create_configuration(target_path)

        # Get or create the target configuration layer

        try:

            target_layer = target_config.get_configuration(target_path)

        except exceptions.NotFound:

            logger.info('Creating new layer configuration %s' % (target_path))

            target_layer = target_config.create_configuration(target_path)

        merge_configuration_layer(source_layer, target_layer, merge_policy)

def main(argv=sys.argv):

    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 target 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")

    group = OptionGroup(parser, 'Merge options',

                        'The merge functionality is meant to merge configurations/layers '

                        'from a remote project (defined with -r) to the current project (defined with -p). '

                        'Default value for the current project is the currently working directory. '

                        'A project can be either a folder or a cpf/zip file. There are two ways to '

                        'use merge: merge configuration roots (multiple layers), or specific layers. '

                        'See the ConE documentation for details and examples.')

    group.add_option("-r", "--remote",\

                   dest="remote",\

                   help="defines the location of remote storage",\

                   metavar="STORAGE")

    group.add_option("-s", "--sourceconfiguration",\

                        dest="sourceconfiguration",\

                        help="defines the name of the remote configuration inside the remote storage for the merge action. "\

                             "Default is the active root of the remote project.",\

                        metavar="CONFIG")

    group.add_option("--sourcelayer",

                     help="Defines a specific layer to use as the layer to merge "\

                          "from the remote project. Must be the layer root (ConfML file)."\

                          "For example: --sourcelayer assets/somelayer/root.confml",

                     metavar="LAYER_ROOT",

                     default=None)

    group.add_option("--targetlayer",

                     help="Defines a specific layer (root) to use as the layer to merge "\

                          "into the target project. Must be the layer root (ConfML file)."\

                          "For example: --targetlayer assets/somelayer/root.confml",

                     metavar="LAYER_ROOT",

                     default=None)

    group.add_option("--rename",\

                        action="store_true", 

                        dest="rename",\

                        help="defines that the merged layers need to be renamed",

                        default=False)

    group.add_option("--all",\

                        action="store_true", 

                        dest="all",\

                        help="Defines that the entire configuration (all layers) needs to be merged. "\

                             "This has no effect when merging layers directly using --sourcelayer and --targetlayer.",

                        default=False)

    group.add_option("-l", "--layer",\

                   dest="layers",\

                   type="int",

                   action="append",

                   help="Define the layers of the source configuration that are included to merge action. "\

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

                        "Note that this can only be used when merging configuration roots, not "\

                        "specific layers using --sourcelayer and --targetlayer. "\

                        "Example -l -1 --layer=-2, which would append a layers -1 and -2 to the layers => layers = -1,-2",

                   metavar="LAYERS",\

                   default=None)

    group.add_option("--merge-policy",

                     help="Specifies the merge policy to use when merging layers. "\

                          "Possible values:                                                         "\

                          "replace-add - Add/replace files from source layer, but leave other files in the target as they are. "\

                          "                                                         "\

                          "overwrite-layer - Overwrite the entire layer (remove all previous content).",

                     default=MergePolicy.REPLACE_ADD)

    parser.add_option_group(group)

    (options, _) = parser.parse_args(argv)

    cone_common.handle_common_options(options)

    # Check the passed options

    if not MergePolicy.is_valid(options.merge_policy):

        parser.error("Invalid merge policy: %s\nMust be one of %s" % (options.merge_policy, '\n'.join(MergePolicy.ALL)))

    if not options.remote: parser.error("Remote project must be given")

    if options.layers and (options.sourcelayer or options.targetlayer):

        parser.error("Specifying layer indices using --layer is not supported when using --sourcelayer or --targetlayer!")

    if options.sourcelayer and not options.targetlayer:

        parser.error("Merging a layer into a configuration is not supported at the moment!")

    if options.sourcelayer and not options.sourcelayer.lower().endswith('.confml'):

        parser.error("Source layer root should be a .confml file")

    if options.targetlayer and not options.targetlayer.lower().endswith('.confml'):

        parser.error("Target layer root should be a .confml file")

    if not options.sourcelayer and options.targetlayer:

        parser.error("Cannot merge a configuration into a layer!")

    # If layers for configuration root merging are not specifically given,

    # the default is the last layer

    if options.layers is None:

        options.layers = [-1]

    target_project = api.Project(api.Storage.open(options.project,"a", username=options.username, password=options.password))

    source_project = api.Project(api.Storage.open(options.remote,"r", username=options.username, password=options.password))

    print "Target project: %s" % options.project

    print "Source project: %s" % options.remote

    target_config = None

    try:

        if options.sourcelayer and options.targetlayer:

            print "Target layer:   %s" % options.targetlayer

            print "Source layer:   %s" % options.sourcelayer

            try:

                source_config = source_project.get_configuration(options.sourcelayer)

            except exceptions.NotFound:

                raise MergeFailedException("Layer root '%s' not found in source project" % options.sourcelayer)

            try:

                target_config = target_project.get_configuration(options.targetlayer)

            except exceptions.NotFound:

                logger.info('Creating new layer %s' % (options.targetlayer))

                target_config  = target_project.create_configuration(options.targetlayer)

            print "Merging layers..."

            merge_configuration_layer(source_config, target_config, options.merge_policy)

        else:

            # Merging a configuration root into a configuration root

            if options.all: layer_indices = None

            else:           layer_indices = utils.distinct_array(options.layers)

            merge_config_root_to_config_root(

                source_project = source_project,

                target_project = target_project,

                source_config  = options.sourceconfiguration,

                target_config  = options.configuration,

                layer_indices  = layer_indices,

                rename         = options.rename,

                merge_policy   = options.merge_policy)

    except MergeFailedException, e:

        print "Could not merge: %s" % e

        sys.exit(2)

    else:

        # Merge successful, so save the target configuration and project

        # to persist the changes

        if target_config: target_config.save()

        target_project.save()

    target_project.close()

    source_project.close()

if __name__ == "__main__":

    main()