#!/usr/bin/python
#
# Copyright 2014 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.
"""Generates interface properties on global objects.

Concretely these are implemented as "constructor attributes", meaning
"attributes whose name ends with Constructor" (special-cased by code generator),
hence "global constructors" for short.

For reference on global objects, see:
http://heycam.github.io/webidl/#Global
http://heycam.github.io/webidl/#Exposed

Design document: http://www.chromium.org/developers/design-documents/idl-build
"""

# pylint: disable=relative-import

import itertools
import optparse
import os
import re
import sys

from collections import defaultdict
from utilities import get_file_contents
from utilities import get_first_interface_name_from_idl
from utilities import get_interface_exposed_arguments
from utilities import get_interface_extended_attributes_from_idl
from utilities import is_non_legacy_callback_interface_from_idl
from utilities import is_interface_mixin_from_idl
from utilities import read_file_to_list
from utilities import read_pickle_file
from utilities import should_generate_impl_file_from_idl
from utilities import write_file
from v8_utilities import EXPOSED_EXECUTION_CONTEXT_METHOD

interface_name_to_global_names = {}
global_name_to_constructors = defaultdict(list)

HEADER_FORMAT = """// Stub header file for {{idl_basename}}
// Required because the IDL compiler assumes that a corresponding header
// file exists for each IDL file.
"""


def parse_options():
    parser = optparse.OptionParser()
    parser.add_option('--idl-files-list', help='file listing IDL files')
    parser.add_option(
        '--global-objects-file', help='pickle file of global objects')
    options, args = parser.parse_args()

    if options.idl_files_list is None:
        parser.error(
            'Must specify a file listing IDL files using --idl-files-list.')
    if options.global_objects_file is None:
        parser.error(
            'Must specify a pickle file of global objects using --global-objects-file.'
        )

    return options, args


def flatten_list(iterable):
    return list(itertools.chain.from_iterable(iterable))


def interface_name_to_constructors(interface_name):
    """Returns constructors for an interface."""
    global_names = interface_name_to_global_names[interface_name]
    return flatten_list(global_name_to_constructors[global_name]
                        for global_name in global_names)


def record_global_constructors(idl_filename):
    full_path = os.path.realpath(idl_filename)
    idl_file_contents = get_file_contents(full_path)
    extended_attributes = get_interface_extended_attributes_from_idl(
        idl_file_contents)
    interface_name = get_first_interface_name_from_idl(idl_file_contents)

    # An interface property is produced for every non-callback interface
    # that does not have [LegacyNoInterfaceObject].
    # http://heycam.github.io/webidl/#es-interfaces
    if (not should_generate_impl_file_from_idl(idl_file_contents)
            or is_non_legacy_callback_interface_from_idl(idl_file_contents)
            or is_interface_mixin_from_idl(idl_file_contents)
            or 'LegacyNoInterfaceObject' in extended_attributes):
        return

    exposed_arguments = get_interface_exposed_arguments(idl_file_contents)
    if exposed_arguments:
        # Exposed(Arguments) case
        for argument in exposed_arguments:
            if 'RuntimeEnabled' in extended_attributes:
                raise ValueError(
                    'RuntimeEnabled should not be used with Exposed(Arguments)'
                )
            attributes = extended_attributes.copy()
            attributes['RuntimeEnabled'] = argument['runtime_enabled']
            new_constructors_list = generate_global_constructors_list(
                interface_name, attributes)
            global_name_to_constructors[argument['exposed']].extend(
                new_constructors_list)
    elif 'Exposed' in extended_attributes:
        # Exposed=env or Exposed=(env1,...) case
        exposed_value = extended_attributes.get('Exposed')
        exposed_global_names = map(str.strip,
                                   exposed_value.strip('()').split(','))
        new_constructors_list = generate_global_constructors_list(
            interface_name, extended_attributes)
        for name in exposed_global_names:
            global_name_to_constructors[name].extend(new_constructors_list)


def generate_global_constructors_list(interface_name, extended_attributes):
    extended_attributes_list = [
        name + (('=' + extended_attributes[name])
                if extended_attributes[name] else '')
        for name in ['RuntimeEnabled', 'ContextEnabled', 'SecureContext']
        if name in extended_attributes
    ]

    # Getters for these Constructors are auto-generated and considered
    # side-effect free w.r.t to V8. That is, executing the getter has no
    # JavaScript observable effect.
    extended_attributes_list.append('Affects=Nothing')

    extended_string = '[%s] ' % ', '.join(extended_attributes_list)

    attribute_string = 'attribute {interface_name}Constructor {interface_name}'.format(
        interface_name=interface_name)
    attributes_list = [extended_string + attribute_string]

    # In addition to the usual interface property, for every [NamedConstructor]
    # extended attribute on an interface, a corresponding property MUST exist
    # on the ECMAScript global object.
    # http://heycam.github.io/webidl/#NamedConstructor
    if 'NamedConstructor' in extended_attributes:
        named_constructor = extended_attributes['NamedConstructor']
        # Extract function name, namely everything before opening '('
        constructor_name = re.sub(r'\(.*', '', named_constructor)
        # Note the reduplicated 'ConstructorConstructor'
        # FIXME: rename to NamedConstructor
        attribute_string = 'attribute %sConstructorConstructor %s' % (
            interface_name, constructor_name)
        attributes_list.append(extended_string + attribute_string)

    return attributes_list


def write_global_constructors_partial_interface(interface_name, idl_filename,
                                                constructor_attributes_list):
    idl_basename = os.path.basename(idl_filename)
    basename = os.path.splitext(idl_basename)[0]
    # FIXME: replace this with a simple Jinja template
    lines = ([
        '[\n',
        '    ImplementedAs=%s\n' % basename,
        '] partial interface %s {\n' % interface_name
    ] + [
        '    %s;\n' % constructor_attribute
        # FIXME: sort by interface name (not first by extended attributes)
        for constructor_attribute in sorted(constructor_attributes_list)
    ] + ['};\n'])
    write_file(''.join(lines), idl_filename)
    header_filename = os.path.splitext(idl_filename)[0] + '.h'
    write_file(
        HEADER_FORMAT.format(idl_basename=idl_basename), header_filename)


################################################################################


def main():
    options, args = parse_options()

    # File paths of input IDL files are passed in a file, which is generated at
    # GN time. It is OK because the target IDL files are static.
    idl_files = read_file_to_list(options.idl_files_list)

    # Output IDL files (to generate) are passed at the command line, since
    # these are in the build directory, which is determined at build time, not
    # GN time.
    # These are passed as pairs of GlobalObjectName, global_object.idl
    interface_name_idl_filename = [(args[i], args[i + 1])
                                   for i in range(0, len(args), 2)]

    interface_name_to_global_names.update(
        read_pickle_file(options.global_objects_file))

    for idl_filename in idl_files:
        record_global_constructors(idl_filename)

    # Check for [Exposed] / [Global] mismatch.
    known_global_names = EXPOSED_EXECUTION_CONTEXT_METHOD.keys()
    exposed_global_names = frozenset(global_name_to_constructors)
    if not exposed_global_names.issubset(known_global_names):
        unknown_global_names = exposed_global_names.difference(
            known_global_names)
        raise ValueError('The following global names were used in '
                         '[Exposed=xxx] but do not match any global names: %s'
                         % list(unknown_global_names))

    # Write partial interfaces containing constructor attributes for each
    # global interface.
    for interface_name, idl_filename in interface_name_idl_filename:
        constructors = interface_name_to_constructors(interface_name)
        write_global_constructors_partial_interface(interface_name,
                                                    idl_filename, constructors)


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