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

import os
import subprocess
import sys

import build_common
from build_options import OPTIONS
from util import platform_util

# Paths for various tools, libs, and sdks.
_SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
_PEPPER_VERSION = 'pepper_canary'
_CANNED_QEMU_ARM = 'canned/host/bin/linux-x86_64/qemu-arm'
_DEXMAKER_PATH = os.path.join('third_party', 'android', 'external', 'dexmaker')
_NACL_DEPS_PATH = os.path.join(_SCRIPT_DIR, 'DEPS.naclsdk')
_NACL_SDK_PATH = os.path.join('third_party', 'nacl_sdk', _PEPPER_VERSION)
_NACL_TOOLS_PATH = os.path.join(_NACL_SDK_PATH, 'tools')
_PNACL_BIN_PATH = os.path.join(_NACL_SDK_PATH, 'toolchain/linux_pnacl/bin')
# TODO(crbug.com/247242): support --naclsdktype={debug,release}
_NACL_SDK_RELEASE = 'Release'  # alternative: Debug
_QEMU_ARM_LD_PATH = '/usr/arm-linux-gnueabihf'
_CHROMEOS_USR_LOCAL_DIR = '/usr/local'
_CLANG_DIR = 'third_party/android/prebuilts/clang/linux-x86/host/3.5'
_CLANG_BIN_DIR = os.path.join(_CLANG_DIR, 'bin')
_CLANG_INCLUDE_DIR = os.path.join(_CLANG_DIR, 'lib', 'clang', '3.5', 'include')

# Used in get_gcc_raw_version().
_GCC_RAW_VERSION_CACHE = {}

# The pinned version of the Android SDK's build tools is used for ARC build.
_ANDROID_SDK_BUILD_TOOLS_PINNED_VERSION = '19.1.0'


def _get_android_build_tools_dir():
  return os.path.join('third_party', 'android', 'build', 'tools')


def get_android_sdk_build_tools_pinned_version():
  """Returns the pinned version of the Android SDK's build tools."""
  return _ANDROID_SDK_BUILD_TOOLS_PINNED_VERSION


def get_android_sdk_build_tools_dir():
  return os.path.join('third_party', 'android-sdk', 'build-tools',
                      get_android_sdk_build_tools_pinned_version())


def get_clang_include_dir():
  return _CLANG_INCLUDE_DIR


def get_chromeos_arc_root_with_exec(*subdirs):
  """Returns a directory whose filesystem is mounted without noexec.

  Chrome OS mounts most filesystems with noexec mount option, which prevents
  executable files from being executed directly. In order to run executable
  files for testing, we need to copy the files to a directory whose filesystem
  is mounted without noexec. This function returns /usr/local/arc as one of
  such directories. |subdirs| is joined to this path.
  """
  return os.path.join(_CHROMEOS_USR_LOCAL_DIR, 'arc', *subdirs)


def get_adb_path_for_chromeos():
  """Returns the directory that contains the adb executable for Chrome OS."""

  if platform_util.is_running_on_chromeos():
    # The adb binary is copied to a directory whose filesystem is mounted
    # without noexec mount options on Chrome OS.
    root = get_chromeos_arc_root_with_exec()
  else:
    root = build_common.get_arc_root()

  # Chrome OS based on linux-i686 is not supported.
  target = 'linux-arm' if OPTIONS.is_arm() else 'linux-x86_64'
  return os.path.join(root, 'out/adb', target, 'adb')


def _get_adb_path_for_localhost():
  root = os.path.join(build_common.get_arc_root(), 'out/adb')
  if platform_util.is_running_on_mac():
    return os.path.join(root, 'mac-x86_64/adb')
  elif platform_util.is_running_on_cygwin():
    return os.path.join(root, 'win-x86_64/adb.exe')
  elif platform_util.is_running_on_chromeos():
    return get_adb_path_for_chromeos()
  else:
    # For Linux desktop.
    return 'third_party/android-sdk/platform-tools/adb'


def get_nacl_sdk_path():
  return _NACL_SDK_PATH


def get_nacl_toolchain_root():
  return os.path.join(_NACL_SDK_PATH, 'toolchain/linux_x86_glibc')


def get_nacl_toolchain_libs_path(bitsize):
  return os.path.join(get_nacl_toolchain_root(), 'x86_64-nacl/lib%d' % bitsize)


def get_nacl_toolchain_path():
  return os.path.join(get_nacl_toolchain_root(), 'bin')


def get_nacl_tool(tool):
  return os.path.join(_NACL_TOOLS_PATH, tool)


def get_nacl_irt_core(bitsize):
  return get_nacl_tool('irt_core_x86_%d.nexe' % bitsize)


def get_nacl_runner(bitsize, bin_dir=None,
                    extra_library_paths=None, extra_envs=None):
  extra_library_paths = extra_library_paths or []
  extra_envs = extra_envs or {}
  # We use the NACL_IRT_DEV_FILENAME interface for unit tests.
  args = ['env', 'NACL_DANGEROUS_ENABLE_FILE_ACCESS=1']

  arch = 'x86_%d' % bitsize
  sel_ldr = get_nacl_tool('sel_ldr_%s' % arch)
  irt_core = get_nacl_irt_core(bitsize)
  if bin_dir:
    sel_ldr = os.path.join(bin_dir, sel_ldr)
    irt_core = os.path.join(bin_dir, irt_core)
  args.extend([sel_ldr, '-a', '-B', irt_core])
  library_path = build_common.get_load_library_path()
  if bin_dir:
    library_path = os.path.join(bin_dir, library_path)
  args.extend(['-E', 'LD_LIBRARY_PATH=' +
               ':'.join([library_path] + extra_library_paths)])
  for key, value in extra_envs.iteritems():
    args.extend(['-E', '%s=%s' % (key, value)])
  args.append('%s/runnable-ld.so' % library_path)
  return args


def get_bare_metal_runner(use_qemu_arm=False, bin_dir=None,
                          extra_library_paths=None, extra_envs=None):
  extra_library_paths = extra_library_paths or []
  extra_envs = extra_envs or {}
  args = []
  if use_qemu_arm:
    args.extend(get_qemu_arm_args())
  loader = build_common.get_bare_metal_loader()
  load_library_path = build_common.get_load_library_path()
  if bin_dir:
    load_library_path = os.path.join(bin_dir, load_library_path)
    loader = os.path.join(bin_dir, loader)
  args.append(loader)
  args.extend(['-E', 'LD_LIBRARY_PATH=' +
               ':'.join([load_library_path] + extra_library_paths)])
  for key, value in extra_envs.iteritems():
    args.extend(['-E', '%s=%s' % (key, value)])
  args.append(os.path.join(load_library_path, 'runnable-ld.so'))
  return args


def get_target_runner(bin_dir=None, extra_library_paths=None, extra_envs=None):
  if OPTIONS.is_bare_metal_build():
    return get_bare_metal_runner(bin_dir=bin_dir,
                                 extra_library_paths=extra_library_paths,
                                 extra_envs=extra_envs)
  else:
    return get_nacl_runner(OPTIONS.get_target_bitsize(), bin_dir=bin_dir,
                           extra_library_paths=extra_library_paths,
                           extra_envs=extra_envs)


def get_qemu_arm_args():
  return [_CANNED_QEMU_ARM, '-L', _QEMU_ARM_LD_PATH]


def _get_create_nmf_script():
  return 'src/packaging/create_nmf.py'


def _get_create_nmf():
  return ' '.join([
      # These environ variables are needed for our fork of create_nmf.py.
      'PYTHONPATH=third_party/chromium-ppapi/native_client_sdk/src/tools',
      'NACL_SDK_ROOT=third_party/nacl_sdk/pepper_canary',
      sys.executable,
      _get_create_nmf_script()])


def get_create_nmf_dependencies():
  deps = [_get_create_nmf_script(), 'src/packaging/lib/quote.py']
  objdump = get_tool(OPTIONS.target(), 'objdump')
  if objdump.startswith(get_nacl_toolchain_path()):
    deps.append(objdump)
  return deps


def _get_native_runner(target):
  if target == 'host' or target == 'java':
    return ''
  return 'env LD_LIBRARY_PATH=' + build_common.get_load_library_path(target)


def _get_valgrind_runner(target):
  valgrind_lib_path = 'third_party/valgrind/linux_x64/lib/valgrind'
  valgrind_env = ('env VALGRIND_LIB=%s VALGRIND_LIB_INNER=%s' %
                  (valgrind_lib_path, valgrind_lib_path))
  valgrind_path = 'third_party/valgrind/linux_x64/bin/valgrind'
  valgrind_options = [
      '--error-exitcode=1', '--num-callers=50', '--gen-suppressions=all',
      '--trace-children=yes', '--trace-children-skip=env', '--leak-check=full',
      '--suppressions=src/build/valgrind/memcheck/suppressions.txt']
  if target.startswith('bare_metal_'):
    runner = ' '.join(get_bare_metal_runner())
  else:
    runner = _get_native_runner(target)
  return '%s %s %s %s' % (
      valgrind_env, valgrind_path, ' '.join(valgrind_options), runner)


def _get_java_command(command):
  # First, look at environment variable. E.g. JAR for jar, JAVAC for javac.
  env_var = os.getenv(command.upper())
  if env_var:
    return env_var

  # Then, if java_dir is set, look at its bin/ directory.
  java_dir = OPTIONS.java_dir()
  if java_dir:
    bin_path = os.path.join(java_dir, 'bin', command)
    if os.path.exists(bin_path):
      return bin_path
  return command


def _get_tool_map():
  android_build_tools_dir = _get_android_build_tools_dir()
  android_sdk_build_tools_dir = get_android_sdk_build_tools_dir()

  return {
      'host': {
          'cxx': os.getenv('HOSTCXX', 'g++'),
          'cc': os.getenv('HOSTCC', 'gcc'),
          'ld': os.getenv('HOSTLD', 'g++'),
          'ar': os.getenv('HOSTAR', 'ar'),
          'nm': os.getenv('HOSTNM', 'nm'),
          'objcopy': os.getenv('HOSTOBJCOPY', 'objcopy'),
          'objdump': os.getenv('HOSTOBJDUMP', 'objdump'),
          'addr2line': os.getenv('HOSTADDR2LINE', 'addr2line'),
          'strip': os.getenv('HOSTSTRIP', 'strip'),
          'runner': _get_native_runner('host'),
          'valgrind_runner': _get_valgrind_runner('host'),
          'gdb': 'gdb',
          'create_nmf': _get_create_nmf(),
          'deps': [],
          'adb': _get_adb_path_for_localhost(),
      },
      'nacl_i686': {
          'cxx': (os.path.join(get_nacl_toolchain_path(), 'x86_64-nacl-g++') +
                  ' -m32'),
          'cc': (os.path.join(get_nacl_toolchain_path(), 'x86_64-nacl-gcc') +
                 ' -m32'),
          'ld': os.path.join(get_nacl_toolchain_path(), 'i686-nacl-g++'),
          'ar': os.path.join(get_nacl_toolchain_path(), 'i686-nacl-ar'),
          'nm': os.path.join(get_nacl_toolchain_path(), 'i686-nacl-nm'),
          'objcopy': os.path.join(get_nacl_toolchain_path(),
                                  'i686-nacl-objcopy'),
          'objdump': os.path.join(get_nacl_toolchain_path(),
                                  'i686-nacl-objdump'),
          'addr2line': os.path.join(get_nacl_toolchain_path(),
                                    'i686-nacl-addr2line'),
          'strip': os.path.join(get_nacl_toolchain_path(), 'i686-nacl-strip'),
          'runner': ' '.join(get_nacl_runner(32)),
          # The target does not support Valgrind. Use nacl_runner.
          'valgrind_runner': ' '.join(get_nacl_runner(32)),
          'ncval': os.path.join(_NACL_TOOLS_PATH, 'ncval'),
          'gdb': os.path.join(get_nacl_toolchain_path(), 'i686-nacl-gdb'),
          'irt': 'nacl_irt_x86_32.nexe',
          'deps': [_NACL_DEPS_PATH],
          'llvm_tblgen': build_common.get_build_path_for_executable(
              'tblgen', is_host=True),
          'clangxx': os.path.join(_PNACL_BIN_PATH, 'i686-nacl-clang++'),
          'clang': os.path.join(_PNACL_BIN_PATH, 'i686-nacl-clang'),
      },
      'nacl_x86_64': {
          'cxx': os.path.join(get_nacl_toolchain_path(), 'x86_64-nacl-g++'),
          'cc': os.path.join(get_nacl_toolchain_path(), 'x86_64-nacl-gcc'),
          'ld': os.path.join(get_nacl_toolchain_path(), 'x86_64-nacl-g++'),
          'ar': os.path.join(get_nacl_toolchain_path(), 'x86_64-nacl-ar'),
          'nm': os.path.join(get_nacl_toolchain_path(), 'x86_64-nacl-nm'),
          'objcopy': os.path.join(get_nacl_toolchain_path(),
                                  'x86_64-nacl-objcopy'),
          'objdump': os.path.join(get_nacl_toolchain_path(),
                                  'x86_64-nacl-objdump'),
          'addr2line': os.path.join(get_nacl_toolchain_path(),
                                    'x86_64-nacl-addr2line'),
          'strip': os.path.join(get_nacl_toolchain_path(), 'x86_64-nacl-strip'),
          'runner': ' '.join(get_nacl_runner(64)),
          # The target does not support Valgrind. Use nacl_runner.
          'valgrind_runner': ' '.join(get_nacl_runner(64)),
          'ncval': os.path.join(_NACL_TOOLS_PATH, 'ncval'),
          'gdb': os.path.join(get_nacl_toolchain_path(), 'x86_64-nacl-gdb'),
          'irt': 'nacl_irt_x86_64.nexe',
          'deps': [_NACL_DEPS_PATH],
          'llvm_tblgen': build_common.get_build_path_for_executable(
              'tblgen', is_host=True),
          'clangxx': os.path.join(_PNACL_BIN_PATH, 'x86_64-nacl-clang++'),
          'clang': os.path.join(_PNACL_BIN_PATH, 'x86_64-nacl-clang'),
      },
      'bare_metal_i686': {
          'cxx': os.getenv('TARGETCXX', 'g++'),
          'cc': os.getenv('TARGETCC', 'gcc'),
          'clangxx': os.path.join(_CLANG_BIN_DIR, 'clang++'),
          'clang': os.path.join(_CLANG_BIN_DIR, 'clang'),
          'ld': os.getenv('TARGETLD', 'g++'),
          'ar': os.getenv('TARGETAR', 'ar'),
          'nm': os.getenv('TARGETNM', 'nm'),
          'objcopy': os.getenv('TARGETOBJCOPY', 'objcopy'),
          'objdump': os.getenv('TARGETOBJDUMP', 'objdump'),
          'addr2line': os.getenv('TARGETADDR2LINE', 'addr2line'),
          'strip': os.getenv('TARGETSTRIP', 'strip'),
          'runner': ' '.join(get_bare_metal_runner()),
          'valgrind_runner': _get_valgrind_runner('bare_metal_i686'),
          'gdb': 'gdb',
          'deps': [],
          'llvm_tblgen': build_common.get_build_path_for_executable(
              'tblgen', is_host=True),
      },
      'bare_metal_arm': {
          'cxx': os.getenv('TARGETCXX', ' arm-linux-gnueabihf-g++'),
          'cc': os.getenv('TARGETCC', ' arm-linux-gnueabihf-gcc'),
          'clangxx': os.path.join(_CLANG_BIN_DIR, 'clang++'),
          'clang': os.path.join(_CLANG_BIN_DIR, 'clang'),
          'ld': os.getenv('TARGETLD', 'arm-linux-gnueabihf-g++'),
          'ar': os.getenv('TARGETAR', 'arm-linux-gnueabihf-ar'),
          'nm': os.getenv('TARGETNM', 'arm-linux-gnueabihf-nm'),
          'objcopy': os.getenv('TARGETOBJCOPY', 'arm-linux-gnueabihf-objcopy'),
          'objdump': os.getenv('TARGETOBJDUMP', 'arm-linux-gnueabihf-objdump'),
          'addr2line': os.getenv('TARGETADDR2LINE',
                                 'arm-linux-gnueabihf-addr2line'),
          'strip': os.getenv('TARGETSTRIP', 'arm-linux-gnueabihf-strip'),
          'runner': ' '.join(get_bare_metal_runner(use_qemu_arm=True)),
          # We do not support valgrind on Bare Metal ARM.
          'valgrind_runner': ' '.join(get_bare_metal_runner(use_qemu_arm=True)),
          'gdb': build_common.get_gdb_multiarch_path(),
          'deps': [],
          'llvm_tblgen': build_common.get_build_path_for_executable(
              'tblgen', is_host=True),
      },
      'java': {
          'aapt': os.getenv(
              'AAPT', os.path.join(android_sdk_build_tools_dir, 'aapt')),
          'aidl': os.path.join(android_sdk_build_tools_dir, 'aidl'),
          'dx': os.getenv(
              'DX', os.path.join(android_sdk_build_tools_dir, 'dx')),
          'deps': [],
          'dexopt': build_common.get_build_path_for_executable(
              'dexopt', is_host=True),
          'dexdump': build_common.get_build_path_for_executable(
              'dexdump', is_host=True),
          'java-event-log-tags': os.path.join(android_build_tools_dir,
                                              'java-event-log-tags.py'),
          'jar': _get_java_command('jar'),
          'jarjar': os.getenv('JARJAR', os.path.join(
              _DEXMAKER_PATH, 'lib', 'jarjar.jar')),
          'java': _get_java_command('java'),
          'javac': _get_java_command('javac'),
          'runner': _get_native_runner('java'),
          'zipalign': 'third_party/android-sdk/tools/zipalign',
      },
  }


def get_tool(target, tool, with_cc_wrapper=True):
  if tool == 'asm' or tool == 'asm_with_preprocessing':
    tool = 'cc'
  if tool == 'ld_system_library':
    tool = 'ld'
  command = _get_tool_map()[target][tool]
  if (tool in ['cc', 'cxx', 'clang', 'clangxx'] and
      OPTIONS.cc_wrapper() and with_cc_wrapper):
    command = OPTIONS.cc_wrapper() + ' ' + command
  return command


def get_gcc_raw_version(target):
  """Returns the gcc version of as a string like "4.8.2"."""

  raw_version = _GCC_RAW_VERSION_CACHE.get(target, 0)
  if raw_version:
    return raw_version
  cc = get_tool(target, 'cc', with_cc_wrapper=False)
  # Should call split() as cc might be prefixed with a wrapper like goma.
  raw_version = subprocess.check_output(cc.split() + ['-dumpversion']).strip()

  _GCC_RAW_VERSION_CACHE[target] = raw_version
  return raw_version


def get_gcc_version(target):
  """Returns the gcc version of as an array of three integers.

  Array of intgers is used so that two versions can be compared easily.
  Example: [4, 8, 0] < [4, 10, 0]. The result is cached so gcc is not run
  multiple times for the same target.
  """

  raw_version = get_gcc_raw_version(target)
  version = [int(x) for x in raw_version.split('.')]
  while len(version) < 3:
    version.append(0)
  assert len(version) == 3

  return version


def has_clang(target, is_host=False):
  if is_host:
    target = 'host'
  tools = _get_tool_map()[target]
  result = 'clang' in tools
  assert result == ('clangxx' in tools)
  return result