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

"""Contains a set of Chrome-specific size queries."""

import logging
import re

import models


class _Grouper:
  def __init__(self):
    self.groups = []

  def Add(self, name, group):
    logging.debug('Computed %s (%d syms)', name, len(group))
    if group:
      sorted_group = group.Sorted()
      sorted_group.SetName(name)
      self.groups.append(sorted_group)
    return group.Inverted()

  def Finalize(self, remaining):
    self.groups.sort(key=lambda s: (s.name.startswith('Other'), -abs(s.pss)))
    if remaining:
      stars = remaining.Filter(lambda s: s.name.startswith('*'))
      if stars:
        remaining = stars.Inverted()
        stars = stars.Sorted()
        stars.SetName('** Merged Symbols')
        self.groups.append(stars)

      others_by_path = remaining.GroupedByPath(depth=1).Sorted()
      for subgroup in others_by_path:
        subgroup.SetName('Other //' + subgroup.name)
      self.groups.extend(others_by_path)

    logging.debug('Finalized')
    return models.SymbolGroup(self.groups)


def _CategorizeByChromeComponent(symbols):
  g = _Grouper()

  # Put things that filter out a lot of symbols at the beginning where possible
  # to optimize speed.
  symbols = g.Add('WebRTC', symbols.WhereMatches(r'(?i)webrtc'))
  symbols = g.Add(
    'v8', symbols.Filter(lambda s: s.source_path.startswith('v8/'))
  )
  symbols = g.Add('Skia', symbols.Filter(lambda s: 'skia/' in s.source_path))
  symbols = g.Add(
    'net', symbols.Filter(lambda s: s.source_path.startswith('net/'))
  )
  symbols = g.Add(
    'media', symbols.Filter(lambda s: s.source_path.startswith('media/'))
  )
  symbols = g.Add(
    'gpu', symbols.Filter(lambda s: s.source_path.startswith('gpu/'))
  )
  symbols = g.Add(
    'cc', symbols.Filter(lambda s: s.source_path.startswith('cc/'))
  )
  symbols = g.Add(
    'base', symbols.Filter(lambda s: s.source_path.startswith('base/'))
  )
  symbols = g.Add(
    'viz', symbols.Filter(lambda s: s.source_path.startswith('components/viz'))
  )
  symbols = g.Add(
    'ui/gfx', symbols.Filter(lambda s: s.source_path.startswith('ui/gfx/'))
  )

  # Next, put non-regex queries, since they're a bit faster.
  symbols = g.Add('ICU', symbols.Filter(lambda s: '/icu/' in s.source_path))
  symbols = g.Add(
    'Prefetch', symbols.Filter(lambda s: 'resource_prefetch' in s.source_path)
  )
  symbols = g.Add(
    'Password Manager',
    symbols.Filter(lambda s: 'password_manager' in s.source_path),
  )
  symbols = g.Add(
    'Internals Pages', symbols.Filter(lambda s: '_internals' in s.source_path)
  )
  symbols = g.Add('Autofill', symbols.WhereSourcePathMatches(r'(?i)autofill'))
  symbols = g.Add('WebGL', symbols.WhereMatches(r'(?i)webgl'))
  symbols = g.Add('WebBluetooth', symbols.WhereMatches(r'(?i)bluetooth'))
  symbols = g.Add('WebUSB', symbols.WhereMatches(r'(?i)webusb|(\b|_)usb(\b|_)'))
  symbols = g.Add(
    'WebVR', symbols.WhereMatches(r'{{_gvr_}}|{{_cwebvr_}}|{{_vr_}}')
  )
  symbols = g.Add(
    'FileSystem',
    symbols.WhereSourcePathMatches(r'content/.*/fileapi|WebKit/.*/filesystem'),
  )
  symbols = g.Add('WebCrypto', symbols.WhereMatches(r'(?i)webcrypto'))
  symbols = g.Add('Printing', symbols.WhereMatches(r'printing'))
  symbols = g.Add(
    'Cast', symbols.WhereSourcePathMatches(r'(?i)(\b|_)cast(\b|_)')
  )
  symbols = g.Add(
    'Media Source',
    symbols.WhereMatches(
      r'(?i)mediasource|blink::.*TrackDefault|blink::.*SourceBuffer'
    ),
  )

  # XSLT must come before libxml.
  symbols = g.Add('XSLT', symbols.WhereMatches(r'(?i)xslt'))
  symbols = g.Add('libxml', symbols.Filter(lambda s: 'libxml' in s.source_path))

  # These have some overlap with above, so need to come afterwards.
  blink_syms = symbols.WhereSourcePathMatches(r'\b(blink|WebKit)\b')
  symbols = blink_syms.Inverted()
  blink_generated = blink_syms.WhereSourceIsGenerated()
  g.Add('Blink (generated)', blink_generated)
  g.Add('Blink (non-generated)', blink_generated.Inverted())

  symbols = g.Add(
    'Codecs',
    symbols.WhereSourcePathMatches(
      r'^third_party/(libweb[mp]|libpng|libjpeg_turbo|opus|ffmpeg|libvpx)/'
    ),
  )
  symbols = g.Add(
    'Other Third-Party',
    symbols.Filter(lambda s: 'third_party' in s.source_path),
  )

  return g.Finalize(symbols)


def _CategorizeGenerated(symbols):
  g = _Grouper()

  # Don't count other symbols or prebuilts.
  symbols = symbols.Filter(
    lambda s: (
      s.section_name != models.SECTION_OTHER
      and not s.source_path.endswith('.class')
    )
  )
  # JNI is generated into .h files then #included, so the symbols don't actaully
  # appear as "SourceIsGenerated".
  # Note: String literals within symbols like "kBaseRegisteredMethods" are not
  #     being accounted for here because they end up within "** merge strings".
  #     This could be fixed by assigning them all to proper variables rather
  #     than having them be inline.
  symbols = g.Add(
    'RegisterJNI',
    symbols.WhereFullNameMatches(r'Register.*JNIEnv\*\)|RegisteredMethods$'),
  )
  symbols = g.Add(
    'gl_bindings_autogen', symbols.WherePathMatches('gl_bindings_autogen')
  )

  symbols = symbols.WhereSourceIsGenerated()
  symbols = g.Add(
    'Java Protocol Buffers',
    symbols.Filter(lambda s: '__protoc_java.srcjar' in s.source_path),
  )
  symbols = g.Add(
    'C++ Protocol Buffers',
    symbols.Filter(
      lambda s: (
        '/protobuf/' in s.object_path
        or s.object_path.endswith('.pbzero.o')
        or s.object_path.endswith('.pb.o')
      )
    ),
  )
  mojo_pattern = re.compile(r'\bmojom?\b')
  symbols = g.Add(
    'Mojo',
    symbols.Filter(
      lambda s: (
        s.full_name.startswith('mojo::') or mojo_pattern.search(s.source_path)
      )
    ),
  )
  symbols = g.Add(
    'DevTools', symbols.WhereSourcePathMatches(r'\b(?:protocol|devtools)\b')
  )
  symbols = g.Add(
    'Blink (bindings)', symbols.WherePathMatches(r'(?:blink|WebKit)/.*bindings')
  )
  symbols = g.Add(
    'Blink (other)',
    symbols.Filter(
      lambda s: 'WebKit' in s.object_path or 'blink/' in s.object_path
    ),
  )
  symbols = g.Add(
    'V8 Builtins',
    symbols.Filter(lambda s: s.source_path.endswith('embedded.S')),
  )
  symbols = g.Add(
    'prepopulated_engines.cc',
    symbols.Filter(lambda s: 'prepopulated_engines' in s.object_path),
  )
  symbols = g.Add(
    'Metrics-related code',
    symbols.Filter(lambda s: '/metrics/' in s.object_path),
  )
  symbols = g.Add(
    'gpu_driver_bug_list_autogen.cc',
    symbols.Filter(lambda s: 'gpu_driver_bug_list' in s.object_path),
  )
  symbols = g.Add(
    'components/policy',
    symbols.Filter(lambda s: 'components/policy' in s.object_path),
  )

  return g.Finalize(symbols)


class CannedQueries:
  """A set of pre-written queries."""

  def __init__(self, size_infos):
    self._size_infos = size_infos

  def _SymbolsArg(self, arg, native_only=False, pak_only=False):
    arg = arg if arg is not None else self._size_infos[-1]
    if isinstance(arg, models.BaseSizeInfo):
      if native_only:
        arg = arg.native_symbols
      elif pak_only:
        arg = arg.pak_symbols
      else:
        arg = arg.symbols
    return arg

  def CategorizeGenerated(self, symbols=None):
    """Categorizes symbols that come from generated source files."""
    return _CategorizeGenerated(self._SymbolsArg(symbols))

  def CategorizeByChromeComponent(self, symbols=None):
    """Groups symbols by component using predefined queries."""
    return _CategorizeByChromeComponent(self._SymbolsArg(symbols))

  def TemplatesByName(self, symbols=None, depth=0):
    """Lists C++ templates grouped by name."""
    symbols = self._SymbolsArg(symbols, native_only=True)
    # Call Sorted() twice so that subgroups will be sorted.
    # TODO(agrieve): Might be nice to recursively GroupedByName() on these.
    return symbols.WhereIsTemplate().Sorted().GroupedByName(depth).Sorted()

  def StaticInitializers(self, symbols=None):
    """Lists Static Initializers."""
    symbols = self._SymbolsArg(symbols, native_only=True)
    # GCC generates "_GLOBAL__" symbols. Clang generates "startup".
    return symbols.WhereNameMatches('^startup$|^_GLOBAL__')

  def LargeFiles(self, symbols=None, min_size=50 * 1024):
    """Lists source files that are larger than a certain size (default 50kb)."""
    symbols = self._SymbolsArg(symbols)
    return (
      symbols.GroupedByPath(fallback=None).WherePssBiggerThan(min_size).Sorted()
    )

  def PakByPath(self, symbols=None):
    """Groups .pak.* symbols by path."""
    symbols = self._SymbolsArg(symbols, pak_only=True)
    return symbols.WhereIsPak().Sorted().GroupedByPath().Sorted()