/*
 * Copyright 2014-present Facebook, Inc.
 *
 * 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.
 */

package com.facebook.buck.cxx;

import com.facebook.buck.graph.AbstractBreadthFirstTraversal;
import com.facebook.buck.model.BuildTarget;
import com.facebook.buck.model.BuildTargets;
import com.facebook.buck.model.Flavor;
import com.facebook.buck.model.ImmutableFlavor;
import com.facebook.buck.rules.BuildRule;
import com.facebook.buck.rules.BuildRuleParams;
import com.facebook.buck.rules.BuildRuleResolver;
import com.facebook.buck.rules.BuildRuleType;
import com.facebook.buck.rules.BuildRules;
import com.facebook.buck.rules.BuildTargetSourcePath;
import com.facebook.buck.rules.ImmutableBuildRuleType;
import com.facebook.buck.rules.SourcePath;
import com.facebook.buck.rules.SourcePathResolver;
import com.facebook.buck.rules.SymlinkTree;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.base.Suppliers;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSortedSet;
import com.google.common.collect.Maps;

import java.nio.file.Path;
import java.util.AbstractMap;
import java.util.Map;

public class CxxPreprocessables {

  private CxxPreprocessables() {}

  private static final BuildRuleType HEADER_SYMLINK_TREE_TYPE =
      ImmutableBuildRuleType.of("header_symlink_tree");

  private static final BuildRuleType PREPROCESS_TYPE = ImmutableBuildRuleType.of("preprocess");

  /**
   * Resolve the map of name to {@link SourcePath} to a map of full header name to
   * {@link SourcePath}.
   */
  public static ImmutableMap<Path, SourcePath> resolveHeaderMap(
      Path basePath,
      ImmutableMap<String, SourcePath> headers) {

    ImmutableMap.Builder<Path, SourcePath> headerMap = ImmutableMap.builder();

    // Resolve the "names" of the headers to actual paths by prepending the base path
    // specified by the build target.
    for (ImmutableMap.Entry<String, SourcePath> ent : headers.entrySet()) {
      Path path = basePath.resolve(ent.getKey());
      headerMap.put(path, ent.getValue());
    }

    return headerMap.build();
  }

  /**
   * Find and return the {@link CxxPreprocessorInput} objects from {@link CxxPreprocessorDep}
   * found while traversing the dependencies starting from the {@link BuildRule} objects given.
   */
  public static CxxPreprocessorInput getTransitiveCxxPreprocessorInput(
      final CxxPlatform cxxPlatform,
      Iterable<? extends BuildRule> inputs,
      final Predicate<Object> traverse)
      throws CxxPreprocessorInput.ConflictingHeadersException {

    // We don't really care about the order we get back here, since headers shouldn't
    // conflict.  However, we want something that's deterministic, so sort by build
    // target.
    final Map<BuildTarget, CxxPreprocessorInput> deps = Maps.newTreeMap();

    // Build up the map of all C/C++ preprocessable dependencies.
    AbstractBreadthFirstTraversal<BuildRule> visitor =
        new AbstractBreadthFirstTraversal<BuildRule>(inputs) {
          @Override
          public ImmutableSet<BuildRule> visit(BuildRule rule) {
            if (rule instanceof CxxPreprocessorDep) {
              CxxPreprocessorDep dep = (CxxPreprocessorDep) rule;
              Preconditions.checkState(!deps.containsKey(rule.getBuildTarget()));
              deps.put(rule.getBuildTarget(), dep.getCxxPreprocessorInput(cxxPlatform));
            }
            return traverse.apply(rule) ? rule.getDeps() : ImmutableSet.<BuildRule>of();
          }
        };
    visitor.start();

    // Grab the cxx preprocessor inputs and return them.
    return CxxPreprocessorInput.concat(deps.values());
  }

  public static CxxPreprocessorInput getTransitiveCxxPreprocessorInput(
      final CxxPlatform cxxPlatform,
      Iterable<? extends BuildRule> inputs)
      throws CxxPreprocessorInput.ConflictingHeadersException {
    return getTransitiveCxxPreprocessorInput(
        cxxPlatform,
        inputs,
        Predicates.instanceOf(CxxPreprocessorDep.class));
  }

  /**
   * Build the {@link SymlinkTree} rule using the original build params from a target node.
   * In particular, make sure to drop all dependencies from the original build rule params,
   * as these are modeled via {@link CxxCompile}.
   */
  public static SymlinkTree createHeaderSymlinkTreeBuildRule(
      SourcePathResolver resolver,
      BuildTarget target,
      BuildRuleParams params,
      Path root,
      ImmutableMap<Path, SourcePath> links) {

    return new SymlinkTree(
        params.copyWithChanges(
            HEADER_SYMLINK_TREE_TYPE,
            target,
            // Symlink trees never need to depend on anything.
            Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of()),
            Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of())),
        resolver,
        root,
        links);
  }

  /**
   * @return the preprocessed file name for the given source name.
   */
  private static String getOutputName(CxxSource.Type type, String name) {

    String extension;
    switch (type) {
      case ASSEMBLER_WITH_CPP:
        extension = "s";
        break;
      case C:
        extension = "i";
        break;
      case CXX:
        extension = "ii";
        break;
      case OBJC:
        extension = "mi";
        break;
      case OBJCXX:
        extension = "mii";
        break;
      // $CASES-OMITTED$
      default:
        throw new IllegalStateException(String.format("unexpected type: %s", type));
    }

    return name + "." + extension;
  }

  /**
   * @return a {@link BuildTarget} used for the rule that preprocesses the source by the given
   *     name and type.
   */
  public static BuildTarget createPreprocessBuildTarget(
      BuildTarget target,
      Flavor platform,
      CxxSource.Type type,
      boolean pic,
      String name) {
    return BuildTarget
        .builder(target)
        .addFlavors(platform)
        .addFlavors(
            ImmutableFlavor.of(
                String.format(
                    "preprocess-%s%s",
                    pic ? "pic-" : "",
                    getOutputName(type, name)
                        .replace('/', '-')
                        .replace('.', '-')
                        .replace('+', '-')
                        .replace(' ', '-'))))
        .build();
  }

  /**
   * @return the output path for an object file compiled from the source with the given name.
   */
  public static Path getPreprocessOutputPath(BuildTarget target, CxxSource.Type type, String name) {
    return BuildTargets.getBinPath(target, "%s").resolve(getOutputName(type, name));
  }

  /**
   * Generate a build rule that preprocesses the given source.
   *
   * @return a pair of the output name and source.
   */
  public static Map.Entry<String, CxxSource> createPreprocessBuildRule(
      BuildRuleParams params,
      BuildRuleResolver resolver,
      CxxPlatform cxxPlatform,
      CxxPreprocessorInput preprocessorInput,
      boolean pic,
      String name,
      CxxSource source) {

    SourcePathResolver pathResolver = new SourcePathResolver(resolver);

    ImmutableSortedSet.Builder<BuildRule> dependencies = ImmutableSortedSet.naturalOrder();

    // If a build rule generates our input source, add that as a dependency.
    dependencies.addAll(pathResolver.filterBuildRuleInputs(ImmutableList.of(source.getPath())));

    // Depend on the rule that generates the sources and headers we're compiling.
    dependencies.addAll(
        pathResolver.filterBuildRuleInputs(
            ImmutableList.<SourcePath>builder()
                .add(source.getPath())
                .addAll(preprocessorInput.getIncludes().getPrefixHeaders())
                .addAll(preprocessorInput.getIncludes().getNameToPathMap().values())
                .build()));

    // Also add in extra deps from the preprocessor input, such as the symlink tree
    // rules.
    dependencies.addAll(
        BuildRules.toBuildRulesFor(
            params.getBuildTarget(),
            resolver,
            preprocessorInput.getRules(),
            false));

    Tool preprocessor;
    ImmutableList.Builder<String> args = ImmutableList.builder();
    CxxSource.Type outputType;

    // We explicitly identify our source rather then let the compiler guess based on the
    // extension.
    args.add("-x", source.getType().getLanguage());

    // Pick the compiler to use.  Basically, if we're dealing with C++ sources, use the C++
    // compiler, and the C compiler for everything.
    switch (source.getType()) {
      case ASSEMBLER_WITH_CPP:
        preprocessor = cxxPlatform.getAspp();
        args.addAll(cxxPlatform.getAsppflags());
        args.addAll(
            preprocessorInput.getPreprocessorFlags().get(CxxSource.Type.ASSEMBLER_WITH_CPP));
        outputType = CxxSource.Type.ASSEMBLER;
        break;
      case C:
        preprocessor = cxxPlatform.getCpp();
        args.addAll(cxxPlatform.getCppflags());
        args.addAll(preprocessorInput.getPreprocessorFlags().get(CxxSource.Type.C));
        outputType = CxxSource.Type.C_CPP_OUTPUT;
        break;
      case CXX:
        preprocessor = cxxPlatform.getCxxpp();
        args.addAll(cxxPlatform.getCxxppflags());
        args.addAll(preprocessorInput.getPreprocessorFlags().get(CxxSource.Type.CXX));
        outputType = CxxSource.Type.CXX_CPP_OUTPUT;
        break;
      case OBJC:
        preprocessor = cxxPlatform.getCpp();
        args.addAll(cxxPlatform.getCppflags());
        args.addAll(preprocessorInput.getPreprocessorFlags().get(CxxSource.Type.OBJC));
        outputType = CxxSource.Type.OBJC_CPP_OUTPUT;
        break;
      case OBJCXX:
        preprocessor = cxxPlatform.getCxxpp();
        args.addAll(cxxPlatform.getCxxppflags());
        args.addAll(preprocessorInput.getPreprocessorFlags().get(CxxSource.Type.OBJCXX));
        outputType = CxxSource.Type.OBJCXX_CPP_OUTPUT;
        break;
      // $CASES-OMITTED$
      default:
        throw new IllegalStateException(String.format("unexpected type: %s", source.getType()));
    }

    // Add dependencies on any build rules used to create the preprocessor.
    dependencies.addAll(preprocessor.getBuildRules(pathResolver));

    // If we're using pic, add in the appropriate flag.
    if (pic) {
      args.add("-fPIC");
    }

    // Add custom per-file flags.
    args.addAll(source.getFlags());

    // Build the CxxCompile rule and add it to our sorted set of build rules.
    BuildTarget target =
        createPreprocessBuildTarget(
            params.getBuildTarget(),
            cxxPlatform.getFlavor(),
            source.getType(),
            pic,
            name);
    CxxPreprocess cxxPreprocess = new CxxPreprocess(
        params.copyWithChanges(
            PREPROCESS_TYPE,
            target,
            Suppliers.ofInstance(dependencies.build()),
            Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of())),
        pathResolver,
        preprocessor,
        args.build(),
        getPreprocessOutputPath(target, source.getType(), name),
        source.getPath(),
        ImmutableList.copyOf(preprocessorInput.getIncludeRoots()),
        ImmutableList.copyOf(preprocessorInput.getSystemIncludeRoots()),
        ImmutableList.copyOf(preprocessorInput.getFrameworkRoots()),
        preprocessorInput.getIncludes(),
        cxxPlatform.getDebugPathSanitizer());
    resolver.addToIndex(cxxPreprocess);

    // Return the output name and source pair.
    return new AbstractMap.SimpleEntry<String, CxxSource>(
        name,
        ImmutableCxxSource.of(
            outputType,
            new BuildTargetSourcePath(
                cxxPreprocess.getProjectFilesystem(),
                cxxPreprocess.getBuildTarget()),
            source.getFlags()));
  }

  /**
   * Generate build rules which preprocess the given input sources.
   */
  public static ImmutableMap<String, CxxSource> createPreprocessBuildRules(
      BuildRuleParams params,
      BuildRuleResolver resolver,
      CxxPlatform config,
      CxxPreprocessorInput cxxPreprocessorInput,
      boolean pic,
      ImmutableMap<String, CxxSource> sources) {

    ImmutableMap.Builder<String, CxxSource> preprocessedSources = ImmutableMap.builder();

    for (Map.Entry<String, CxxSource> entry : sources.entrySet()) {
      if (CxxSourceTypes.isPreprocessableType(entry.getValue().getType())) {
        entry = CxxPreprocessables.createPreprocessBuildRule(
            params,
            resolver,
            config,
            cxxPreprocessorInput,
            pic,
            entry.getKey(),
            entry.getValue());
      }
      preprocessedSources.put(entry);
    }

    return preprocessedSources.build();
  }

}