# 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 os
import logging as real_logging
import re
import subprocess
import sys

from telemetry import decorators
from telemetry.core import browser
from telemetry.core import platform
from telemetry.core import possible_browser
from telemetry.core import util
from telemetry.core.backends import adb_commands
from telemetry.core.backends.chrome import android_browser_backend
from telemetry.core.platform import android_platform_backend


CHROME_PACKAGE_NAMES = {
  'android-content-shell':
      ['org.chromium.content_shell_apk',
       android_browser_backend.ContentShellBackendSettings,
       'ContentShell.apk'],
  'android-chrome-shell':
      ['org.chromium.chrome.shell',
       android_browser_backend.ChromeShellBackendSettings,
       'ChromeShell.apk'],
  'android-webview':
      ['com.android.webview.chromium.shell',
       android_browser_backend.WebviewBackendSettings,
       None],
  'android-chrome':
      ['com.google.android.apps.chrome',
       android_browser_backend.ChromeBackendSettings,
       'Chrome.apk'],
  'android-chrome-beta':
      ['com.chrome.beta',
       android_browser_backend.ChromeBackendSettings,
       None],
  'android-chrome-dev':
      ['com.google.android.apps.chrome_dev',
       android_browser_backend.ChromeBackendSettings,
       None],
  'android-chrome-canary':
      ['com.chrome.canary',
       android_browser_backend.ChromeBackendSettings,
       None],
  'android-jb-system-chrome':
      ['com.android.chrome',
       android_browser_backend.ChromeBackendSettings,
       None]
}

ALL_BROWSER_TYPES = CHROME_PACKAGE_NAMES.keys()

# adb shell pm list packages
# adb
# intents to run (pass -D url for the rest)
#   com.android.chrome/.Main
#   com.google.android.apps.chrome/.Main

class PossibleAndroidBrowser(possible_browser.PossibleBrowser):
  """A launchable android browser instance."""
  def __init__(self, browser_type, finder_options, backend_settings, apk_name):
    super(PossibleAndroidBrowser, self).__init__(browser_type, 'android',
        finder_options, backend_settings.supports_tab_control)
    assert browser_type in ALL_BROWSER_TYPES, \
        'Please add %s to ALL_BROWSER_TYPES' % browser_type
    self._backend_settings = backend_settings
    self._local_apk = None

    chrome_root = util.GetChromiumSrcDir()
    if apk_name:
      candidate_apks = []
      for build_dir, build_type in util.GetBuildDirectories():
        apk_full_name = os.path.join(chrome_root, build_dir, build_type, '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 canadidate .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

  @property
  @decorators.Cache
  def _platform_backend(self):
    return android_platform_backend.AndroidPlatformBackend(
        self._backend_settings.adb.device(),
        self.finder_options.no_performance_mode)

  def Create(self):
    use_rndis_forwarder = (self.finder_options.android_rndis or
                           self.finder_options.browser_options.netsim or
                           platform.GetHostPlatform().GetOSName() != 'linux')
    backend = android_browser_backend.AndroidBrowserBackend(
        self.finder_options.browser_options, self._backend_settings,
        use_rndis_forwarder,
        output_profile_path=self.finder_options.output_profile_path,
        extensions_to_load=self.finder_options.extensions_to_load)
    b = browser.Browser(backend, self._platform_backend)
    return b

  def SupportsOptions(self, finder_options):
    if len(finder_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():
      real_logging.warn(
          'Refreshing %s on device if needed.' % self._local_apk)
      self._backend_settings.adb.Install(self._local_apk)

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

def SelectDefaultBrowser(possible_browsers):
  local_builds_by_date = sorted(possible_browsers,
                                key=lambda b: b.last_modification_time())

  if local_builds_by_date:
    newest_browser = local_builds_by_date[-1]
    return newest_browser
  return None

adb_works = None
def CanFindAvailableBrowsers(logging=real_logging):
  if not adb_commands.IsAndroidSupported():
    logging.info('Android build commands unavailable on this machine. Have '
                 'you installed Android build dependencies?')
    return False

  global adb_works

  if adb_works == None:
    try:
      with open(os.devnull, 'w') as devnull:
        proc = subprocess.Popen(['adb', 'devices'],
                                stdout=subprocess.PIPE,
                                stderr=subprocess.PIPE,
                                stdin=devnull)
        stdout, _ = proc.communicate()
        if re.search(re.escape('????????????\tno permissions'), stdout) != None:
          logging.warn(
              ('adb devices reported a permissions error. Consider '
               'restarting adb as root:'))
          logging.warn('  adb kill-server')
          logging.warn('  sudo `which adb` devices\n\n')
        adb_works = True
    except OSError:
      platform_tools_path = os.path.join(util.GetChromiumSrcDir(),
          'third_party', 'android_tools', 'sdk', 'platform-tools')
      if (sys.platform.startswith('linux') and
          os.path.exists(os.path.join(platform_tools_path, 'adb'))):
        os.environ['PATH'] = os.pathsep.join([platform_tools_path,
                                              os.environ['PATH']])
        adb_works = True
      else:
        adb_works = False
  return adb_works

def FindAllAvailableBrowsers(finder_options, logging=real_logging):
  """Finds all the desktop browsers available on this machine."""
  if not CanFindAvailableBrowsers(logging=logging):
    logging.info('No adb command found. ' +
                 'Will not try searching for Android browsers.')
    return []

  device = None
  if finder_options.android_device:
    devices = [finder_options.android_device]
  else:
    devices = adb_commands.GetAttachedDevices()

  if len(devices) == 0:
    logging.info('No android devices found.')
    return []

  if len(devices) > 1:
    logging.warn(
        'Multiple devices attached. Please specify one of the following:\n' +
        '\n'.join(['  --device=%s' % d for d in devices]))
    return []

  device = devices[0]

  adb = adb_commands.AdbCommands(device=device)
  # Trying to root the device, if possible.
  if not adb.IsRootEnabled():
    # Ignore result.
    adb.EnableAdbRoot()

  if sys.platform.startswith('linux'):
    # Host side workaround for crbug.com/268450 (adb instability)
    # The adb server has a race which is mitigated by binding to a single core.
    import psutil  # pylint: disable=F0401
    pids  = [p.pid for p in psutil.process_iter() if 'adb' in p.name]
    with open(os.devnull, 'w') as devnull:
      for pid in pids:
        ret = subprocess.call(['taskset', '-p', '-c', '0', str(pid)],
                              stdout=subprocess.PIPE,
                              stderr=subprocess.PIPE,
                              stdin=devnull)
        if ret:
          logging.warn('Failed to taskset %d (%s)', pid, ret)

  if not os.environ.get('BUILDBOT_BUILDERNAME'):
    # Killing adbd before running tests has proven to make them less likely to
    # flake out during the test. We skip this if Telemetry is running under a
    # buildbot because build/android/test_runner.py wrapper already took care
    # of it before starting the shards.
    adb.RestartAdbdOnDevice()

  packages = adb.RunShellCommand('pm list packages')
  possible_browsers = []

  for name, package_info in CHROME_PACKAGE_NAMES.iteritems():
    [package, backend_settings, local_apk] = package_info
    b = PossibleAndroidBrowser(
        name,
        finder_options,
        backend_settings(adb, package),
        local_apk)

    if 'package:' + package in packages or b.HaveLocalAPK():
      possible_browsers.append(b)

  if possible_browsers:
    installed_prebuilt_tools = adb_commands.SetupPrebuiltTools(adb)
    if not installed_prebuilt_tools:
      logging.error(
          'Android device detected, however prebuilt android tools could not '
          'be used. To run on Android you must build them first:\n'
          '  $ ninja -C out/Release android_tools')
      return []

  return possible_browsers