/*
 * Copyright 2013 Google 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.google.gwt.dev;

import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.TreeLogger.Type;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.linker.ArtifactSet;
import com.google.gwt.core.ext.linker.EmittedArtifact;
import com.google.gwt.core.ext.linker.EmittedArtifact.Visibility;
import com.google.gwt.core.linker.SymbolMapsLinker.SourceMapArtifact;
import com.google.gwt.dev.Link.LinkOptions;
import com.google.gwt.dev.cfg.ResourceLoader;
import com.google.gwt.dev.json.JsonArray;
import com.google.gwt.dev.json.JsonException;
import com.google.gwt.dev.json.JsonObject;
import com.google.gwt.dev.util.OutputFileSet;
import com.google.gwt.thirdparty.guava.common.collect.Sets;
import com.google.gwt.thirdparty.guava.common.io.ByteStreams;
import com.google.gwt.thirdparty.guava.common.io.Resources;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.URL;
import java.util.LinkedHashSet;
import java.util.Set;

/**
 * SourceSaver writes source code useful for a debugger.
 */
class SourceSaver {

  /**
   * Copies all source files referenced in at least one sourcemap to the appropriate destination.
   *
   * @param artifacts contains the sourcemaps we need source code for
   *   and also generated source code to copy.
   * @param loader contains the non-generated source code
   * @param modulePrefix a prefix to add to a source file's path when writing it.
   */
  static void save(TreeLogger logger, ArtifactSet artifacts, ResourceLoader loader,
      LinkOptions options, String modulePrefix, OutputFileSet extraFileSet)
      throws IOException, UnableToCompleteException {

    // First scan artifacts for useful files.

    Set<EmittedArtifact> genFiles = new LinkedHashSet<EmittedArtifact>();
    Set<EmittedArtifact> sourceMaps = new LinkedHashSet<EmittedArtifact>();
    for (EmittedArtifact candidate : artifacts.find(EmittedArtifact.class)) {

      if (candidate.getVisibility() == Visibility.Source) {
        genFiles.add(candidate);
        continue;
      }

      boolean isSourceMap =
          SourceMapArtifact.isSourceMapFile.matcher(candidate.getPartialPath()).find();
      if (isSourceMap) {
        sourceMaps.add(candidate);
      }
    }

    if (sourceMaps.isEmpty()) {
      logger.log(Type.WARN, "Not saving source because sourcemaps weren't generated. " +
          "Hint: set compiler.useSourceMaps.");
      return;
    }

    boolean saveInExtras = options.getSaveSourceOutput() == null ||
        options.getSaveSourceOutput().equals(options.getExtraDir());

    OutputFileSet out;
    if (saveInExtras) {
      out = extraFileSet;
      logger.log(Type.INFO, "Saving source with extras");
    } else {
      out = Link.chooseOutputFileSet(options.getSaveSourceOutput(), modulePrefix);
      logger.log(Type.INFO, "Saving source to " + options.getSaveSourceOutput());
    }

    try {
      copySources(logger, sourceMaps, genFiles, loader, out, "src/");
    } finally {
      if (!saveInExtras) {
        out.close();
      }
    }
  }

  private static void copySources(TreeLogger logger,
      Set<EmittedArtifact> sourceMaps,
      Set<EmittedArtifact> genFiles, ResourceLoader loader,
      OutputFileSet dest, String destPrefix)
      throws UnableToCompleteException {

    Set<String> filesInSourceMap = getSourcePaths(logger, sourceMaps);

    // All files in the source map should be either be resources (input source files) or
    // in the ArtifactSet (generated files). Try both places and log a warning if we
    // can't find it anywhere.

    // First, copy input source files..
    Set<String> remainingFiles = Sets.newLinkedHashSet();
    for (String path : filesInSourceMap) {
      try {
        if (!copySourceFile(path, loader, dest, destPrefix)) {
          remainingFiles.add(path);
        }
      } catch (IOException e) {
        logger.log(Type.ERROR, "Unable to copy source file: " + path, e);
        throw new UnableToCompleteException();
      }
    }

    // Next, copy generated files.
    for (EmittedArtifact candidate : genFiles) {
      if (!remainingFiles.contains(candidate.getPartialPath())) {
        // This file was generated but not used according to the sourcemap.
        // Perhaps an interface? Anyway we don't need it for debugging.
        continue;
      }
      copyGeneratedFile(logger, candidate, dest, destPrefix);
      remainingFiles.remove(candidate.getPartialPath());
    }

    // Nothing should be left. If there is, log a warning.
    if (!remainingFiles.isEmpty()) {
      logger.log(Type.WARN, "Unable to find all source code needed by debuggers. " +
          remainingFiles.size() + " files from sourcemaps weren't found.");
      if (logger.isLoggable(Type.DEBUG)) {
        TreeLogger missing = logger.branch(Type.DEBUG, "Missing files:");
        int filesPrinted = 0;
        for (String path : remainingFiles) {
          if (filesPrinted >= 100) {
            missing.log(Type.DEBUG, "(truncated)");
            break;
          }
          missing.log(Type.DEBUG, path);
          filesPrinted++;
        }
      }
    }
  }

  /**
   * Finds the path of each source file that contributed to at least one sourcemap.
   */
  private static Set<String> getSourcePaths(TreeLogger logger, Set<EmittedArtifact> sourceMaps)
      throws UnableToCompleteException {
    Set<String> sourceFiles = new LinkedHashSet<String>();
    for (EmittedArtifact map : sourceMaps) {
      // TODO maybe improve performance by not re-reading the sourcemap files.
      // (We'd need another way for SourceMapRecorder to pass the list of files here.)
      JsonObject json = loadSourceMap(logger, map);
      JsonArray sources = json.get("sources").asArray();
      for (int i = 0; i < sources.getLength(); i++) {
        sourceFiles.add(sources.get(i).asString().getString());
      }
    }
    return sourceFiles;
  }

  /**
   * Reads a sourcemap as a JSON object.
   */
  private static JsonObject loadSourceMap(TreeLogger logger, EmittedArtifact sourceMap)
      throws UnableToCompleteException {
    JsonObject json;
    try {
      InputStream bytes = sourceMap.getContents(logger);
      try {
        json = JsonObject.parse(new InputStreamReader(bytes));
      } finally {
        bytes.close();
      }
    } catch (JsonException e) {
      logger.log(Type.ERROR, "Unable to parse sourcemap: " + sourceMap.getPartialPath(), e);
      throw new UnableToCompleteException();
    } catch (IOException e) {
      logger.log(Type.ERROR, "Unable to read sourcemap: " + sourceMap.getPartialPath(), e);
      throw new UnableToCompleteException();
    }
    return json;
  }

  /**
   * Copies a source file from the module to a directory or jar.
   * Returns false if the source file wasn't found.
   */
  private static boolean copySourceFile(String path, ResourceLoader loader,
      OutputFileSet dest, String destPrefix) throws IOException {

    URL resource = loader.getResource(path);
    if (resource == null) {
      return false;
    }

    try (InputStream resourceAsStream = Resources.asByteSource(resource).openStream();
        OutputStream out = dest.openForWrite(destPrefix + path);) {
      ByteStreams.copy(resourceAsStream, out);
    }

    return true;
  }

  private static void copyGeneratedFile(TreeLogger log, EmittedArtifact src,
      OutputFileSet dest, String destPrefix) throws UnableToCompleteException {

    String newPath = destPrefix + src.getPartialPath();
    try {
      OutputStream out = dest.openForWrite(newPath, src.getLastModified());
      try {
        src.writeTo(log, out);
      } finally {
        out.close();
      }
    } catch (IOException e) {
      log.log(TreeLogger.WARN, "Error emitting artifact: " + newPath, e);
    }
  }
}