#!/usr/bin/env 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.

from blinkbuild.name_style_converter import NameStyleConverter
from core.css.field_alias_expander import FieldAliasExpander
import json5_generator
from make_origin_trials import OriginTrialsWriter
from name_utilities import enum_key_for_css_property, id_for_css_property
from name_utilities import enum_key_for_css_property_alias, id_for_css_property_alias

# These values are converted using CSSPrimitiveValue in the setter function,
# if applicable.
PRIMITIVE_TYPES = [
    'short', 'unsigned short', 'int', 'unsigned int', 'unsigned', 'float',
    'LineClampValue'
]


def validate_property(prop):
    name = prop['name']
    has_method = lambda x: x in prop['property_methods']
    assert prop['is_property'] or prop['is_descriptor'], \
        'Entry must be a property, descriptor, or both [%s]' % name
    assert not prop['interpolable'] or prop['is_longhand'], \
        'Only longhands can be interpolable [%s]' % name
    assert not has_method('ParseSingleValue') or prop['is_longhand'], \
        'Only longhands can implement ParseSingleValue [%s]' % name
    assert not has_method('ParseShorthand') or prop['is_shorthand'], \
        'Only shorthands can implement ParseShorthand [%s]' % name
    assert not prop['field_template'] or prop['is_longhand'], \
        'Only longhands can have a field_template [%s]' % name
    assert not prop['valid_for_first_letter'] or prop['is_longhand'], \
        'Only longhands can be valid_for_first_letter [%s]' % name
    assert not prop['valid_for_cue'] or prop['is_longhand'], \
        'Only longhands can be valid_for_cue [%s]' % name
    assert not prop['valid_for_marker'] or prop['is_longhand'], \
        'Only longhands can be valid_for_marker [%s]' % name
    assert not prop['valid_for_highlight'] or prop['is_longhand'], \
        'Only longhands can be valid_for_highlight [%s]' % name


def validate_alias(alias):
    name = alias['name']
    is_internal = lambda x: x['name'].original.startswith('-internal-')
    assert not alias['runtime_flag'], \
        'Runtime flags are not supported for aliases [%s]' % name
    assert not is_internal(alias), \
        'Internal aliases not supported [%s]' % name


def validate_field(field):
    name = field['name']
    assert not field['mutable'] or field['field_template'] == 'monotonic_flag',\
        'mutable requires field_template:monotonic_flag [%s]' % name


class CSSProperties(object):
    def __init__(self, file_paths):
        assert len(file_paths) >= 3, \
            "CSSProperties at least needs both css_properties.json5, \
            computed_style_field_aliases.json5 and \
            runtime_enabled_features.json5 to function"

        # computed_style_field_aliases.json5. Used to expand out parameters used
        # in the various generators for ComputedStyle.
        self._field_alias_expander = FieldAliasExpander(file_paths[1])

        # _alias_offset must be a power of 2.
        self._alias_offset = 1024
        # 0: CSSPropertyID::kInvalid
        # 1: CSSPropertyID::kVariable
        self._first_enum_value = 2
        self._last_used_enum_value = self._first_enum_value
        self._last_high_priority_property = None

        self._properties_by_id = {}
        self._properties_by_name = {}
        self._aliases = []
        self._longhands = []
        self._shorthands = []
        self._properties_including_aliases = []

        # Add default data in css_properties.json5. This must be consistent
        # across instantiations of this class.
        css_properties_file = json5_generator.Json5File.load_from_files(
            [file_paths[0]])
        self._default_parameters = css_properties_file.parameters
        # Map of feature name -> origin trial feature name
        origin_trial_features = {}
        # TODO(crbug/1031309): Refactor OriginTrialsWriter to reuse logic here.
        origin_trials_writer = OriginTrialsWriter([file_paths[2]], "")
        for feature in origin_trials_writer.origin_trial_features:
            origin_trial_features[str(feature['name'])] = True

        self.add_properties(css_properties_file.name_dictionaries,
                            origin_trial_features)

        assert self._first_enum_value + len(self._properties_by_id) < \
            self._alias_offset, \
            'Property aliasing expects fewer than %d properties.' % \
            self._alias_offset
        self._last_unresolved_property_id = max(
            property_["enum_value"] for property_ in self._aliases)

        # Process extra files passed in.
        self._extra_fields = []
        for i in range(3, len(file_paths)):
            fields = json5_generator.Json5File.load_from_files(
                [file_paths[i]], default_parameters=self._default_parameters)
            self._extra_fields.extend(fields.name_dictionaries)
        for field in self._extra_fields:
            self.expand_parameters(field)
            validate_field(field)

    def add_properties(self, properties, origin_trial_features):
        for property_ in properties:
            self._properties_by_name[property_['name'].original] = property_

        for property_ in properties:
            property_['is_shorthand'] = \
                property_['is_property'] and bool(property_['longhands'])
            property_['is_longhand'] = \
                property_['is_property'] and not property_['is_shorthand']
            self.expand_visited(property_)
            property_['in_origin_trial'] = False
            self.expand_origin_trials(property_, origin_trial_features)
            self.expand_surrogate(property_)

        self._aliases = [
            property_ for property_ in properties if property_['alias_for']
        ]
        self._shorthands = [
            property_ for property_ in properties if property_['longhands']
        ]
        self._longhands = [
            property_ for property_ in properties
            if (not property_['alias_for'] and not property_['longhands'])
        ]

        # Sort the properties by priority, then alphabetically. Ensure that
        # the resulting order is deterministic.
        # Sort properties by priority, then alphabetically.
        for property_ in self._longhands + self._shorthands:
            self.expand_parameters(property_)
            validate_property(property_)
            priority_numbers = {'High': 0, 'Low': 1}
            priority = priority_numbers[property_['priority']]
            name_without_leading_dash = property_['name'].original
            if name_without_leading_dash.startswith('-'):
                name_without_leading_dash = name_without_leading_dash[1:]
            property_['sorting_key'] = (priority, name_without_leading_dash)

        sorting_keys = {}
        for property_ in self._longhands + self._shorthands:
            key = property_['sorting_key']
            assert key not in sorting_keys, \
                ('Collision detected - two properties have the same name and '
                 'priority, a potentially non-deterministic ordering can '
                 'occur: {}, {} and {}'.format(
                     key, property_['name'].original, sorting_keys[key]))
            sorting_keys[key] = property_['name'].original
        self._longhands.sort(key=lambda p: p['sorting_key'])
        self._shorthands.sort(key=lambda p: p['sorting_key'])

        # The sorted index becomes the CSSPropertyID enum value.
        for property_ in self._longhands + self._shorthands:
            property_['enum_value'] = self._last_used_enum_value
            self._last_used_enum_value += 1
            # Add the new property into the map of properties.
            assert property_['property_id'] not in self._properties_by_id, \
                ('property with ID {} appears more than once in the '
                 'properties list'.format(property_['property_id']))
            self._properties_by_id[property_['property_id']] = property_
            if property_['priority'] == 'High':
                self._last_high_priority_property = property_

        self.expand_aliases()
        self._properties_including_aliases = self._longhands + \
            self._shorthands + self._aliases

    def expand_origin_trials(self, property_, origin_trial_features):
        if not property_['runtime_flag']:
            return
        if property_['runtime_flag'] in origin_trial_features:
            property_['in_origin_trial'] = True

    def expand_visited(self, property_):
        if not property_['visited_property_for']:
            return
        visited_property_for = property_['visited_property_for']
        unvisited_property = self._properties_by_name[visited_property_for]
        property_['visited'] = True
        # The visited property needs a link to the unvisited counterpart.
        property_['unvisited_property'] = unvisited_property
        # The unvisited property needs a link to the visited counterpart.
        assert 'visited_property' not in unvisited_property, \
            'A property may not have multiple visited properties'
        unvisited_property['visited_property'] = property_

    def expand_surrogate(self, property_):
        if not property_['surrogate_for']:
            return
        assert property_['surrogate_for'] in self._properties_by_name, \
            'surrogate_for must name a property'
        # Upgrade 'surrogate_for' to property reference.
        property_['surrogate_for'] = self._properties_by_name[
            property_['surrogate_for']]

    def expand_aliases(self):
        for i, alias in enumerate(self._aliases):
            validate_alias(alias)
            aliased_property = self._properties_by_id[id_for_css_property(
                alias['alias_for'])]
            aliased_property.setdefault('aliases', [])
            aliased_property['aliases'].append(alias['name'].original)
            updated_alias = aliased_property.copy()
            updated_alias['name'] = alias['name']
            updated_alias['alias_for'] = alias['alias_for']
            updated_alias['aliased_property'] = aliased_property[
                'name'].to_upper_camel_case()
            updated_alias['property_id'] = id_for_css_property_alias(
                alias['name'])
            updated_alias['enum_key'] = enum_key_for_css_property_alias(
                alias['name'])
            updated_alias['enum_value'] = aliased_property['enum_value'] + \
                self._alias_offset * len(aliased_property['aliases'])
            updated_alias['superclass'] = 'CSSUnresolvedProperty'
            updated_alias['namespace_group'] = \
                'Shorthand' if aliased_property['longhands'] else 'Longhand'
            self._aliases[i] = updated_alias

    def expand_parameters(self, property_):
        def set_if_none(property_, key, value):
            if key not in property_ or property_[key] is None:
                property_[key] = value

        # Basic info.
        name = property_['name']
        property_['property_id'] = id_for_css_property(name)
        property_['enum_key'] = enum_key_for_css_property(name)
        property_['is_internal'] = name.original.startswith('-internal-')
        method_name = property_['name_for_methods']
        if not method_name:
            method_name = name.to_upper_camel_case().replace('Webkit', '')
        set_if_none(property_, 'inherited', False)

        # Initial function, Getters and Setters for ComputedStyle.
        set_if_none(property_, 'initial', 'Initial' + method_name)
        simple_type_name = str(property_['type_name']).split('::')[-1]
        set_if_none(property_, 'name_for_methods', method_name)
        set_if_none(property_, 'type_name', 'E' + method_name)
        set_if_none(
            property_, 'getter', method_name
            if simple_type_name != method_name else 'Get' + method_name)
        set_if_none(property_, 'setter', 'Set' + method_name)
        if property_['inherited']:
            property_['is_inherited_setter'] = (
                'Set' + method_name + 'IsInherited')
        property_['is_animation_property'] = (
            property_['priority'] == 'Animation')

        # Figure out whether this property should have style builders at all.
        # E.g. shorthands do not get style builders.
        property_['style_builder_declare'] = (property_['is_property']
                                              and not property_['longhands'])

        # Figure out whether we should generate style builder implementations.
        for x in ['initial', 'inherit', 'value']:
            suppressed = x in property_['style_builder_custom_functions']
            declared = property_['style_builder_declare']
            property_['style_builder_generate_%s' % x] = (declared
                                                          and not suppressed)

        # Expand StyleBuilderConverter params where necessary.
        if property_['type_name'] in PRIMITIVE_TYPES:
            set_if_none(property_, 'converter', 'CSSPrimitiveValue')
        else:
            set_if_none(property_, 'converter', 'CSSIdentifierValue')

        assert not property_['alias_for'], \
            'Use expand_aliases to expand aliases'
        if not property_['longhands']:
            property_['superclass'] = 'Longhand'
            property_['namespace_group'] = 'Longhand'
        elif property_['longhands']:
            property_['superclass'] = 'Shorthand'
            property_['namespace_group'] = 'Shorthand'

        # Expand out field templates.
        if property_['field_template']:
            self._field_alias_expander.expand_field_alias(property_)

            type_name = property_['type_name']
            if (property_['field_template'] == 'keyword'
                    or property_['field_template'] == 'multi_keyword'):
                default_value = (type_name + '::' + NameStyleConverter(
                    property_['default_value']).to_enum_value())
            elif (property_['field_template'] == 'external'
                  or property_['field_template'] == 'primitive'
                  or property_['field_template'] == 'pointer'):
                default_value = property_['default_value']
            else:
                assert property_['field_template'] == 'monotonic_flag', \
                    "Please put a valid value for field_template; got " + \
                    str(property_['field_template'])
                property_['type_name'] = 'bool'
                default_value = 'false'
            property_['default_value'] = default_value

            property_['unwrapped_type_name'] = property_['type_name']
            if property_['wrapper_pointer_name']:
                assert property_['field_template'] in ['pointer', 'external']
                if property_['field_template'] == 'external':
                    property_['type_name'] = '{}<{}>'.format(
                        property_['wrapper_pointer_name'], type_name)

        # Default values for extra parameters in computed_style_extra_fields.json5.
        set_if_none(property_, 'custom_copy', False)
        set_if_none(property_, 'custom_compare', False)
        set_if_none(property_, 'mutable', False)

        if property_['logical_property_group']:
            group = property_['logical_property_group']
            assert 'name' in group, 'name option is required'
            assert 'resolver' in group, 'resolver option is required'
            logicals = {
                'block', 'inline', 'block-start', 'block-end', 'inline-start',
                'inline-end', 'start-start', 'start-end', 'end-start',
                'end-end'
            }
            physicals = {
                'vertical', 'horizontal', 'top', 'bottom', 'left', 'right',
                'top-left', 'top-right', 'bottom-right', 'bottom-left'
            }
            if group['resolver'] in logicals:
                group['is_logical'] = True
            elif group['resolver'] in physicals:
                group['is_logical'] = False
            else:
                assert 0, 'invalid resolver option'
            group['name'] = NameStyleConverter(group['name'])
            group['resolver_name'] = NameStyleConverter(group['resolver'])
            if not property_['style_builder_template'] and group['is_logical']:
                property_['style_builder_template'] = 'direction_aware'

    @property
    def default_parameters(self):
        return self._default_parameters

    @property
    def aliases(self):
        return self._aliases

    @property
    def shorthands(self):
        return self._shorthands

    @property
    def shorthands_including_aliases(self):
        return self._shorthands + [x for x in self._aliases if x['longhands']]

    @property
    def longhands(self):
        return self._longhands

    @property
    def longhands_including_aliases(self):
        return self._longhands + [
            x for x in self._aliases if not x['longhands']
        ]

    @property
    def properties_by_name(self):
        return self._properties_by_name

    @property
    def properties_by_id(self):
        return self._properties_by_id

    @property
    def properties_including_aliases(self):
        return self._properties_including_aliases

    @property
    def first_property_id(self):
        return self._first_enum_value

    @property
    def last_property_id(self):
        return self._first_enum_value + len(self._properties_by_id) - 1

    @property
    def last_unresolved_property_id(self):
        return self._last_unresolved_property_id

    @property
    def last_high_priority_property_id(self):
        return self._last_high_priority_property['enum_key']

    @property
    def property_id_bit_length(self):
        return int.bit_length(self._last_unresolved_property_id)

    @property
    def alias_offset(self):
        return self._alias_offset

    @property
    def extra_fields(self):
        return self._extra_fields