#!/usr/bin/env python
# Copyright 2015 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 argparse
import subprocess
import sys
import os

SRC_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

def get_out_dir(args):
    if args.target_os is not None:
        target_dir = [args.target_os]
    else:
        target_dir = ['host']

    if args.dynamic:
        target_dir.append('dynamic')

    target_dir.append(args.runtime_mode)

    if args.simulator:
        target_dir.append('sim')

    if args.unoptimized:
        target_dir.append('unopt')

    if args.target_os != 'ios' and args.interpreter:
        target_dir.append('interpreter')

    if args.android_cpu != 'arm':
        target_dir.append(args.android_cpu)

    if args.ios_cpu != 'arm64':
        target_dir.append(args.ios_cpu)

    if args.linux_cpu is not None:
      target_dir.append(args.linux_cpu)

    if args.enable_vulkan:
        target_dir.append('vulkan')

    return os.path.join('out', '_'.join(target_dir))

def to_command_line(gn_args):
    def merge(key, value):
        if type(value) is bool:
            return '%s=%s' % (key, 'true' if value else 'false')
        return '%s="%s"' % (key, value)
    return [merge(x, y) for x, y in gn_args.iteritems()]

def cpu_for_target_arch(arch):
  if arch in ['ia32', 'arm', 'armv6', 'armv5te', 'mips',
              'simarm', 'simarmv6', 'simarmv5te', 'simmips', 'simdbc',
              'armsimdbc']:
    return 'x86'
  if arch in ['x64', 'arm64', 'simarm64', 'simdbc64', 'armsimdbc64']:
    return 'x64'

def to_gn_args(args):
    if args.simulator:
        if args.target_os == 'android':
            raise Exception('--simulator is not supported on Android')
        elif args.target_os == 'ios':
            if args.runtime_mode != 'debug':
                raise Exception('iOS simulator only supports the debug runtime mode')

    if args.target_os != 'android' and args.enable_vulkan:
      raise Exception('--enable-vulkan is only supported on Android')

    runtime_mode = args.runtime_mode
    if args.dynamic and runtime_mode in ['profile', 'release']:
      runtime_mode = 'dynamic_' + runtime_mode

    gn_args = {}

    # Skia GN args.
    gn_args['skia_enable_flutter_defines'] = True # Enable Flutter API guards in Skia.
    gn_args['skia_use_dng_sdk'] = False    # RAW image handling.
    gn_args['skia_use_sfntly'] = False     # PDF handling depedency.
    gn_args['skia_enable_pdf'] = False     # PDF handling.
    gn_args['skia_use_expat'] = args.target_os == 'android'
    gn_args['skia_use_fontconfig'] = False # Use the custom font manager instead.
    gn_args['is_official_build'] = True    # Disable Skia test utilities.

    gn_args['is_debug'] = args.unoptimized
    gn_args['android_full_debug'] = args.target_os == 'android' and args.unoptimized
    gn_args['is_clang'] = not sys.platform.startswith(('cygwin', 'win'))

    enable_lto = args.lto
    if args.unoptimized:
      # There is no point in enabling LTO in unoptimized builds.
      enable_lto = False

    if not sys.platform.startswith('win'):
      # The GN arg is not available in the windows toolchain.
      gn_args['enable_lto'] = enable_lto

    aot = not runtime_mode in ['debug', 'dynamic_profile', 'dynamic_release']
    if args.target_os == 'android':
        gn_args['target_os'] = 'android'
    elif args.target_os == 'ios':
        gn_args['target_os'] = 'ios'
        gn_args['use_ios_simulator'] = args.simulator
        if not args.simulator:
          aot = True
    else:
      aot = False

    if runtime_mode == 'debug':
        gn_args['dart_runtime_mode'] = 'develop'
    elif runtime_mode == 'dynamic_profile':
        gn_args['dart_runtime_mode'] = 'profile'
    elif runtime_mode == 'dynamic_release':
        gn_args['dart_runtime_mode'] = 'release'
    else:
        gn_args['dart_runtime_mode'] = runtime_mode

    if args.target_os == 'android':
        gn_args['target_cpu'] = args.android_cpu
    elif args.target_os == 'ios':
        if args.simulator:
            gn_args['target_cpu'] = 'x64'
        else:
            gn_args['target_cpu'] = args.ios_cpu
    elif args.target_os == 'linux':
      gn_args['target_cpu'] = args.linux_cpu
    else:
        # Building host artifacts
        gn_args['target_cpu'] = 'x64'

    # On iOS Devices, use the Dart bytecode interpreter so we don't incur
    # snapshotting and linking costs of the precompiler during development.
    # We can still use the JIT on the simulator though.
    can_use_dbc = runtime_mode in ['debug', 'dynamic_profile', 'dynamic_release']
    use_dbc = args.target_os == 'ios' and not args.simulator and can_use_dbc
    # Use dbc if it is requested on the command line and supported by the
    # requested runtime mode.
    if args.interpreter and not can_use_dbc:
      raise Exception('--interpreter not supported with --runtime-mode=' + runtime_mode)
    use_dbc = use_dbc or (args.interpreter and can_use_dbc)
    if use_dbc:
      gn_args['dart_target_arch'] = 'dbc'
    else:
      gn_args['dart_target_arch'] = gn_args['target_cpu']

    # No cross-compilation on Windows (for now).
    if sys.platform.startswith(('cygwin', 'win')):
      if 'target_os' in gn_args:
        gn_args['target_os'] = 'win'
      if 'target_cpu' in gn_args:
        gn_args['target_cpu'] = cpu_for_target_arch(gn_args['target_cpu'])

    if args.target_os is None:
      if sys.platform.startswith(('cygwin', 'win')):
        gn_args['dart_use_fallback_root_certificates'] = True


    gn_args['dart_custom_version_for_pub'] = 'flutter'

    # Make sure host_cpu matches the bit width of target_cpu.
    target_is_32_bit = gn_args['target_cpu'] == 'arm' or gn_args['target_cpu'] == 'x86'
    if target_is_32_bit:
      gn_args["host_cpu"] = "x86"

    gn_args['flutter_runtime_mode'] = runtime_mode
    gn_args['flutter_aot'] = aot

    if args.target_sysroot:
      gn_args['target_sysroot'] = args.target_sysroot

    if args.toolchain_prefix:
      gn_args['toolchain_prefix'] = args.toolchain_prefix

    goma_dir = os.environ.get('GOMA_DIR')
    goma_home_dir = os.path.join(os.getenv('HOME', ''), 'goma')
    if args.goma and goma_dir:
      gn_args['use_goma'] = True
      gn_args['goma_dir'] = goma_dir
    elif args.goma and os.path.exists(goma_home_dir):
      gn_args['use_goma'] = True
      gn_args['goma_dir'] = goma_home_dir
    else:
      gn_args['use_goma'] = False
      gn_args['goma_dir'] = None

    if args.enable_vulkan:
      # Enable vulkan in the Flutter shell.
      gn_args['shell_enable_vulkan'] = True
      # Configure Skia for Vulkan support.
      gn_args['skia_use_vulkan'] = True
      gn_args['skia_vulkan_header'] = "flutter/vulkan/skia_vulkan_header.h"

    # We should not need a special case for x86, but this seems to introduce text relocations
    # even with -fPIC everywhere.
    # gn_args['enable_profiling'] = args.runtime_mode != 'release' and args.android_cpu != 'x86'

    return gn_args

def parse_args(args):
  args = args[1:]
  parser = argparse.ArgumentParser(description='A script run` gn gen`.')

  parser.add_argument('--unoptimized', default=False, action='store_true')

  parser.add_argument('--runtime-mode', type=str, choices=['debug', 'profile', 'release'], default='debug')
  parser.add_argument('--dynamic', default=False, action='store_true')
  parser.add_argument('--interpreter', default=False, action='store_true')

  parser.add_argument('--target-os', type=str, choices=['android', 'ios', 'linux'])
  parser.add_argument('--android', dest='target_os', action='store_const', const='android')
  parser.add_argument('--android-cpu', type=str, choices=['arm', 'x64', 'x86', 'arm64'], default='arm')
  parser.add_argument('--ios', dest='target_os', action='store_const', const='ios')
  parser.add_argument('--ios-cpu', type=str, choices=['arm', 'arm64'], default='arm64')
  parser.add_argument('--simulator', action='store_true', default=False)
  parser.add_argument('--linux-cpu', type=str, choices=['x64', 'x86', 'arm64'])

  parser.add_argument('--goma', default=True, action='store_true')
  parser.add_argument('--no-goma', dest='goma', action='store_false')

  parser.add_argument('--lto', default=True, action='store_true')
  parser.add_argument('--no-lto', dest='lto', action='store_false')

  parser.add_argument('--clang', default=True, action='store_true')
  parser.add_argument('--no-clang', dest='clang', action='store_false')

  parser.add_argument('--target-sysroot', type=str)
  parser.add_argument('--toolchain-prefix', type=str)

  parser.add_argument('--use-glfw', action='store_true', default=False)
  parser.add_argument('--enable-vulkan', action='store_true', default=False)

  return parser.parse_args(args)

def main(argv):
  args = parse_args(argv)

  if sys.platform.startswith(('cygwin', 'win')):
    subdir = 'win'
  elif sys.platform == 'darwin':
    subdir = 'mac'
  elif sys.platform.startswith('linux'):
     subdir = 'linux64'
  else:
    raise Error('Unknown platform: ' + sys.platform)

  command = [
    '%s/buildtools/%s/gn' % (SRC_ROOT, subdir),
    'gen',
    '--check',
  ]

  if sys.platform == 'darwin':
    # On the Mac, also generate Xcode projects for ease of editing.
    command.append('--ide=xcode')

  if sys.platform.startswith('win'):
    # On Windows, also generate Visual Studio project for ease of editing.
    command.append('--ide=vs')

  gn_args = to_command_line(to_gn_args(args))
  out_dir = get_out_dir(args)
  print "gn gen --check in %s" % out_dir
  command.append(out_dir)
  command.append('--args=%s' % ' '.join(gn_args))
  gn_call_result = subprocess.call(command, cwd=SRC_ROOT)

  if gn_call_result == 0:
    # Generate/Replace the compile commands database in out.
    compile_cmd_gen_cmd = [
      'ninja',
      '-C',
      out_dir,
      '-t',
      'compdb',
      'cc',
      'cxx',
      'objc',
      'objcxx',
      'asm',
    ]

    contents = subprocess.check_output(compile_cmd_gen_cmd, cwd=SRC_ROOT)
    compile_commands = open('%s/out/compile_commands.json' % SRC_ROOT, 'w+')
    compile_commands.write(contents)
    compile_commands.close()

  return gn_call_result

if __name__ == '__main__':
    sys.exit(main(sys.argv))