#!/usr/bin/python
#
# Copyright 2017 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

# This script reads the global interface data collected by
# compute_interfaces_info_overall.py, and writes out the code which adds
# bindings for origin-trial-enabled features at runtime.

import optparse
import os
import posixpath
import sys
from collections import defaultdict, namedtuple

from code_generator import (initialize_jinja_env, normalize_and_sort_includes,
                            render_template)
from idl_reader import IdlReader
from utilities import (create_component_info_provider, write_file,
                       idl_filename_to_component)
from v8_utilities import (binding_header_filename, v8_class_name,
                          v8_class_name_or_partial, origin_trial_feature_name)

# Make sure extension is .py, not .pyc or .pyo, so doesn't depend on caching
MODULE_PYNAME = os.path.splitext(os.path.basename(__file__))[0] + '.py'

OriginTrialInterfaceInfo = namedtuple(
    'OriginTrialInterfaceInfo',
    ['name', 'v8_class', 'v8_class_or_partial', 'is_global'])


def get_install_functions(interfaces, feature_names):
    """Construct a list of V8 bindings installation functions for each feature
    on each interface.

    interfaces is a list of OriginTrialInterfaceInfo tuples
    feature_names is a list of strings, containing names of features which can
        be installed on those interfaces.
    """
    return [{
        'condition':
        'RuntimeEnabledFeatures::%sEnabled' % feature_name,
        'name':
        feature_name,
        'install_method':
        'Install%s' % feature_name,
        'interface_is_global':
        interface_info.is_global,
        'global_type_check_method':
        interface_global_type_check_method(interface_info),
        'v8_class':
        interface_info.v8_class,
        'v8_class_or_partial':
        interface_info.v8_class_or_partial,
    } for feature_name in feature_names for interface_info in interfaces]


def get_origin_trial_feature_names_from_interface(interface, runtime_features):
    feature_names = set()

    def add_if_not_none(value):
        if value:
            feature_names.add(value)

    if interface.is_partial:
        add_if_not_none(origin_trial_feature_name(interface, runtime_features))
    for operation in interface.operations:
        add_if_not_none(origin_trial_feature_name(operation, runtime_features))
    for attribute in interface.attributes:
        add_if_not_none(origin_trial_feature_name(attribute, runtime_features))
    return feature_names


def read_idl_file(reader, idl_filename):
    definitions = reader.read_idl_file(idl_filename)
    interfaces = definitions.interfaces
    includes = definitions.includes
    # There should only be a single interface defined in an IDL file. Return it.
    assert len(interfaces) == 1, (
        "Expected one interface in file %r, found %d" %
        (idl_filename, len(interfaces)))
    return (list(interfaces.values())[0], includes)


def interface_is_global(interface):
    return 'Global' in interface.extended_attributes


def interface_global_type_check_method(interface_info):
    """Generate the name of the method on ExecutionContext used to check if the
       context matches the type of the interface, which is a global.

       Returns None for non-global interfaces.
    """
    if not interface_info.is_global:
        return None

    return 'Is%s' % interface_info.name


def origin_trial_features_info(info_provider, reader, idl_filenames,
                               target_component):
    """Read a set of IDL files and compile the mapping between interfaces and
    the conditional features defined on them.

    Returns a tuple (features_for_type, types_for_feature, includes):
      - features_for_type is a mapping of interface->feature
      - types_for_feature is the reverse mapping: feature->interface
      - includes is a set of header files which need to be included in the
          generated implementation code.
    """
    features_for_type = defaultdict(set)
    types_for_feature = defaultdict(set)
    include_files = set()
    runtime_features = info_provider.component_info['runtime_enabled_features']

    for idl_filename in idl_filenames:
        interface, includes = read_idl_file(reader, idl_filename)
        feature_names = get_origin_trial_feature_names_from_interface(
            interface, runtime_features)

        # If this interface is a mixin, we don't generate V8 bindings code for
        # it.
        # TODO(crbug.com/1061995): This incorrectly ignores includes in the
        # mixin idl like "SomeInterface includes MixinInterface".
        if interface.is_mixin:
            continue

        # If this interface include another one,
        # it inherits any conditional features from it.
        for include in includes:
            assert include.interface == interface.name, (
                "'includes' interface identifier %r in file %r should be  %r" %
                (include.interface, idl_filename, interface.name))
            mixin, _ = read_idl_file(
                reader,
                info_provider.interfaces_info[include.mixin].get('full_path'))
            feature_names |= get_origin_trial_feature_names_from_interface(
                mixin, runtime_features)

        feature_names = list(feature_names)
        if feature_names:
            is_global = interface_is_global(interface)
            if interface.is_partial:
                # For partial interfaces, we need to generate different
                # |include_files| if the parent interface is in a different
                # component.
                parent_interface_info = \
                    info_provider.interfaces_info[interface.name]
                parent_interface, _ = read_idl_file(
                    reader, parent_interface_info.get('full_path'))
                is_global = is_global or interface_is_global(parent_interface)
                parent_component = idl_filename_to_component(
                    parent_interface_info.get('full_path'))
            if interface.is_partial and target_component != parent_component:
                include_files.add('bindings/%s/v8/%s' % (
                    parent_component, binding_header_filename(interface.name)))
                include_files.add(
                    'bindings/%s/v8/%s' %
                    (target_component,
                     binding_header_filename(interface.name + 'Partial')))
            else:
                include_files.add('bindings/%s/v8/%s' % (
                    target_component, binding_header_filename(interface.name)))
                # If this is a partial interface in the same component as
                # its parent, then treat it as a non-partial interface.
                interface.is_partial = False
            interface_info = OriginTrialInterfaceInfo(
                interface.name, v8_class_name(interface),
                v8_class_name_or_partial(interface), is_global)
            for feature_name in feature_names:
                features_for_type[interface_info].add(feature_name)
                types_for_feature[feature_name].add(interface_info)

    return features_for_type, types_for_feature, include_files


def origin_trial_features_context(generator_name, feature_info):
    context = {'code_generator': generator_name}

    # Unpack the feature info tuple.
    features_for_type, types_for_feature, include_files = feature_info

    # Add includes needed for cpp code and normalize.
    include_files.update([
        'core/context_features/context_feature_settings.h',
        'core/execution_context/execution_context.h',
        'core/frame/frame.h',
        'core/origin_trials/origin_trials.h',
        'platform/bindings/origin_trial_features.h',
        'platform/bindings/script_state.h',
        'platform/bindings/v8_per_context_data.h',
        'platform/runtime_enabled_features.h',
        # TODO(iclelland): Remove the need to explicitly include this; it is
        # here because the ContextFeatureSettings code needs it.
        'bindings/core/v8/v8_window.h',
    ])
    context['includes'] = normalize_and_sort_includes(include_files)

    # For each interface, collect a list of bindings installation functions to
    # call, organized by conditional feature.
    context['installers_by_interface'] = [{
        'name':
        interface_info.name,
        'is_global':
        interface_info.is_global,
        'v8_class':
        interface_info.v8_class,
        'installers':
        get_install_functions([interface_info], feature_names)
    } for interface_info, feature_names in features_for_type.items()]
    context['installers_by_interface'].sort(key=lambda x: x['name'])

    # For each conditional feature, collect a list of bindings installation
    # functions to call, organized by interface.
    context['installers_by_feature'] = [{
        'name':
        feature_name,
        'name_constant':
        'OriginTrialFeature::k%s' % feature_name,
        'installers':
        get_install_functions(interfaces, [feature_name])
    } for feature_name, interfaces in types_for_feature.items()]
    context['installers_by_feature'].sort(key=lambda x: x['name'])

    return context


def parse_options():
    parser = optparse.OptionParser()
    parser.add_option(
        '--cache-directory',
        help='cache directory, defaults to output directory')
    parser.add_option('--output-directory')
    parser.add_option('--info-dir')
    parser.add_option(
        '--target-component',
        type='choice',
        choices=['core', 'modules'],
        help='target component to generate code')
    parser.add_option('--idl-files-list')

    options, _ = parser.parse_args()
    if options.output_directory is None:
        parser.error('Must specify output directory using --output-directory.')
    return options


def generate_origin_trial_features(info_provider, options, idl_filenames):
    reader = IdlReader(info_provider.interfaces_info, options.cache_directory)
    jinja_env = initialize_jinja_env(options.cache_directory)

    # Extract the bidirectional mapping of conditional features <-> interfaces
    # from the global info provider and the supplied list of IDL files.
    feature_info = origin_trial_features_info(
        info_provider, reader, idl_filenames, options.target_component)

    # Convert that mapping into the context required for the Jinja2 templates.
    template_context = origin_trial_features_context(MODULE_PYNAME,
                                                     feature_info)

    file_basename = 'origin_trial_features_for_%s' % options.target_component

    # Generate and write out the header file
    header_text = render_template(
        jinja_env.get_template(file_basename + '.h.tmpl'), template_context)
    header_path = posixpath.join(options.output_directory,
                                 file_basename + '.h')
    write_file(header_text, header_path)

    # Generate and write out the implementation file
    cpp_text = render_template(
        jinja_env.get_template(file_basename + '.cc.tmpl'), template_context)
    cpp_path = posixpath.join(options.output_directory, file_basename + '.cc')
    write_file(cpp_text, cpp_path)


def main():
    options = parse_options()

    info_provider = create_component_info_provider(
        os.path.normpath(options.info_dir), options.target_component)
    idl_filenames = list(map(str.strip, open(options.idl_files_list)))

    generate_origin_trial_features(info_provider, options, idl_filenames)
    return 0


if __name__ == '__main__':
    sys.exit(main())