#

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

import logging

import pickle

from optparse import OptionParser, OptionGroup

import cone_common

import generation_report

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

VERSION     = '1.0'

logger    = logging.getLogger('cone')

def main():

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

    parser.add_options(cone_common.COMMON_OPTIONS)

    group = OptionGroup(parser, 'Report options',

                        'The report function generates a report using previously generated '\

                        'intermediary report data as input.')

    group.add_option("-i", "--input-data",\

                        action="append",\

                        help="Defines an input file for report generation. "\

                             "If specified more than once, the data of all specified "\

                             "report data files is merged.",

                        metavar="FILE",

                        default=[])

    group.add_option("-d", "--input-data-dir",\

                        help="Defines a directory containing the data files to use for "\

                             "generating the report. This is an alternative to specifying "\

                             "a number of --input-data files. The order of the data files "\

                             "is determined by the generation time stamps found in the data "\

                             "files.",

                        metavar="DIR",

                        default=None)

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

                   dest="report",\

                   action="store",

                   type="string",

                   help="Specifies the report file to create."\

                        "Example -r report.html.",

                   metavar="FILE",\

                   default="report.html")

    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)

    parser.add_option_group(group)

    (options, args) = parser.parse_args()

    cone_common.handle_common_options(options)

    if len(options.input_data) == 0 and not options.input_data_dir:

        parser.error("Input data must be specified with either --input-data or --input-data-dir")

    if len(options.input_data) > 0 and options.input_data_dir:

        parser.error("Both --input-data and --input-data-dir specified, use one or the other.")

    if options.input_data_dir and not os.path.isdir(options.input_data_dir):

        parser.error('Given --input-data-dir does not exist or is not a directory.')

    if options.input_data:

        files = options.input_data

    else:

        files = get_input_data_files(options.input_data_dir)

    if len(files) == 0:

        parser.error("At least one input data file must be specified.")

    class DataEntry(object):

        def __init__(self, label, data):

            self.label = label

            self.data = data

    # Load all data files

    data_entries = []

    for data_file in files:

        print "Loading data file '%s'" % data_file

        label = get_generation_run_label(data_file)

        data = generation_report.load_report_data(data_file)

        data_entries.append(DataEntry(label, data))

    # Sort by time stamp

    data_entries.sort(key=lambda entry: entry.data.generation_timestamp)

    # Use the first data object as the main report data

    main_entry = data_entries[0]

    # Merge the rest of the data objects into the main data

    if len(data_entries) > 1:

        # Update the generation_runs attribute of all implementations

        # in the main data

        for line in main_entry.data.lines:

            for impl in line.impls:

                impl.generation_runs = [main_entry.label]

        # Load other report data files and merge them to the main data object

        for i in xrange(len(data_entries) - 1):

            entry = data_entries[i + 1]

            print "Merging data for '%s'" % entry.label

            merge_report_data(main_entry.data, entry.data, entry.label)

    # Generate the report

    main_entry.data.report_filename = options.report

    generation_report.generate_report(main_entry.data, options.report, options.template)

    print "Generated report to '%s'" % options.report

def get_input_data_files(directory):

    files = []

    for name in os.listdir(directory):

        path = os.path.join(directory, name)

        if os.path.isfile(path):

            files.append(path)

    return files

def get_generation_run_label(datafile_path):

    filename = os.path.split(datafile_path)[1]

    filename_noext = os.path.splitext(filename)[0]

    return filename_noext

def get_feature(rep_data, ref):

    for feat in rep_data.lines:

        if feat.ref == ref:

            return feat

    raise RuntimeError("Feature '%s' not found in refs with impl" % ref)

def get_impl(rep_data, ref, impl_name):

    feat = get_feature(rep_data, ref)

    for impl in feat.impls:

        if impl.name == impl_name:

            return impl

    raise RuntimeError("Impl '%s' not found for feature '%s'" % (impl_name, ref))

def merge_report_data(data, data_to_merge, generation_run_label):

    impls_by_ref = {}

    for feat in data.lines:

        impls_dict = {}

        impls_by_ref[feat.ref] = impls_dict

        for impl in feat.impls:

            impls_dict[impl.name] = impl

    for feat in data_to_merge.lines:

        if feat.ref in impls_by_ref:

            # Feature has implementations in both report data objects

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

            impls_dict = impls_by_ref[feat.ref]

            for impl in feat.impls:

                if impl.name in impls_dict:

                    # Same implementation in both: add the generation run to merge to the impl

                    impl = get_impl(data, feat.ref, impl.name)

                    impl.generation_runs.append(generation_run_label)

                else:

                    # Implementation only in the data to merge: add to the main data

                    impl = get_impl(data_to_merge, feat.ref, impl.name)

                    impl.generation_runs = [generation_run_label]

                    feat = get_feature(data, feat.ref)

                    feat.impls.append(impl)

                    feat.nbr_impls += 1

        else:

            # Feature has implementations only in the data to merge

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

            # Add the feature and impls to the main data

            feat = get_feature(data_to_merge, feat.ref)

            for impl in feat.impls:

                impl.generation_runs = [generation_run_label]

            data.lines.append(feat)

            data.nbr_of_refs += 1

            # Remove from features with no impl in the main data

            for i, noimpl_feat in enumerate(data.ref_noimpl):

                if feat.ref == noimpl_feat.ref:

                    del data.ref_noimpl[i]

                    data.nbr_of_refs_noimpl -= 1

                    break

if __name__ == "__main__":

    main()