# Copyright 2017 The Cobalt Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Wrapper to generate build files from .gyp files."""

import logging
import os
import shlex
import sys

import _env  # pylint: disable=unused-import
from starboard.tools import build
from starboard.tools import paths
from starboard.tools import platform


def _Dedupe(sequence):
  visited = set()
  return [x for x in sequence if not (x in visited or visited.add(x))]


def _GetHostOS():
  """Returns the name of the hosting OS."""
  host_os_names = {
      'linux2': 'linux',
      'linux3': 'linux',
      'darwin': 'linux',
      'win32': 'win',
  }

  if sys.platform not in host_os_names:
    if sys.platform == 'cygwin':
      logging.error('There may be several incompatibilities when trying to '
                    'build from within cygwin. When using a bash shell is '
                    'preferred, consider using msysgit instead (see '
                    'https://msysgit.github.io).')
    raise RuntimeError('Unsupported platform: %s' % sys.platform)

  return host_os_names[sys.platform]


def _AppendIncludes(includes, args):
  for include in includes:
    args.append('-I{}'.format(include))


def _AppendVariables(variables, args):
  for var in variables:
    args.append('-D{}={}'.format(var, variables[var]))


def _AppendGeneratorVariables(variables, args):
  for var in variables:
    args.append('-G{}={}'.format(var, variables[var]))


class GypRunner(object):
  """Responsible for running GYP."""

  def __init__(self, options):
    options.build_configs = _Dedupe(options.build_configs)
    self.options = options
    self.common_args = []
    self.platform_configuration = build.GetPlatformConfig(options.platform)
    if not self.platform_configuration:
      raise RuntimeError('Unable to load PlatformConfiguration.')

    env_vars = self.platform_configuration.GetEnvironmentVariables()
    self.app_configuration = (
        self.platform_configuration.GetApplicationConfiguration(
            options.application))

    if not self.app_configuration:
      raise RuntimeError('Unable to load an ApplicationConfiguration.')

    app_env_vars = self.app_configuration.GetEnvironmentVariables()
    if app_env_vars:
      env_vars.update(app_env_vars)
    os.environ.update(env_vars)
    self._MakeCommonArguments()

  def BuildConfigs(self):
    """Builds all configs specified in the options."""
    if not self.options.build_configs:
      raise RuntimeError('No build config types specified.')

    for config_name in self.options.build_configs:
      logging.info('Building config: %s', config_name)
      result = self.BuildConfig(config_name)
      if result:
        return result
    return 0

  def BuildConfig(self, config_name):
    """Builds the GYP file for a given config."""

    # Make a copy of the common arguments.
    args = self.common_args[:]

    configuration_variables = {
        # Default deploy script. Certain platforms may choose to change this.
        'include_path_platform_deploy_gypi':
            'starboard/build/default_no_deploy.gypi'
    }
    configuration_variables.update(
        self.platform_configuration.GetVariables(config_name))
    app_variables = self.app_configuration.GetVariables(config_name)
    if app_variables:
      configuration_variables.update(app_variables)
    _AppendVariables(configuration_variables, args)

    # Add the symbolizer path for ASAN to allow translation of callstacks.
    asan_symbolizer_path = ''
    if configuration_variables.get('use_asan', 0) == 1:
      compiler_commandline = shlex.split(os.environ.get('CC', ''))
      for path in compiler_commandline:
        if os.path.isfile(path):
          test_path = os.path.join(os.path.dirname(path), 'llvm-symbolizer')
          if os.path.isfile(test_path):
            asan_symbolizer_path = test_path
            break
    asan_variables = {
        'asan_symbolizer_path': asan_symbolizer_path,
    }
    _AppendVariables(asan_variables, args)

    # Add config specific generator variables.
    generator_config = '{}_{}'.format(self.options.platform, config_name)

    generator_variables = {
        'config': generator_config,
    }
    generator_variables.update(
        self.platform_configuration.GetGeneratorVariables(config_name))
    app_generator_variables = (
        self.app_configuration.GetGeneratorVariables(config_name))
    if app_generator_variables:
      generator_variables.update(app_generator_variables)
    _AppendGeneratorVariables(generator_variables, args)

    build_file = self.options.build_file
    if not build_file:
      build_file = self.app_configuration.GetDefaultTargetBuildFile()

    if not build_file:
      build_file = self.platform_configuration.GetDefaultTargetBuildFile()

    if not build_file:
      raise RuntimeError('Unable to determine target GYP file.')

    # That target build file goes last.
    args.append(build_file)
    logging.debug('GYP arguments: %s', args)
    return build.GetGyp().main(args)

  def _MakeCommonArguments(self):
    """Makes a list of GYP arguments that are common to all configurations."""

    platform_name = self.platform_configuration.GetName()
    if not platform.IsValid(platform_name):
      raise RuntimeError('Invalid platform: %s' % platform_name)

    source_tree_dir = paths.REPOSITORY_ROOT
    self.common_args = [
        # Set the build format.
        '--format={}-{}'.format(self.platform_configuration.GetBuildFormat(),
                                platform_name),

        # Set the depth argument to the top level directory. This will define
        # the DEPTH variable which is the relative path between the directory
        # containing the processed build file and the top level directory.
        '--depth={}'.format(source_tree_dir),

        # Set the top of the source tree.
        '--toplevel-dir={}'.format(source_tree_dir),
    ]

    # Pass through the debug options.
    for debug in self.options.debug:
      self.common_args.append('--debug=%s' % debug)

    if self.options.check:
      self.common_args.append('--check')

    # Append common GYP variables.
    common_variables = {
        'OS': 'starboard',
        'CC_HOST': os.environ.get('CC_HOST', os.environ.get('CC', '')),
        'host_os': _GetHostOS(),
        'starboard_path': os.path.relpath(platform.Get(platform_name).path,
                                          source_tree_dir),
        'starboard_platform_name': platform_name,
    }

    _AppendVariables(common_variables, self.common_args)

    # Append generator variables.
    generator_variables = {
        # Set the output folder name; affects all generators but MSVS.
        'output_dir': 'out',
    }
    _AppendGeneratorVariables(generator_variables, self.common_args)

    # Append GYPI includes which will be included by GYP before any processed
    # build file.
    gyp_includes = [
        os.path.join(paths.REPOSITORY_ROOT, 'starboard', 'build',
                     'base_configuration.gypi'),

        # TODO: Remove dependency on common.gypi by moving the required bits
        # into base_configuration.gypi.
        os.path.join(paths.REPOSITORY_ROOT, 'build', 'common.gypi'),
    ]
    gyp_includes.extend(self.platform_configuration.GetIncludes())
    if self.app_configuration:
      gyp_includes[:0] = self.app_configuration.GetPreIncludes()
      gyp_includes.extend(self.app_configuration.GetPostIncludes())
    _AppendIncludes(gyp_includes, self.common_args)