#!/usr/bin/python
# Copyright (c) 2011 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 optparse
import os
import re
import shutil
import subprocess
import sys


# Where things are in relation to this script.
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
SRC_DIR = os.path.dirname(SCRIPT_DIR)
NACL_DIR = os.path.join(SRC_DIR, 'native_client')

# Pathing to the two command_buffer directories (relative to native_client).
NACL_CMD_BUFFER_DIR = os.path.join('src', 'shared',
                                   'ppapi_proxy', 'command_buffer')
GPU_CMD_BUFFER_DIR = os.path.join('..', 'gpu', 'command_buffer')

# Pathing to mirror of nacl tree in ppapi.
PPAPI_NACL_DIR = os.path.join(SRC_DIR, 'ppapi', 'native_client')


def RelativePath(path, base):
  """Find the relative path.

  Arguments:
    path: path we want a relative path to.
    base: path we want a relative path from.
  Returns:
    The relative path from base to path.
  """
  path = os.path.abspath(path)
  base = os.path.abspath(base)
  path_parts = path.split(os.sep)
  base_parts = base.split(os.sep)
  while path_parts and base_parts and path_parts[0] == base_parts[0]:
    path_parts = path_parts[1:]
    base_parts = base_parts[1:]
  rel_parts = ['..'] * len(base_parts) + path_parts
  return os.sep.join(rel_parts)


def PrintInputs(platforms):
  """Print all the transitive inputs required to build the IRT.

  Arguments:
    platforms: list of platform names to build for.
  """
  inputs = set()
  for platform in platforms:
    # Invoke scons to get dependency tree.
    cmd = [
        sys.executable, 'scons.py', '-n', '--tree=all',
        '--mode=nacl', 'platform=' + platform,
        'scons-out/nacl_irt-' + platform + '/staging/irt.nexe',
    ]
    p = subprocess.Popen(cmd, cwd=NACL_DIR,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE)
    (p_stdout, p_stderr) = p.communicate()
    # If things fail on windows, try running --help, if that fails,
    # emit this script as an input (to satiate gyp), and assume we're being
    # run on a test only bot.
    # TODO(bradnelson): add plumbing to the buildbots to allow this script
    #     to know its on a test only bot + make scons return a _particular_
    #     return code so we can detect this kind of fail in one step.
    if p.returncode != 0 and sys.platform == 'win32':
      cmd = [sys.executable, 'scons.py', '--help']
      p = subprocess.Popen(cmd, cwd=NACL_DIR,
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE)
      (p_stdout, p_stderr) = p.communicate()
      if p.returncode !=0:
        # If scons can't even run, emit just this script as an input.
        # See comment above this one.
        print RelativePath(__file__, SCRIPT_DIR).replace(os.sep, '/')
        return
    if p.returncode != 0:
      sys.exit(2)
    # Extract unique inputs.
    for line in p_stdout.splitlines():
      m = re.match('^[ -+|]*\+\-(.+)', line)
      if not m:
        continue
      filename = m.group(1)
      if '[' in filename:
        continue
      if filename.startswith('scons-out'):
        continue
      if filename.endswith('.nexe'):
        continue
      # Apply the underlay of gpu/command_buffer (to match scons).
      if filename.startswith(NACL_CMD_BUFFER_DIR + os.sep):
        filename = GPU_CMD_BUFFER_DIR + filename[len(NACL_CMD_BUFFER_DIR):]
      # Apply the underlay of ppapi (to match scons).
      if (not os.path.exists(os.path.join(NACL_DIR, filename)) and
          os.path.exists(os.path.join(PPAPI_NACL_DIR, filename))):
        filename = '../ppapi/native_client/' + filename
      inputs.add(filename)
  # Check that everything exists and make it script relative.
  # Exclude things above SRC_DIR.
  rel_inputs = set()
  for f in inputs:
    nf = os.path.join(NACL_DIR, f)
    if not os.path.exists(nf):
      raise Exception('missing input file "%s"' % nf)
    # If the relative path from SRC_DIR to the file starts with ../ ignore it.
    # (i.e. the file is outside the client).
    if RelativePath(nf, SRC_DIR).startswith('..' + os.sep):
      continue
    rel_inputs.add(RelativePath(nf, SCRIPT_DIR).replace(os.sep, '/'))
  # Print it sorted.
  rel_inputs = sorted(list(rel_inputs))
  for f in rel_inputs:
    print f


def BuildIRT(platforms, out_dir):
  """Build the IRT for several platforms.

  Arguments:
    platforms: list of platform names to build for.
    out_dir: directory to output the IRT to.
  """
  # Make out_dir absolute.
  out_dir = os.path.abspath(out_dir)
  # Clean.
  scons_out = os.path.join(NACL_DIR, 'scons-out')
  if os.path.exists(scons_out):
    shutil.rmtree(scons_out)
  # Build for each platform.
  for platform in platforms:
    cmd = [
        sys.executable, 'scons.py', '--verbose', '-j8',
        '--mode=nacl', 'platform=' + platform,
        'scons-out/nacl_irt-' + platform + '/staging/irt.nexe',
    ]
    print 'Running: ' + ' '.join(cmd)
    # Work around the fact that python's readline module (used by scons),
    # attempts to alter file handle state on stdin in a way that blocks if
    # a process is not a member of a foreground job on a tty on OSX.
    # e.g. On a Mac:
    #
    # hydric:test mseaborn$ python -c 'import readline' &
    # [1] 67058
    # hydric:test mseaborn$
    # [1]+  Stopped                 python -c 'import readline'
    #
    # i.e. the process receives a stop signal when it's a background job.
    if sys.platform == 'darwin':
      devnull = open(os.devnull, 'r')
    else:
      devnull = None
    p = subprocess.Popen(cmd, cwd=NACL_DIR, stdin=devnull)
    p.wait()
    if p.returncode != 0:
      sys.exit(3)
  # Copy out each platform after stripping.
  for platform in platforms:
    uplatform = platform.replace('-', '_')
    platform2 = {'x86-32': 'i686', 'x86-64': 'x86_64'}.get(platform, platform)
    cplatform = {
        'win32': 'win',
        'cygwin': 'win',
        'darwin': 'mac',
    }.get(sys.platform, 'linux')
    nexe = os.path.join(out_dir, 'nacl_irt_' + uplatform + '.nexe')
    cmd = [
      '../native_client/toolchain/' + cplatform + '_x86_newlib/bin/' +
          platform2 + '-nacl-strip',
      '--strip-debug',
      '../native_client/scons-out/nacl_irt-' + platform + '/staging/irt.nexe',
      '-o', nexe
    ]
    print 'Running: ' + ' '.join(cmd)
    p = subprocess.Popen(cmd, cwd=SCRIPT_DIR)
    p.wait()
    if p.returncode != 0:
      sys.exit(4)


def Main(argv):
  parser = optparse.OptionParser()
  parser.add_option('--inputs', dest='inputs', default=False,
                    action='store_true',
                    help='only emit the transitive inputs to the irt build')
  parser.add_option('--platform', dest='platforms', action='append',
                    default=[],
                    help='add a platform to build for (x86-32|x86-64)')
  parser.add_option('--outdir', dest='outdir',
                    help='directory to out irt to')
  (options, args) = parser.parse_args(argv[1:])
  if args or not options.platforms or (
      not options.inputs and not options.outdir):
    parser.print_help()
    sys.exit(1)

  if options.inputs:
    PrintInputs(options.platforms)
  else:
    BuildIRT(options.platforms, options.outdir)


if __name__ == '__main__':
  Main(sys.argv)