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

from blinkbuild.name_style_converter import NameStyleConverter
import json5_generator
import template_expander
import make_style_builder
import keyword_utils
from name_utilities import enum_key_for_css_keyword


def _find_continuous_segment(numbers):
    """Find the longest continuous segment in a list of numbers.
    For example:
        input:
                1, 2, 3, 4, 5, 6
               22,70,23,24,25,26
        output:
            number_list_sorted:
                1, 3, 4, 5, 6, 2
               22,23,24,25,26,70
            segments:
                0, 1, 5, 6
            which means there are 3 segment with start and end indices
            on the number_list_sorted to be: (0, 1), (1, 5), (5, 6)

    Args:
        numbers: List of pairs of number

    Returns:
        segment: a list containing the indices of the segment start point
            and end point.
        number_list: sorted by the first element version of the input.

    """
    segments = [0]
    number_list_sorted = sorted(numbers, key=lambda elem: elem[0])
    for i in range(len(number_list_sorted) - 1):
        # continuous segment is a segment which the number in pair is 1 unit
        # more than the previous pair
        if (number_list_sorted[i + 1][0] - number_list_sorted[i][0] != 1 or
                number_list_sorted[i + 1][1] - number_list_sorted[i][1] != 1):
            segments.append(i + 1)
    segments.append(len(number_list_sorted))
    return segments, number_list_sorted


def _find_largest_segment(segments):
    """Find the largest segment given a list of start and end
    indices of segments

    Args:
        segments: a list of start and end indices

    Returns:
        longest_segment: the start and end indices of the longest segment

    """
    segment_list = zip(segments[:-1], segments[1:])
    return max(segment_list, key=lambda x: x[1] - x[0])


def _find_enum_longest_continuous_segment(property_,
                                          name_to_position_dictionary):
    """Find the longest continuous segment in the list of keywords
    Finding the continuous segment will allows us to do the subtraction
    between keywords so that the distance between 2 keywords in this
    enum is equal to the distance of corresponding keywords in another
    enum.

    Step 1:
        Convert keyword enums into number.
        Sort and find all continuous segment in the list of enums.

    Step 2:
        Get the longest segment.

    Step 3:
        Compose a list of keyword enums and their respective numbers
        in the sorted order.

    Step 4:
        Build the switch case statements of other enums not in the
        segment. Enums in the segment will be computed in default clause.
    """
    property_enum_order = range(len(property_['keywords']))
    css_enum_order = [
        name_to_position_dictionary[x] for x in property_['keywords']
    ]
    enum_pair_list = zip(css_enum_order, property_enum_order)
    enum_segment, enum_pair_list = _find_continuous_segment(enum_pair_list)
    longest_segment = _find_largest_segment(enum_segment)

    enum_tuple_list = []
    for x in enum_pair_list:
        keyword = NameStyleConverter(property_['keywords'][x[1]])
        enum_tuple_list.append((enum_key_for_css_keyword(keyword), x[1], x[0]))
    return enum_tuple_list, enum_segment, longest_segment


class CSSValueIDMappingsWriter(make_style_builder.StyleBuilderWriter):
    def __init__(self, json5_file_paths, output_dir):
        super(CSSValueIDMappingsWriter, self).__init__(json5_file_paths,
                                                       output_dir)
        self._outputs = {
            'css_value_id_mappings_generated.h':
            self.generate_css_value_mappings,
        }
        self.css_values_dictionary_file = json5_file_paths[3]
        css_properties = self.css_properties.longhands
        # We sort the enum values based on each value's position in
        # the keywords as listed in css_properties.json5. This will ensure that if there is a continuous
        # segment in css_properties.json5 matching the segment in this enum then
        # the generated enum will have the same order and continuity as
        # css_properties.json5 and we can get the longest continuous segment.
        # Thereby reduce the switch case statement to the minimum.
        css_properties = keyword_utils.sort_keyword_properties_by_canonical_order(
            css_properties, json5_file_paths[3], self.default_parameters)

    @template_expander.use_jinja(
        'core/css/templates/css_value_id_mappings_generated.h.tmpl')
    def generate_css_value_mappings(self):
        mappings = {}
        include_paths = set()
        css_values_dictionary = json5_generator.Json5File.load_from_files(
            [self.css_values_dictionary_file],
            default_parameters=self.default_parameters).name_dictionaries
        name_to_position_dictionary = dict(
            zip([x['name'].original for x in css_values_dictionary],
                range(len(css_values_dictionary))))

        for property_ in self.css_properties.properties_including_aliases:
            include_paths.update(property_['include_paths'])
            if property_['field_template'] == 'multi_keyword':
                mappings[property_['type_name']] = {
                    'default_value':
                    property_['default_value'],
                    'mapping': [
                        enum_key_for_css_keyword(k)
                        for k in property_['keywords']
                    ],
                }
            elif property_['field_template'] == 'keyword':
                enum_pair_list, enum_segment, p_segment = _find_enum_longest_continuous_segment(
                    property_, name_to_position_dictionary)
                mappings[property_['type_name']] = {
                    'default_value': property_['default_value'],
                    'mapping': enum_pair_list,
                    'segment': enum_segment,
                    'longest_segment_length': p_segment[1] - p_segment[0],
                    'start_segment': enum_pair_list[p_segment[0]],
                    'end_segment': enum_pair_list[p_segment[1] - 1],
                }

        return {
            'include_paths': list(sorted(include_paths)),
            'input_files': self._input_files,
            'mappings': mappings,
        }


if __name__ == '__main__':
    json5_generator.Maker(CSSValueIDMappingsWriter).main()