# Copyright (c) 2009 Symbian Foundation Ltd
# This component and the accompanying materials are made available
# under the terms of the License "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:
# Symbian Foundation Ltd - initial contribution.
# 
# Contributors:
#
# Description:
# Walk all nodes in the dependency graph to create a dependency report.

"""Walk a dependency graph to find dependencies for a particular set of
components. This script uses the output of build_graph.py to trace
dependencies.

The directory_list refer to diretories in the source tree for which
you wish to trace dependencies. The script will find all components
in the graph file under these directories and trace dependencies from
that point.
"""

from optparse import OptionParser
from _common import Node

import sys
import pickle
import logging

__author__ = 'James Aley'
__email__ = 'jamesa@symbian.org'
__version__ = '1.0'

_LOG_FORMAT = '%(levelname)s: %(message)s'
logging.basicConfig(format=_LOG_FORMAT, level=logging.WARNING, stream=sys.stdout)

# Internalized graph object
graph = {}

# Report formatting
_REPORT_HEADER = """// Generated by get_deps.py
//
// Dependency information for:
//
%s

"""

_DEPENDENCY_FORMAT = """
// Required components:

%s

"""

_MISSING_FORMAT = """
// The following binary objects were referenced from the build files for
// components required by your specified root components. However, there
// were no build files for these objects found in the source tree parsing,
// so dependencies for them may be missing in the above listing.

%s

"""

def load_graph(path):
    """Return the internalized graph dictionary object.
    """
    graph_file = None
    graph_loaded = {}

    try:
        graph_file = open(path, 'rb')
    except IOError, e:
        logging.critical('Unable to open graph from file: %s: %s' % (path, repr(e)))
        exit(1)
    try:
        graph_loaded = pickle.load(graph_file)
    except Exception, e:
        logging.critical('File %s does not contain a valid graph: %s' % (path, repr(e)))
    return graph_loaded

def find_roots(root_dirs):
    """Return a list of root nodes from the graph for tracing, based on
    the specified component directories in the root_dirs list.
    """
    roots = []
    for root in root_dirs:
        for node in graph.keys():
            if node.startswith(root.lower()):
                if node not in roots:
                    roots.append(node)
    return roots

def trace(root, visited = set()):
    """Return a list of components required to support root.
    """
    node = graph[root]
    visited |= set([node.node_path]) | set(node.dependencies)
    for dep in node.dependencies:
        if dep not in visited:
            return trace(dep, visited)
    return visited

def unresolved(deps):
    """Return a set of components with unknown dependencies from a 
    provided list of node names.
    """
    unresolved = set()
    for dep in deps:
        node = graph[dep]
        unresolved |= set(node.unresolved)
    return unresolved

def report(out_path, roots, dependencies, missing):
    """Output the dependency information to file.
    """
    # open report file
    out_file = None
    try:
        out_file = open(out_path, 'w')
    except IOError, e:
        logging.critical('Unable to write report: %s' % (repr(e)))
        exit(1)

    # easier to read report with these sorted
    roots.sort()
    dependencies.sort()
    missing.sort()

    # format report
    formatted_header = _REPORT_HEADER % ('\n'.join(['// %s' % (line, ) for line in roots]), )
    formatted_body = _DEPENDENCY_FORMAT % ('\n'.join(dependencies))
    formatted_missing = _MISSING_FORMAT % ('\n'.join(['// %s' % (line, ) for line in missing]), )

    # write report
    out_file.write(formatted_header)
    out_file.write(formatted_body)
    out_file.write(formatted_missing)

    out_file.close()

if __name__ == '__main__':
    # Options config
    parser = OptionParser()
    parser.set_description(__doc__)
    parser.set_usage('python get_deps.py [options] directory_list')
    parser.add_option('-g', '--graph', dest='graph_file', 
                      help='File name to write the graph to.', 
                      metavar='GRAPH_FILE', default='dependencies.graph')
    parser.add_option('-o', '--output', dest='output_file',
                      help='File to write the dependency report to.',
                      metavar='OUT_FILE', default='dependencies.txt')
    (options, args) = parser.parse_args()

    # Intenalize the graph file
    print 'Loading graph from %s' % (options.graph_file, )
    graph = load_graph(options.graph_file)

    # Extract relevant slices and merge dependencies
    roots = find_roots(args)
    print 'Tracing dependencies for %d components under %s' % (len(roots), ', '.join(args))
    deps = set()
    for root in roots:
        deps |= trace(root)
    print 'Dependency graph slice yields %d of %d components.' % (len(deps), len(graph))
    unresolved_deps = unresolved(deps)
    print 'Component dependencies for %d binaries are unresolved' % (len(unresolved_deps, ))

    # Write the report to the output file
    report(options.output_file, roots, list(deps), list(unresolved_deps))
    print 'Report written to: %s' % (options.output_file, )