# Copyright 2013 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.

"""Finds android browsers that can be controlled by telemetry."""

import logging
import os
import sys

from py_utils import dependency_util
from devil import base_error
from devil.android import apk_helper

from telemetry.core import exceptions
from telemetry.core import platform
from telemetry.core import util
from telemetry import decorators
from telemetry.internal.backends import android_browser_backend_settings
from telemetry.internal.backends.chrome import android_browser_backend
from telemetry.internal.browser import browser
from telemetry.internal.browser import possible_browser
from telemetry.internal.platform import android_device
from telemetry.internal.util import binary_manager


CHROME_PACKAGE_NAMES = {
  'android-content-shell':
      ['org.chromium.content_shell_apk',
       android_browser_backend_settings.ContentShellBackendSettings,
       'ContentShell.apk'],
  'android-webview':
      ['org.chromium.webview_shell',
       android_browser_backend_settings.WebviewBackendSettings,
       None],
  'android-webview-shell':
      ['org.chromium.android_webview.shell',
       android_browser_backend_settings.WebviewShellBackendSettings,
       'AndroidWebView.apk'],
  'android-chromium':
      ['org.chromium.chrome',
       android_browser_backend_settings.ChromeBackendSettings,
       'ChromePublic.apk'],
  'android-chrome':
      ['com.google.android.apps.chrome',
       android_browser_backend_settings.ChromeBackendSettings,
       'Chrome.apk'],
  'android-chrome-work':
      ['com.chrome.work',
       android_browser_backend_settings.ChromeBackendSettings,
       None],
  'android-chrome-beta':
      ['com.chrome.beta',
       android_browser_backend_settings.ChromeBackendSettings,
       None],
  'android-chrome-dev':
      ['com.chrome.dev',
       android_browser_backend_settings.ChromeBackendSettings,
       None],
  'android-chrome-canary':
      ['com.chrome.canary',
       android_browser_backend_settings.ChromeBackendSettings,
       None],
  'android-system-chrome':
      ['com.android.chrome',
       android_browser_backend_settings.ChromeBackendSettings,
       None],
}


class PossibleAndroidBrowser(possible_browser.PossibleBrowser):
  """A launchable android browser instance."""
  def __init__(self, browser_type, finder_options, android_platform,
               backend_settings, apk_name):
    super(PossibleAndroidBrowser, self).__init__(
        browser_type, 'android', backend_settings.supports_tab_control)
    assert browser_type in FindAllBrowserTypes(finder_options), (
        'Please add %s to android_browser_finder.FindAllBrowserTypes' %
         browser_type)
    self._platform = android_platform
    self._platform_backend = (
        android_platform._platform_backend)  # pylint: disable=protected-access
    self._backend_settings = backend_settings
    self._local_apk = None

    if browser_type == 'exact':
      if not os.path.exists(apk_name):
        raise exceptions.PathMissingError(
            'Unable to find exact apk %s specified by --browser-executable' %
            apk_name)
      self._local_apk = apk_name
    elif browser_type == 'reference':
      if not os.path.exists(apk_name):
        raise exceptions.PathMissingError(
            'Unable to find reference apk at expected location %s.' % apk_name)
      self._local_apk = apk_name
    elif apk_name:
      assert finder_options.chrome_root, (
          'Must specify Chromium source to use apk_name')
      chrome_root = finder_options.chrome_root
      candidate_apks = []
      for build_path in util.GetBuildDirectories(chrome_root):
        apk_full_name = os.path.join(build_path, 'apks', apk_name)
        if os.path.exists(apk_full_name):
          last_changed = os.path.getmtime(apk_full_name)
          candidate_apks.append((last_changed, apk_full_name))

      if candidate_apks:
        # Find the candidate .apk with the latest modification time.
        newest_apk_path = sorted(candidate_apks)[-1][1]
        self._local_apk = newest_apk_path

  def __repr__(self):
    return 'PossibleAndroidBrowser(browser_type=%s)' % self.browser_type

  def _InitPlatformIfNeeded(self):
    pass

  def Create(self, finder_options):
    self._InitPlatformIfNeeded()
    browser_backend = android_browser_backend.AndroidBrowserBackend(
        self._platform_backend,
        finder_options.browser_options, self._backend_settings)
    try:
      return browser.Browser(
          browser_backend, self._platform_backend, self._credentials_path)
    except Exception:
      logging.exception('Failure while creating Android browser.')
      original_exception = sys.exc_info()
      try:
        browser_backend.Close()
      except Exception:
        logging.exception('Secondary failure while closing browser backend.')

      raise original_exception[0], original_exception[1], original_exception[2]

  def SupportsOptions(self, browser_options):
    if len(browser_options.extensions_to_load) != 0:
      return False
    return True

  def HaveLocalAPK(self):
    return self._local_apk and os.path.exists(self._local_apk)

  @decorators.Cache
  def UpdateExecutableIfNeeded(self):
    if self.HaveLocalAPK():
      logging.warn('Installing %s on device if needed.' % self._local_apk)
      self.platform.InstallApplication(self._local_apk)

  def last_modification_time(self):
    if self.HaveLocalAPK():
      return os.path.getmtime(self._local_apk)
    return -1


def SelectDefaultBrowser(possible_browsers):
  """Return the newest possible browser."""
  if not possible_browsers:
    return None
  return max(possible_browsers, key=lambda b: b.last_modification_time())


def CanFindAvailableBrowsers():
  return android_device.CanDiscoverDevices()


def CanPossiblyHandlePath(target_path):
  return os.path.splitext(target_path.lower())[1] == '.apk'


def FindAllBrowserTypes(options):
  del options  # unused
  return CHROME_PACKAGE_NAMES.keys() + ['exact', 'reference']


def _FindAllPossibleBrowsers(finder_options, android_platform):
  """Testable version of FindAllAvailableBrowsers."""
  if not android_platform:
    return []
  possible_browsers = []

  # Add the exact APK if given.
  if (finder_options.browser_executable and
      CanPossiblyHandlePath(finder_options.browser_executable)):
    apk_name = os.path.basename(finder_options.browser_executable)
    normalized_path = os.path.expanduser(finder_options.browser_executable)
    exact_package = apk_helper.GetPackageName(normalized_path)
    package_info = next(
        (info for info in CHROME_PACKAGE_NAMES.itervalues()
         if info[0] == exact_package or info[2] == apk_name), None)

    # It is okay if the APK name or package doesn't match any of known chrome
    # browser APKs, since it may be of a different browser.
    if package_info:
      if not exact_package:
        raise exceptions.PackageDetectionError(
            'Unable to find package for %s specified by --browser-executable' %
            normalized_path)

      [package, backend_settings, _] = package_info
      if package == exact_package:
        possible_browsers.append(PossibleAndroidBrowser(
            'exact',
            finder_options,
            android_platform,
            backend_settings(package),
            normalized_path))
      else:
        raise exceptions.UnknownPackageError(
            '%s specified by --browser-executable has an unknown package: %s' %
            (normalized_path, exact_package))

  # Add the reference build if found.
  os_version = dependency_util.GetChromeApkOsVersion(
      android_platform.GetOSVersionName())
  arch = android_platform.GetArchName()
  try:
    reference_build = binary_manager.FetchPath(
        'chrome_stable', arch, 'android', os_version)
  except (binary_manager.NoPathFoundError,
          binary_manager.CloudStorageError):
    reference_build = None

  if reference_build and os.path.exists(reference_build):
    # TODO(aiolos): how do we stably map the android chrome_stable apk to the
    # correct package name?
    package, backend_settings, _ = CHROME_PACKAGE_NAMES['android-chrome']
    possible_browsers.append(PossibleAndroidBrowser(
        'reference',
        finder_options,
        android_platform,
        backend_settings(package),
        reference_build))

  # Add any known local versions.
  for name, package_info in CHROME_PACKAGE_NAMES.iteritems():
    package, backend_settings, apk_name = package_info
    if apk_name and not finder_options.chrome_root:
      continue
    b = PossibleAndroidBrowser(name,
                               finder_options,
                               android_platform,
                               backend_settings(package),
                               apk_name)
    if b.platform.CanLaunchApplication(package) or b.HaveLocalAPK():
      possible_browsers.append(b)
  return possible_browsers


def FindAllAvailableBrowsers(finder_options, device):
  """Finds all the possible browsers on one device.

  The device is either the only device on the host platform,
  or |finder_options| specifies a particular device.
  """
  if not isinstance(device, android_device.AndroidDevice):
    return []

  try:
    android_platform = platform.GetPlatformForDevice(device, finder_options)
    return _FindAllPossibleBrowsers(finder_options, android_platform)
  except base_error.BaseError as e:
    logging.error('Unable to find browsers on %s: %s', device.device_id, str(e))
  return []