# Copyright 2019 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

from style_variable_generator.base_generator import BaseGenerator
from style_variable_generator.model import Modes, VariableType
from style_variable_generator.color import ColorBlend, ColorVar, ColorRGBVar, ColorRGB
import collections


class CSSStyleGenerator(BaseGenerator):
    '''Generator for CSS Variables'''

    @staticmethod
    def GetName():
        return 'CSS'

    def Render(self):
        return self.ApplyTemplate(self, 'templates/css_generator.tmpl',
                                  self.GetParameters())

    def GetParameters(self):
        if self.generate_single_mode:
            resolved_colors = self.model.colors.Flatten(resolve_missing=True)
            resolved_opacities = self.model.opacities.Flatten(
                resolve_missing=True)
            resolved_legacy_mappings = self.model.legacy_mappings.Flatten(
                resolve_missing=True)
            colors = {
                Modes.DEFAULT: resolved_colors[self.generate_single_mode]
            }
            legacy_mappings = {
                Modes.DEFAULT:
                resolved_legacy_mappings[self.generate_single_mode]
            }
            opacities = {
                Modes.DEFAULT: resolved_opacities[self.generate_single_mode]
            }
        else:
            colors = self.model.colors.Flatten()
            opacities = self.model.opacities.Flatten()
            legacy_mappings = self.model.legacy_mappings.Flatten()

        return {
            'opacities': opacities,
            'colors': colors,
            'legacy_mappings': legacy_mappings,
            'typefaces': self.model.typefaces,
            'font_faces': self.model.font_faces,
            'font_families': self.model.font_families,
            'untyped_css': self.model.untyped_css,
        }

    def GetFilters(self):
        return {
            'to_css_var_name': self.ToCSSVarName,
            'to_css_var_name_unscoped': self.ToCSSVarNameUnscoped,
            'css_opacity': self._CSSOpacity,
            'css_color_rgb': self.CSSColorRGB,
            'process_simple_ref': self.ProcessSimpleRef,
        }

    def GetGlobals(self):
        return {
            'css_color_var':
            self.CSSColorVar,
            'needs_rgb_variant':
            self.NeedsRGBVariant,
            'in_files':
            self.GetInputFiles(),
            'dark_mode_selector':
            self.generator_options.get('dark_mode_selector', None),
            'suppress_sources_comment':
            self.generator_options.get('suppress_sources_comment', False),
            'Modes':
            Modes,
        }

    def DefaultPreblend(self):
        return False

    def AddGeneratedVars(self, var_names, variable):
        def AddVarNames(name, variations):
            for v in variations:
                var_name = v.replace('$css_name', self.ToCSSVarName(name))
                if var_name in var_names:
                    raise ValueError(name + " is defined multiple times")
                var_names[var_name] = name

        variable_type = variable.variable_type
        if variable_type == VariableType.OPACITY:
            AddVarNames(variable.name, ['$css_name'])
        elif variable_type == VariableType.COLOR:
            AddVarNames(variable.name, ['$css_name', '$css_name-rgb'])
        elif variable_type == VariableType.UNTYPED_CSS:
            AddVarNames(variable.name, ['$css_name'])
        elif variable_type == VariableType.FONT_FAMILY:
            AddVarNames(variable.name, ['$css_name'])
        elif variable_type == VariableType.TYPEFACE:
            AddVarNames(variable.name, [
                '$css_name-font',
                '$css_name-font-family',
                '$css_name-font-size',
                '$css_name-font-weight',
                '$css_name-line-height',
            ])
        elif variable_type == VariableType.FONT_FACE:
            # Font faces are not individual attributes
            pass
        elif variable_type == VariableType.LEGACY_MAPPING:
            # No Clients should be directly using any of the legacy mappings.
            pass
        else:
            raise ValueError("GetGeneratedVars() for '%s' not implemented")

    def GetCSSVarNames(self):
        '''Returns a map of all generated names to the model names that
           generated them.
        '''
        var_names = dict()
        for variable in self.model.variable_map.values():
            self.AddGeneratedVars(var_names, variable)

        return var_names

    def ProcessSimpleRef(self, value):
        '''If |value| is a simple '$other_variable' reference, returns a
           CSS variable that points to '$other_variable'.'''
        if value.startswith('$'):
            ref_name = value[1:]
            assert ref_name in self.model.variable_map
            value = 'var({0})'.format(self.ToCSSVarName(ref_name))

        return value

    def _GetCSSVarPrefix(self, name):
        prefix = self.model.variable_map[name].context.get(
            CSSStyleGenerator.GetName(), {}).get('prefix')
        return prefix + '-' if prefix else ''

    def ToCSSVarName(self, name):
        # This handles old_semantic_names as well as new.token-names.
        var_name = name.translate(str.maketrans('-_.', '_--'))

        return '--%s%s' % (self._GetCSSVarPrefix(name), var_name)

    def ToCSSVarNameUnscoped(self, name):
        return f'--{name}'

    def _CSSOpacity(self, opacity):
        if opacity.var:
            return 'var(%s)' % self.ToCSSVarName(opacity.var)

        return ('%f' % opacity.a).rstrip('0').rstrip('.')

    def CSSColorRGB(self, c):
        '''Returns the CSS rgb representation of |c|'''
        if isinstance(c, ColorVar):
            return 'var(%s-rgb)' % self.ToCSSVarName(c.var)

        if isinstance(c, ColorRGBVar):
            return 'var(%s-rgb)' % self.ToCSSVarName(c.ToVar())

        if isinstance(c, ColorRGB):
            return '%d, %d, %d' % (c.r, c.g, c.b)

        raise NotImplementedError(f'Cannot reduce {c} to RBG')

    def CSSBlendInputColor(self, c, mode):
        '''Resolves a color for use in a color-mix call.'''
        # TODO(b/278121949): Assert that the color is opaque.
        if (isinstance(c, ColorVar)):
            return 'var(%s)' % self.ToCSSVarName(c.var)
        if (isinstance(c, ColorBlend)):
            return self.ToBlendColor(c, mode)
        return 'rgb(%s)' % self.CSSColorRGB(c)

    def ToBlendColor(self, color, mode):
        '''Resolves a color blend. Allows for nested blends.'''
        assert (isinstance(color, ColorBlend))
        blendPercentage = float(
            color.blendPercentage
            or self.ExtractOpacity(color.blended_colors[0], mode))
        return 'color-mix(in srgb, %s %s%%, %s)' % (
            self.CSSBlendInputColor(color.blended_colors[0],
                                    mode), blendPercentage,
            self.CSSBlendInputColor(color.blended_colors[1], mode))

    def ExtractOpacity(self, c, mode):
        if isinstance(c, ColorVar):
            return self.ExtractOpacity(self.model.colors.Resolve(c.var, mode),
                                       mode)
        if c.opacity:
            return self.model.opacities.ResolveOpacity(c.opacity, mode).a * 100

        # If we don't have opacity information assume we want to blend 100%.
        return 100

    def CSSColorVar(self, name, color, mode, unscoped=False):
        '''Returns the CSS color representation given a color name and color'''
        if unscoped:
            var_name = self.ToCSSVarNameUnscoped(name)
        else:
            var_name = self.ToCSSVarName(name)

        if isinstance(color, ColorVar):
            return 'var(%s)' % self.ToCSSVarName(color.var)

        if isinstance(color, ColorBlend):
            return self.ToBlendColor(color, mode)

        if isinstance(color,
                      ((ColorRGB, ColorRGBVar))) and color.opacity.a != 1:
            return 'rgba(var(%s-rgb), %s)' % (var_name,
                                              self._CSSOpacity(color.opacity))

        return 'rgb(var(%s-rgb))' % var_name

    def NeedsRGBVariant(self, color):
        return not isinstance(color, ColorBlend)