/*
 * Copyright 2016 The Bazel 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.
 */
package com.google.idea.blaze.base.sync.aspects;

import com.google.common.base.Objects;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.idea.blaze.base.async.FutureUtil;
import com.google.idea.blaze.base.async.executor.BlazeExecutor;
import com.google.idea.blaze.base.async.process.ExternalTask;
import com.google.idea.blaze.base.async.process.LineProcessingOutputStream;
import com.google.idea.blaze.base.command.BlazeCommand;
import com.google.idea.blaze.base.command.BlazeCommandName;
import com.google.idea.blaze.base.command.BlazeFlags;
import com.google.idea.blaze.base.command.ExperimentalShowArtifactsLineProcessor;
import com.google.idea.blaze.base.experiments.BoolExperiment;
import com.google.idea.blaze.base.ideinfo.RuleIdeInfo;
import com.google.idea.blaze.base.issueparser.IssueOutputLineProcessor;
import com.google.idea.blaze.base.metrics.Action;
import com.google.idea.blaze.base.model.SyncState;
import com.google.idea.blaze.base.model.primitives.Label;
import com.google.idea.blaze.base.model.primitives.TargetExpression;
import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
import com.google.idea.blaze.base.prefetch.PrefetchService;
import com.google.idea.blaze.base.projectview.ProjectViewSet;
import com.google.idea.blaze.base.scope.BlazeContext;
import com.google.idea.blaze.base.scope.Result;
import com.google.idea.blaze.base.scope.Scope;
import com.google.idea.blaze.base.scope.ScopedFunction;
import com.google.idea.blaze.base.scope.output.PerformanceWarning;
import com.google.idea.blaze.base.scope.output.PrintOutput;
import com.google.idea.blaze.base.scope.scopes.LoggedTimingScope;
import com.google.idea.blaze.base.scope.scopes.TimingScope;
import com.google.idea.blaze.base.settings.Blaze;
import com.google.idea.blaze.base.settings.Blaze.BuildSystem;
import com.google.idea.blaze.base.sync.filediff.FileDiffService;
import com.google.idea.blaze.base.sync.projectview.WorkspaceLanguageSettings;
import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoder;
import com.google.repackaged.devtools.build.lib.ideinfo.androidstudio.AndroidStudioIdeInfo;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.project.Project;

import javax.annotation.Nullable;
import java.io.File;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicLong;

/**
 * Implementation of BlazeIdeInterface based on aspects.
 */
public class BlazeIdeInterfaceAspectsImpl extends BlazeIdeInterface {

  private static final Logger LOG = Logger.getInstance(BlazeIdeInterfaceAspectsImpl.class);
  private static final Label ANDROID_SDK_TARGET = new Label("//third_party/java/android/android_sdk_linux:android");
  private static final FileDiffService fileDiffService = new FileDiffService();
  private static final BoolExperiment USE_SKYLARK_ASPECT = new BoolExperiment("use.skylark.aspect", false);

  static class State implements Serializable {
    private static final long serialVersionUID = 10L;
    ImmutableMap<Label, RuleIdeInfo> ruleMap;
    File androidPlatformDirectory;
    FileDiffService.State fileState = null;
    Map<File, Label> fileToLabel = Maps.newHashMap();
    WorkspaceLanguageSettings workspaceLanguageSettings;
    String aspectStrategyName;
  }

  @Nullable
  @Override
  public IdeResult updateBlazeIdeState(Project project,
                                       BlazeContext context,
                                       WorkspaceRoot workspaceRoot,
                                       ProjectViewSet projectViewSet,
                                       List<TargetExpression> targets,
                                       WorkspaceLanguageSettings workspaceLanguageSettings,
                                       ArtifactLocationDecoder artifactLocationDecoder,
                                       SyncState.Builder syncStateBuilder,
                                       @Nullable SyncState previousSyncState,
                                       boolean requiresAndroidSdk) {
    State prevState = previousSyncState != null ? previousSyncState.get(State.class) : null;

    // If the language filter has changed, redo everything from scratch
    if (prevState != null && !prevState.workspaceLanguageSettings.equals(workspaceLanguageSettings)) {
      prevState = null;
    }

    // If the aspect strategy has changed, redo everything from scratch
    final AspectStrategy aspectStrategy = getAspectStrategy();
    if (prevState != null && !Objects.equal(prevState.aspectStrategyName, aspectStrategy.getName())) {
      prevState = null;
    }

    List<File> fileList = getIdeInfo(project, context, workspaceRoot, projectViewSet, targets, aspectStrategy, requiresAndroidSdk);
    if (!context.shouldContinue()) {
      return null;
    }

    List<File> updatedFiles = Lists.newArrayList();
    List<File> removedFiles = Lists.newArrayList();
    FileDiffService.State fileState = fileDiffService.updateFiles(
      prevState != null ? prevState.fileState : null,
      fileList,
      updatedFiles,
      removedFiles
    );
    if (fileState == null) {
      return null;
    }

    context.output(new PrintOutput(String.format(
      "Total rules: %d, new/changed: %d, removed: %d",
      fileList.size(),
      updatedFiles.size(),
      removedFiles.size()
    )));

    ListenableFuture<?> prefetchFuture = PrefetchService.getInstance().prefetchFiles(updatedFiles, true);
    if (!FutureUtil.waitForFuture(context, prefetchFuture)
      .timed("FetchAspectOutput")
      .run()
      .success()) {
      return null;
    }

    State state = updateState(
      context,
      prevState,
      fileState,
      workspaceLanguageSettings,
      artifactLocationDecoder,
      aspectStrategy,
      updatedFiles,
      removedFiles
    );
    if (state == null) {
      return null;
    }
    if (state.androidPlatformDirectory == null && requiresAndroidSdk) {
      LOG.error("Android platform directory not found.");
      return null;
    }
    syncStateBuilder.put(State.class, state);
    return new IdeResult(state.ruleMap, state.androidPlatformDirectory);
  }

  private static List<File> getIdeInfo(Project project,
                                       BlazeContext parentContext,
                                       WorkspaceRoot workspaceRoot,
                                       ProjectViewSet projectViewSet,
                                       List<TargetExpression> targets,
                                       AspectStrategy aspectStrategy,
                                       boolean addAndroidSdkTarget) {
    return Scope.push(parentContext, context -> {
      context.push(new TimingScope("ExecuteBlazeCommand"));

      List<File> result = Lists.newArrayList();

      BuildSystem buildSystem = Blaze.getBuildSystem(project);
      BlazeCommand.Builder blazeCommandBuilder = BlazeCommand.builder(buildSystem, BlazeCommandName.BUILD);
      if (addAndroidSdkTarget) {
        blazeCommandBuilder.addTargets(ANDROID_SDK_TARGET);
      }
      blazeCommandBuilder
        .addTargets(targets)
        .addBlazeFlags(BlazeFlags.EXPERIMENTAL_SHOW_ARTIFACTS)
        .addBlazeFlags(BlazeFlags.buildFlags(project, projectViewSet));

      aspectStrategy.modifyIdeInfoCommand(blazeCommandBuilder);

      int retVal = ExternalTask.builder(workspaceRoot, blazeCommandBuilder.build())
        .context(context)
        .stderr(LineProcessingOutputStream.of(
          new ExperimentalShowArtifactsLineProcessor(result, aspectStrategy.getAspectOutputFileExtension()),
          new IssueOutputLineProcessor(project, context, workspaceRoot)
        ))
        .build()
        .run(new LoggedTimingScope(project, Action.BLAZE_BUILD));

      if (retVal != 0) {
        context.setHasError();
      }

      return result;
    });
  }

  private static class RuleIdeInfoOrSdkInfo {
    public File file;
    public RuleIdeInfo ruleIdeInfo;
    public File androidPlatformDirectory;
  }

  @Nullable
  static State updateState(BlazeContext parentContext,
                           @Nullable State prevState,
                           FileDiffService.State fileState,
                           WorkspaceLanguageSettings workspaceLanguageSettings,
                           ArtifactLocationDecoder artifactLocationDecoder,
                           AspectStrategy aspectStrategy,
                           List<File> newFiles,
                           List<File> removedFiles) {
    Result<State> result = Scope.push(parentContext, (ScopedFunction<Result<State>>)context -> {
      context.push(new TimingScope("UpdateRuleMap"));

      State state = new State();
      state.fileState = fileState;
      state.workspaceLanguageSettings = workspaceLanguageSettings;
      state.aspectStrategyName = aspectStrategy.getName();

      Map<Label, RuleIdeInfo> ruleMap = Maps.newHashMap();
      Map<Label, RuleIdeInfo> updatedRules = Maps.newHashMap();
      if (prevState != null) {
        ruleMap.putAll(prevState.ruleMap);
        state.androidPlatformDirectory = prevState.androidPlatformDirectory;
        state.fileToLabel.putAll(prevState.fileToLabel);
      }

      // Update removed
      for (File removedFile : removedFiles) {
        Label label = state.fileToLabel.remove(removedFile);
        if (label != null) {
          ruleMap.remove(label);
        }
      }

      AtomicLong totalSizeLoaded = new AtomicLong(0);

      // Read protos from any new files
      List<ListenableFuture<RuleIdeInfoOrSdkInfo>> futures = Lists.newArrayList();
      for (File file : newFiles) {
        futures.add(submit(() -> {
          RuleIdeInfoOrSdkInfo ruleIdeInfoOrSdkInfo = new RuleIdeInfoOrSdkInfo();
          ruleIdeInfoOrSdkInfo.file = file;

          totalSizeLoaded.addAndGet(file.length());

          AndroidStudioIdeInfo.RuleIdeInfo ruleProto = aspectStrategy.readAspectFile(file);
          if (ruleProto.getLabel().equals(ANDROID_SDK_TARGET.toString())) {
            ruleIdeInfoOrSdkInfo.androidPlatformDirectory = getAndroidPlatformDirectoryFromAndroidTarget(
              ruleProto,
              artifactLocationDecoder
            );
          }
          else {
            ruleIdeInfoOrSdkInfo.ruleIdeInfo = IdeInfoFromProtobuf.makeRuleIdeInfo(
              workspaceLanguageSettings,
              artifactLocationDecoder,
              ruleProto
            );
          }
          return ruleIdeInfoOrSdkInfo;
        }
        ));
      }

      // Update state with result from proto files
      int duplicateRuleLabels = 0;
      try {
        for (RuleIdeInfoOrSdkInfo ruleIdeInfoOrSdkInfo : Futures.allAsList(futures).get()) {
          if (ruleIdeInfoOrSdkInfo.androidPlatformDirectory != null) {
            state.androidPlatformDirectory = ruleIdeInfoOrSdkInfo.androidPlatformDirectory;
          } else if (ruleIdeInfoOrSdkInfo.ruleIdeInfo != null) {
            File file = ruleIdeInfoOrSdkInfo.file;
            Label label = ruleIdeInfoOrSdkInfo.ruleIdeInfo.label;

            RuleIdeInfo previousRule = updatedRules.putIfAbsent(label, ruleIdeInfoOrSdkInfo.ruleIdeInfo);
            if (previousRule == null) {
              state.fileToLabel.put(file, label);
            } else {
              duplicateRuleLabels++;
            }
          }
        }
      }
      catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        return Result.error(null);
      }
      catch (ExecutionException e) {
        return Result.error(e);
      }
      ruleMap.putAll(updatedRules);

      context.output(new PrintOutput(String.format(
        "Loaded %d aspect files, total size %dkB", newFiles.size(), totalSizeLoaded.get() / 1024
      )));
      if (duplicateRuleLabels > 0) {
        context.output(new PerformanceWarning(String.format(
          "There were %d duplicate rules. You may be including multiple configurations in your build. "
          + "Your IDE sync is slowed down by ~%d%%.",
          duplicateRuleLabels,
          (100 * duplicateRuleLabels / ruleMap.size())
        )));
      }

      state.ruleMap = ImmutableMap.copyOf(ruleMap);
      return Result.of(state);
    });

    if (result.error != null) {
      LOG.error(result.error);
      return null;
    }
    return result.result;
  }

  @Nullable
  private static File getAndroidPlatformDirectoryFromAndroidTarget(AndroidStudioIdeInfo.RuleIdeInfo ruleProto,
                                                                   ArtifactLocationDecoder artifactLocationDecoder) {
    if (!ruleProto.hasJavaRuleIdeInfo()) {
      return null;
    }
    AndroidStudioIdeInfo.JavaRuleIdeInfo javaRuleIdeInfo = ruleProto.getJavaRuleIdeInfo();
    if (javaRuleIdeInfo.getJarsCount() == 0) {
      return null;
    }
    AndroidStudioIdeInfo.LibraryArtifact libraryArtifact = javaRuleIdeInfo.getJars(0);
    AndroidStudioIdeInfo.ArtifactLocation artifactLocation = libraryArtifact.getJar();
    if (artifactLocation == null) {
      return null;
    }
    File androidJar = artifactLocationDecoder.decode(artifactLocation).getFile();
    return androidJar.getParentFile();
  }

  private static <T> ListenableFuture<T> submit(Callable<T> callable) {
    return BlazeExecutor.getInstance().submit(callable);
  }

  @Override
  public void resolveIdeArtifacts(Project project,
                                  BlazeContext context,
                                  WorkspaceRoot workspaceRoot,
                                  ProjectViewSet projectViewSet,
                                  List<TargetExpression> targets) {
    AspectStrategy aspectStrategy = getAspectStrategy();

    BlazeCommand.Builder blazeCommandBuilder = BlazeCommand.builder(Blaze.getBuildSystem(project), BlazeCommandName.BUILD)
      .addTargets(targets)
      .addBlazeFlags()
      .addBlazeFlags(BlazeFlags.KEEP_GOING)
      .addBlazeFlags(BlazeFlags.buildFlags(project, projectViewSet));

    aspectStrategy.modifyIdeResolveCommand(blazeCommandBuilder);

    BlazeCommand blazeCommand = blazeCommandBuilder.build();

    int retVal = ExternalTask.builder(workspaceRoot, blazeCommand)
      .context(context)
      .stderr(LineProcessingOutputStream.of(new IssueOutputLineProcessor(project, context, workspaceRoot)))
      .build()
      .run(new LoggedTimingScope(project, Action.BLAZE_BUILD));

    if (retVal != 0) {
      context.setHasError();
    }
  }

  private AspectStrategy getAspectStrategy() {
    return USE_SKYLARK_ASPECT.getValue() ? AspectStrategy.SKYLARK_ASPECT : AspectStrategy.NATIVE_ASPECT;
  }
}