/*
 * Copyright 2008 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.ant.taskdefs;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.Jar;
import org.apache.tools.zip.ZipExtraField;
import org.apache.tools.zip.ZipOutputStream;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Map;
import java.util.Random;
import java.util.TreeMap;

/**
 * A variation on Jar which handles duplicate entries by only archiving the most
 * recent of any given path. This is done by keeping a map of paths (as shown in
 * the jar file) against {@link EntryInfo} objects identifying the input source
 * and its timestamp. Most of the actual archiving is deferred until archive
 * finalization, when we've decided on the actual de-duplicated set of entries.
 */
public class LatestTimeJar extends Jar {

  /**
   * Metadata about pending entries in the jar, for replacement if newer entries
   * are found. Subclasses of EntryInfo are held in the
   */
  protected abstract class EntryInfo {
    protected long timestamp;
    protected int mode;

    public EntryInfo(long lastModified, int mode) {
      this.timestamp = lastModified;
      this.mode = mode;
    }

    /**
     * Called to actually add the entry to a given zip stream.
     * 
     * @param out
     * @param path
     * @throws IOException
     */
    public abstract void addToZip(ZipOutputStream out, String path)
        throws IOException;

    public long getLastModified() {
      return timestamp;
    }

    public int getMode() {
      return mode;
    }
  }

  /**
   * Metadata about a directory entry.
   */
  protected class DirEntryInfo extends EntryInfo {
    protected File dir;
    protected ZipExtraField extra[];

    public DirEntryInfo(File dir, long touchTime, int mode,
        ZipExtraField extra[]) {
      super(touchTime, mode);
      this.dir = dir;
      this.extra = extra;
    }

    @Override
    public void addToZip(ZipOutputStream out, String path) throws IOException {
      doZipDir(dir, out, path, mode, extra);
    }
  }

  /**
   * Metadata about a file entry.
   */
  protected class FileEntryInfo extends EntryInfo {
    private File tmpFile;
    private File archive;

    public FileEntryInfo(InputStream in, long lastModified, File fromArchive,
        int mode) throws IOException {
      super(lastModified, mode);
      tmpFile = createTempFile("gwtjar", "");
      tmpFile.deleteOnExit();
      OutputStream fos = new FileOutputStream(tmpFile);
      int readLen = in.read(buffer);
      while (readLen > 0) {
        fos.write(buffer, 0, readLen);
        readLen = in.read(buffer);
      }
      fos.close();
      archive = fromArchive;
    }

    @Override
    public void addToZip(ZipOutputStream out, String path) throws IOException {
      FileInputStream inStream = new FileInputStream(tmpFile);
      try {
        doZipFile(inStream, out, path, timestamp, archive, mode);
        tmpFile.delete();
      } finally {
        inStream.close();
      }
    }
  }

  /**
   * Used to generate temporary file names.
   */
  private static long counter = -1;

  /**
   * Creates a temporary file.
   * 
   * @param prefix the file prefix
   * @param suffix the file suffix
   * @return the new file
   * @throws IOException if the file cannot be created
   */
  private static File createTempFile(String prefix, String suffix)
      throws IOException {
    if (suffix == null) {
      suffix = ".tmp";
    }

    // Get the temp file directory.
    File tmpDir = new File(System.getProperty("java.io.tmpdir"));
    tmpDir.mkdirs();

    // Generate a random name.
    if (counter == -1) {
      counter = new Random().nextLong();
    }
    boolean created = false;
    File tmpFile;
    do {
      counter++;
      tmpFile = new File(tmpDir, prefix + Long.toString(counter) + suffix);
      if (!tmpFile.exists()) {
        created = tmpFile.createNewFile();
        if (!created) {
          // If we fail the create the temp file, it must have been created by
          // another thread between lines 161 and 162.  We re-seed to avoid
          // further race conditions.
          counter = new Random().nextLong();
        }
      }
    } while (!created);

    // Create the file.
    tmpFile.createNewFile();
    return tmpFile;
  }

  private byte buffer[] = new byte[16 * 1024];
  private Map<String, EntryInfo> paths = new TreeMap<String, EntryInfo>();

  @Override
  protected void finalizeZipOutputStream(ZipOutputStream out)
      throws IOException, BuildException {
    for (String path : paths.keySet()) {
      paths.get(path).addToZip(out, path);
    }
    super.finalizeZipOutputStream(out);
  }

  @Override
  protected void zipDir(File dir,
      @SuppressWarnings("unused") ZipOutputStream out, String path, int mode,
      ZipExtraField[] extra) throws IOException {
    long thisTouchTime = (dir == null ? 0L : dir.lastModified());
    String dirName = (dir == null ? "<null>" : dir.getAbsolutePath());
    if (shouldReplace(path, thisTouchTime)) {
      if (paths.get(path) != null) {
        log("Obsoleting older " + path + " with " + dirName,
            Project.MSG_VERBOSE);
      }
      paths.put(path, new DirEntryInfo(dir, thisTouchTime, mode, extra));
    } else {
      log("Newer " + path + " already added, skipping " + dirName,
          Project.MSG_VERBOSE);
    }
  }

  @Override
  protected void zipFile(InputStream in,
      @SuppressWarnings("unused") ZipOutputStream out, String path,
      long lastModified, File fromArchive, int mode) throws IOException {

    String desc = (fromArchive == null ? "file" : "file from "
        + fromArchive.getAbsolutePath());

    if (shouldReplace(path, lastModified)) {
      if (paths.get(path) != null) {
        log("Obsoleting older " + path + " with " + desc, Project.MSG_VERBOSE);
      }
      paths.put(path, new FileEntryInfo(in, lastModified, fromArchive, mode));
    } else {
      log("Newer " + path + " already added, skipping " + desc,
          Project.MSG_VERBOSE);
    }
  }

  private void doZipDir(File dir, ZipOutputStream out, String entryName,
      int mode, ZipExtraField[] extra) throws IOException {
    super.zipDir(dir, out, entryName, mode, extra);
  }

  private void doZipFile(InputStream inStream, ZipOutputStream out,
      String entryName, long timestamp, File archive, int mode)
      throws IOException {
    super.zipFile(inStream, out, entryName, timestamp, archive, mode);
  }

  /**
   * Checks whether an entry should be replaced, by touch dates and duplicates
   * setting.
   * 
   * @param path the path of an entry being considered
   * @param touchTime the lastModified of the candiate replacement
   * @return true if the file should be replaced
   */
  private boolean shouldReplace(String path, long touchTime) {
    EntryInfo oldInfo = paths.get(path);
    // adding from jars, we get directories with 0L time; missing should be
    // earlier than that, -1L.
    long existingTouchTime = ((oldInfo != null) ? oldInfo.getLastModified()
        : -1L);
    return (existingTouchTime < touchTime || (existingTouchTime == touchTime && this.duplicate.equals("add")));
  }
}