// Copyright (c) 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.

#include "tools/gn/functions.h"

#include <iostream>

#include "base/strings/string_util.h"
#include "tools/gn/config.h"
#include "tools/gn/config_values_generator.h"
#include "tools/gn/err.h"
#include "tools/gn/input_file.h"
#include "tools/gn/item_tree.h"
#include "tools/gn/parse_tree.h"
#include "tools/gn/scheduler.h"
#include "tools/gn/scope.h"
#include "tools/gn/settings.h"
#include "tools/gn/target_manager.h"
#include "tools/gn/token.h"
#include "tools/gn/value.h"

namespace {

void FillNeedsBlockError(const FunctionCallNode* function, Err* err) {
  *err = Err(function->function(), "This function call requires a block.",
      "The block's \"{\" must be on the same line as the function "
      "call's \")\".");
}

Value ExecuteAssert(const FunctionCallNode* function,
                    const std::vector<Value>& args,
                    Err* err) {
  if (args.size() != 1) {
    *err = Err(function->function(), "Wrong number of arguments.",
               "assert() takes one argument, "
               "were you expecting somethig else?");
  } else if (args[0].InterpretAsInt() == 0) {
    *err = Err(function->function(), "Assertion failed.");
    if (args[0].origin()) {
      // If you do "assert(foo)" we'd ideally like to show you where foo was
      // set, and in this case the origin of the args will tell us that.
      // However, if you do "assert(foo && bar)" the source of the value will
      // be the assert like, which isn't so helpful.
      //
      // So we try to see if the args are from the same line or not. This will
      // break if you do "assert(\nfoo && bar)" and we may show the second line
      // as the source, oh well. The way around this is to check to see if the
      // origin node is inside our function call block.
      Location origin_location = args[0].origin()->GetRange().begin();
      if (origin_location.file() != function->function().location().file() ||
          origin_location.line_number() !=
              function->function().location().line_number()) {
        err->AppendSubErr(Err(args[0].origin()->GetRange(), "",
                              "This is where it was set."));
      }
    }
  }
  return Value();
}

Value ExecuteConfig(Scope* scope,
                    const FunctionCallNode* function,
                    const std::vector<Value>& args,
                    Err* err) {
  if (!EnsureSingleStringArg(function, args, err) ||
      !EnsureNotProcessingImport(function, scope, err))
    return Value();

  Label label(MakeLabelForScope(scope, function, args[0].string_value()));

  if (g_scheduler->verbose_logging())
    g_scheduler->Log("Generating config", label.GetUserVisibleName(true));

  // Create the empty config object.
  ItemTree* tree = &scope->settings()->build_settings()->item_tree();
  Config* config = Config::GetConfig(scope->settings(), function->GetRange(),
                                     label, NULL, err);
  if (err->has_error())
    return Value();

  // Fill it.
  const SourceDir input_dir = SourceDirForFunctionCall(function);
  ConfigValuesGenerator gen(&config->config_values(), scope,
                            function->function(), input_dir, err);
  gen.Run();
  if (err->has_error())
    return Value();

  // Mark as complete.
  {
    base::AutoLock lock(tree->lock());
    tree->MarkItemGeneratedLocked(label);
  }
  return Value();
}

Value ExecuteDeclareArgs(Scope* scope,
                         const FunctionCallNode* function,
                         const std::vector<Value>& args,
                         Err* err) {
  // Only allow this to be called once. We use a variable in the current scope
  // with a name the parser will reject if the user tried to type it.
  const char did_declare_args_var[] = "@@declared_args";
  if (scope->GetValue(did_declare_args_var)) {
    *err = Err(function->function(), "Duplicate call to declared_args.");
    err->AppendSubErr(
        Err(scope->GetValue(did_declare_args_var)->origin()->GetRange(),
                            "See the original call."));
    return Value();
  }

  // Find the root scope where the values will be set.
  Scope* root = scope->mutable_containing();
  if (!root || root->containing() || !scope->IsProcessingBuildConfig()) {
    *err = Err(function->function(), "declare_args called incorrectly."
        "It must be called only from the build config script and in the "
        "root scope.");
    return Value();
  }

  // Take all variables set in the current scope as default values and put
  // them in the parent scope. The values in the current scope are the defaults,
  // then we apply the external args to this list.
  Scope::KeyValueVector values;
  scope->GetCurrentScopeValues(&values);
  for (size_t i = 0; i < values.size(); i++) {
    // TODO(brettw) actually import the arguments from the command line rather
    // than only using the defaults.
    root->SetValue(values[i].first, values[i].second,
                   values[i].second.origin());
  }

  scope->SetValue(did_declare_args_var, Value(function, 1), NULL);
  return Value();
}

Value ExecuteImport(Scope* scope,
                    const FunctionCallNode* function,
                    const std::vector<Value>& args,
                    Err* err) {
  if (!EnsureSingleStringArg(function, args, err) ||
      !EnsureNotProcessingImport(function, scope, err))
    return Value();

  const SourceDir input_dir = SourceDirForFunctionCall(function);
  SourceFile import_file =
      input_dir.ResolveRelativeFile(args[0].string_value());
  scope->settings()->import_manager().DoImport(import_file, function,
                                               scope, err);
  return Value();
}

Value ExecuteTemplate(Scope* scope,
                      const FunctionCallNode* invocation,
                      const std::vector<Value>& args,
                      BlockNode* block,
                      const FunctionCallNode* rule,
                      Err* err) {
  if (!EnsureNotProcessingImport(invocation, scope, err))
    return Value();
  Scope block_scope(scope);
  if (!FillTargetBlockScope(scope, invocation,
                            invocation->function().value().data(),
                            block, args, &block_scope, err))
    return Value();

  // Run the block for the rule invocation.
  block->ExecuteBlockInScope(&block_scope, err);
  if (err->has_error())
    return Value();

  // Now run the rule itself with that block as the current scope.
  rule->block()->ExecuteBlockInScope(&block_scope, err);
  if (err->has_error())
    return Value();

  return Value();
}

Value ExecuteSetDefaults(Scope* scope,
                         const FunctionCallNode* function,
                         const std::vector<Value>& args,
                         BlockNode* block,
                         Err* err) {
  if (!EnsureSingleStringArg(function, args, err))
    return Value();
  const std::string& target_type(args[0].string_value());

  // Ensure there aren't defaults already set.
  if (scope->GetTargetDefaults(target_type)) {
    *err = Err(function->function(),
               "This target type defaults were already set.");
    return Value();
  }

  // Execute the block in a new scope that has a parent of the containing
  // scope.
  Scope block_scope(scope);
  if (!FillTargetBlockScope(scope, function,
                            function->function().value().data(),
                            block, args, &block_scope, err))
    return Value();

  // Run the block for the rule invocation.
  block->ExecuteBlockInScope(&block_scope, err);
  if (err->has_error())
    return Value();

  // Now copy the values set on the scope we made into the free-floating one
  // (with no containing scope) used to hold the target defaults.
  Scope* dest = scope->MakeTargetDefaults(target_type);
  block_scope.NonRecursiveMergeTo(dest, function, "<SHOULD NOT FAIL>", err);
  return Value();
}

Value ExecuteSetSourcesAssignmentFilter(Scope* scope,
                                        const FunctionCallNode* function,
                                        const std::vector<Value>& args,
                                        Err* err) {
  if (args.size() != 1) {
    *err = Err(function, "set_sources_assignment_filter takes one argument.");
  } else {
    scoped_ptr<PatternList> f(new PatternList);
    f->SetFromValue(args[0], err);
    if (!err->has_error())
      scope->set_sources_assignment_filter(f.Pass());
  }
  return Value();
}

// void print(...)
// prints all arguments to the console separated by spaces.
Value ExecutePrint(const std::vector<Value>& args, Err* err) {
  for (size_t i = 0; i < args.size(); i++) {
    if (i != 0)
      std::cout << " ";
    std::cout << args[i].ToString();
  }
  std::cout << std::endl;
  return Value();
}

}  // namespace

// ----------------------------------------------------------------------------

namespace functions {

const char kAssert[] = "assert";
const char kComponent[] = "component";
const char kConfig[] = "config";
const char kCopy[] = "copy";
const char kCustom[] = "custom";
const char kDeclareArgs[] = "declare_args";
const char kExecScript[] = "exec_script";
const char kExecutable[] = "executable";
const char kGroup[] = "group";
const char kImport[] = "import";
const char kPrint[] = "print";
const char kProcessFileTemplate[] = "process_file_template";
const char kReadFile[] = "read_file";
const char kSetDefaults[] = "set_defaults";
const char kSetDefaultToolchain[] = "set_default_toolchain";
const char kSetSourcesAssignmentFilter[] = "set_sources_assignment_filter";
const char kSharedLibrary[] = "shared_library";
const char kStaticLibrary[] = "static_library";
const char kTemplate[] = "template";
const char kTool[] = "tool";
const char kToolchain[] = "toolchain";
const char kTest[] = "test";
const char kWriteFile[] = "write_file";

}  // namespace functions

// ----------------------------------------------------------------------------

bool EnsureNotProcessingImport(const ParseNode* node,
                               const Scope* scope,
                               Err* err) {
  if (scope->IsProcessingImport()) {
    *err = Err(node, "Not valid from an import.",
        "We need to talk about this thing you are doing here. Doing this\n"
        "kind of thing from an imported file makes me feel like you are\n"
        "abusing me. Imports are for defining defaults, variables, and rules.\n"
        "The appropriate place for this kind of thing is really in a normal\n"
        "BUILD file.");
    return false;
  }
  return true;
}

bool EnsureNotProcessingBuildConfig(const ParseNode* node,
                                    const Scope* scope,
                                    Err* err) {
  if (scope->IsProcessingBuildConfig()) {
    *err = Err(node, "Not valid from the build config.",
        "You can't do this kind of thing from the build config script, "
        "silly!\nPut it in a regular BUILD file.");
    return false;
  }
  return true;
}

bool FillTargetBlockScope(const Scope* scope,
                          const FunctionCallNode* function,
                          const char* target_type,
                          const BlockNode* block,
                          const std::vector<Value>& args,
                          Scope* block_scope,
                          Err* err) {
  if (!block) {
    FillNeedsBlockError(function, err);
    return false;
  }

  // Copy the target defaults, if any, into the scope we're going to execute
  // the block in.
  const Scope* default_scope = scope->GetTargetDefaults(target_type);
  if (default_scope) {
    if (!default_scope->NonRecursiveMergeTo(block_scope, function,
                                            "target defaults", err))
      return false;
  }

  // The name is the single argument to the target function.
  if (!EnsureSingleStringArg(function, args, err))
    return false;

  // Set the target name variable to the current target, and mark it used
  // because we don't want to issue an error if the script ignores it.
  const base::StringPiece target_name("target_name");
  block_scope->SetValue(target_name, Value(function, args[0].string_value()),
                        function);
  block_scope->MarkUsed(target_name);
  return true;
}

bool EnsureSingleStringArg(const FunctionCallNode* function,
                           const std::vector<Value>& args,
                           Err* err) {
  if (args.size() != 1) {
    *err = Err(function->function(), "Incorrect arguments.",
               "This function requires a single string argument.");
    return false;
  }
  return args[0].VerifyTypeIs(Value::STRING, err);
}

const SourceDir& SourceDirForFunctionCall(const FunctionCallNode* function) {
  return function->function().location().file()->dir();
}

const Label& ToolchainLabelForScope(const Scope* scope) {
  return scope->settings()->toolchain()->label();
}

Label MakeLabelForScope(const Scope* scope,
                        const FunctionCallNode* function,
                        const std::string& name) {
  const SourceDir& input_dir = SourceDirForFunctionCall(function);
  const Label& toolchain_label = ToolchainLabelForScope(scope);
  return Label(input_dir, name, toolchain_label.dir(), toolchain_label.name());
}

Value ExecuteFunction(Scope* scope,
                      const FunctionCallNode* function,
                      const std::vector<Value>& args,
                      BlockNode* block,
                      Err* err) {
  const Token& name = function->function();
  if (block) {
    // These target generators need to execute the block themselves.
    if (name.IsIdentifierEqualTo(functions::kComponent))
      return ExecuteComponent(scope, function, args, block, err);
    if (name.IsIdentifierEqualTo(functions::kCustom))
      return ExecuteCustom(scope, function, args, block, err);
    if (name.IsIdentifierEqualTo(functions::kExecutable))
      return ExecuteExecutable(scope, function, args, block, err);
    if (name.IsIdentifierEqualTo(functions::kSetDefaults))
      return ExecuteSetDefaults(scope, function, args, block, err);
    if (name.IsIdentifierEqualTo(functions::kSharedLibrary))
      return ExecuteSharedLibrary(scope, function, args, block, err);
    if (name.IsIdentifierEqualTo(functions::kStaticLibrary))
      return ExecuteStaticLibrary(scope, function, args, block, err);
    if (name.IsIdentifierEqualTo(functions::kGroup))
      return ExecuteGroup(scope, function, args, block, err);
    if (name.IsIdentifierEqualTo(functions::kTest))
      return ExecuteExecutable(scope, function, args, block, err);
    if (name.IsIdentifierEqualTo(functions::kTemplate))
      return ExecuteTemplate(scope, function, args, block, err);
    if (name.IsIdentifierEqualTo(functions::kTool))
      return ExecuteTool(scope, function, args, block, err);
    if (name.IsIdentifierEqualTo(functions::kToolchain))
      return ExecuteToolchain(scope, function, args, block, err);

    const FunctionCallNode* rule =
        scope->GetTemplate(function->function().value().as_string());
    if (rule)
      return ExecuteTemplate(scope, function, args, block, rule, err);

    // FIXME(brettw) This is not right, what if you specify a function that
    // doesn't take a block but specify one?!?!?

    // The rest of the functions can take a pre-executed block for simplicity.
    Scope block_scope(scope);
    block->ExecuteBlockInScope(&block_scope, err);
    if (err->has_error())
      return Value();

    if (name.IsIdentifierEqualTo(functions::kConfig))
      return ExecuteConfig(&block_scope, function, args, err);
    if (name.IsIdentifierEqualTo(functions::kCopy))
      return ExecuteCopy(&block_scope, function, args, err);
    if (name.IsIdentifierEqualTo(functions::kDeclareArgs))
      return ExecuteDeclareArgs(&block_scope, function, args, err);

    *err = Err(name, "Unknown function.");
    return Value();
  }

  if (name.IsIdentifierEqualTo(functions::kAssert))
    return ExecuteAssert(function, args, err);
  if (name.IsIdentifierEqualTo(functions::kExecScript))
    return ExecuteExecScript(scope, function, args, err);
  if (name.IsIdentifierEqualTo(functions::kImport))
    return ExecuteImport(scope, function, args, err);
  if (name.IsIdentifierEqualTo(functions::kPrint))
    return ExecutePrint(args, err);
  if (name.IsIdentifierEqualTo(functions::kProcessFileTemplate))
    return ExecuteProcessFileTemplate(scope, function, args, err);
  if (name.IsIdentifierEqualTo(functions::kReadFile))
    return ExecuteReadFile(scope, function, args, err);
  if (name.IsIdentifierEqualTo(functions::kSetDefaultToolchain))
    return ExecuteSetDefaultToolchain(scope, function, args, err);
  if (name.IsIdentifierEqualTo(functions::kSetSourcesAssignmentFilter))
    return ExecuteSetSourcesAssignmentFilter(scope, function, args, err);
  if (name.IsIdentifierEqualTo(functions::kWriteFile))
    return ExecuteWriteFile(scope, function, args, err);

  *err = Err(function, "Unknown function.");
  return Value();
}