/*
 * @(#)JarDiffPatcher.java	1.7 05/11/17
 * 
 * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * -Redistribution of source code must retain the above copyright notice, this
 *  list of conditions and the following disclaimer.
 *
 * -Redistribution in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *
 * Neither the name of Sun Microsystems, Inc. or the names of contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
 * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
 * OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN")
 * AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE
 * AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
 * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
 * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
 * INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY
 * OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * You acknowledge that this software is not designed, licensed or intended
 * for use in the design, construction, operation or maintenance of any
 * nuclear facility.
 */

package jnlp.sample.jardiff;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.JarOutputStream;
import java.util.zip.ZipEntry;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * JarDiff is able to create a jar file containing the delta between two jar
 * files (old and new). The delta jar file can then be applied to the old jar
 * file to reconstruct the new jar file.
 * <p>
 * Refer to the JNLP spec for details on how this is done.
 * 
 * @version 1.11, 06/26/03
 */
@SuppressWarnings({ "unchecked", "unused", "rawtypes" })
public class JarDiffPatcher implements JarDiffConstants, Patcher {

	private final static Logger logger = LoggerFactory
			.getLogger(JarDiffPatcher.class);
	private static final int DEFAULT_READ_SIZE = 2048;
	private static byte[] newBytes = new byte[DEFAULT_READ_SIZE];
	private static byte[] oldBytes = new byte[DEFAULT_READ_SIZE];
	private static ResourceBundle _resources = JarDiff.getResources();

	public static ResourceBundle getResources() {
		return JarDiff.getResources();
	}

	@SuppressWarnings("resource")
	@Override
	public void applyPatch(Patcher.PatchDelegate delegate, String oldJarPath,
			String jarDiffPath, OutputStream result) throws IOException {
		File oldFile = new File(oldJarPath);
		File diffFile = new File(jarDiffPath);
		JarOutputStream jos = new JarOutputStream(result);
		JarFile oldJar = new JarFile(oldFile);
		JarFile jarDiff = new JarFile(diffFile);
		Set ignoreSet = new HashSet();
		Map renameMap = new HashMap();

		determineNameMapping(jarDiff, ignoreSet, renameMap);

		// get all keys in renameMap
		Object[] keys = renameMap.keySet().toArray();

		// Files to implicit move
		Set oldjarNames = new HashSet();

		Enumeration oldEntries = oldJar.entries();
		if (oldEntries != null) {
			while (oldEntries.hasMoreElements()) {
				oldjarNames
						.add(((JarEntry) oldEntries.nextElement()).getName());
			}
		}

		// size depends on the three parameters below, which is
		// basically the counter for each loop that do the actual
		// writes to the output file
		// since oldjarNames.size() changes in the first two loop
		// below, we need to adjust the size accordingly also when
		// oldjarNames.size() changes
		double size = oldjarNames.size() + keys.length + jarDiff.size();
		double currentEntry = 0;

		// Handle all remove commands
		oldjarNames.removeAll(ignoreSet);
		size -= ignoreSet.size();

		// Add content from JARDiff
		Enumeration entries = jarDiff.entries();
		if (entries != null) {
			while (entries.hasMoreElements()) {
				JarEntry entry = (JarEntry) entries.nextElement();

				if (!INDEX_NAME.equals(entry.getName())) {

					updateDelegate(delegate, currentEntry, size);
					currentEntry++;

					writeEntry(jos, entry, jarDiff);

					// Remove entry from oldjarNames since no implicit
					// move is needed
					boolean wasInOld = oldjarNames.remove(entry.getName());

					// Update progress counters. If it was in old, we do
					// not need an implicit move, so adjust total size.
					if (wasInOld)
						size--;

				} else {
					// no write is done, decrement size
					size--;
				}
			}
		}

		// go through the renameMap and apply move for each entry
		for (int j = 0; j < keys.length; j++) {

			// Apply move <oldName> <newName> command
			String newName = (String) keys[j];
			String oldName = (String) renameMap.get(newName);

			// Get source JarEntry
			JarEntry oldEntry = oldJar.getJarEntry(oldName);

			if (oldEntry == null) {
				String moveCmd = MOVE_COMMAND + oldName + " " + newName;
				handleException("jardiff.error.badmove", moveCmd);
				return;
			}

			// Create dest JarEntry
			JarEntry newEntry = new JarEntry(newName);
			newEntry.setTime(oldEntry.getTime());
			newEntry.setSize(oldEntry.getSize());
			newEntry.setCompressedSize(oldEntry.getCompressedSize());
			newEntry.setCrc(oldEntry.getCrc());
			newEntry.setMethod(oldEntry.getMethod());
			newEntry.setExtra(oldEntry.getExtra());
			newEntry.setComment(oldEntry.getComment());

			updateDelegate(delegate, currentEntry, size);
			currentEntry++;

			writeEntry(jos, newEntry, oldJar.getInputStream(oldEntry));

			// Remove entry from oldjarNames since no implicit
			// move is needed
			boolean wasInOld = oldjarNames.remove(oldName);

			// Update progress counters. If it was in old, we do
			// not need an implicit move, so adjust total size.
			if (wasInOld)
				size--;

		}

		// implicit move
		Iterator iEntries = oldjarNames.iterator();
		if (iEntries != null) {
			while (iEntries.hasNext()) {

				String name = (String) iEntries.next();
				JarEntry entry = oldJar.getJarEntry(name);

				updateDelegate(delegate, currentEntry, size);
				currentEntry++;

				writeEntry(jos, entry, oldJar);
			}
		}

		updateDelegate(delegate, currentEntry, size);

		jos.finish();
		oldJar.close();
	}

	private void updateDelegate(Patcher.PatchDelegate delegate,
			double currentSize, double size) {
		if (delegate != null) {
			delegate.patching((int) (currentSize / size));
		}
	}

	private void determineNameMapping(JarFile jarDiff, Set ignoreSet,
			Map renameMap) throws IOException {
		InputStream is = jarDiff.getInputStream(jarDiff.getEntry(INDEX_NAME));

		if (is == null) {
			handleException("jardiff.error.noindex", null);
			// to appease findbugs:
			return;
		}
		LineNumberReader indexReader = new LineNumberReader(
				new InputStreamReader(is, "UTF-8"));
		String line = indexReader.readLine();

		if (line == null || !line.equals(VERSION_HEADER)) {
			handleException("jardiff.error.badheader", line);

		}

		while ((line = indexReader.readLine()) != null) {
			if (line.startsWith(REMOVE_COMMAND)) {
				List sub = getSubpaths(line.substring(REMOVE_COMMAND.length()));

				if (sub.size() != 1) {
					handleException("jardiff.error.badremove", line);

				}
				ignoreSet.add(sub.get(0));
			} else if (line.startsWith(MOVE_COMMAND)) {
				List sub = getSubpaths(line.substring(MOVE_COMMAND.length()));

				if (sub.size() != 2) {
					handleException("jardiff.error.badmove", line);

				}
				// target of move should be the key
				if (renameMap.put(sub.get(1), sub.get(0)) != null) {
					// invalid move - should not move to same target twice
					handleException("jardiff.error.badmove", line);
				}
			} else if (line.length() > 0) {
				handleException("jardiff.error.badcommand", line);

			}
		}
	}

	private void handleException(String errorMsg, String line)
			throws IOException {
		try {
			throw new IOException(getResources().getString(errorMsg) + " "
					+ line);
		} catch (MissingResourceException mre) {
			logger.info("Fatal error: " + errorMsg,mre);

		}
	}

	private List getSubpaths(String path) {
		int index = 0;
		int length = path.length();
		ArrayList sub = new ArrayList();

		while (index < length) {
			while (index < length && Character.isWhitespace(path.charAt(index))) {
				index++;
			}
			if (index < length) {
				int start = index;
				int last = start;
				String subString = null;

				while (index < length) {
					char aChar = path.charAt(index);
					if (aChar == '\\' && (index + 1) < length
							&& path.charAt(index + 1) == ' ') {

						if (subString == null) {
							subString = path.substring(last, index);
						} else {
							subString += path.substring(last, index);
						}
						last = ++index;
					} else if (Character.isWhitespace(aChar)) {
						break;
					}
					index++;
				}
				if (last != index) {
					if (subString == null) {
						subString = path.substring(last, index);
					} else {
						subString += path.substring(last, index);
					}
				}
				sub.add(subString);
			}
		}
		return sub;
	}

	private void writeEntry(JarOutputStream jos, JarEntry entry, JarFile file)
			throws IOException {
		writeEntry(jos, entry, file.getInputStream(entry));
	}

	private void writeEntry(JarOutputStream jos, JarEntry entry,
			InputStream data) throws IOException {
		// Create a new ZipEntry to clear the compressed size. 5079423
		jos.putNextEntry(new ZipEntry(entry.getName()));

		// Read the entry
		int size = data.read(newBytes);

		while (size != -1) {
			jos.write(newBytes, 0, size);
			size = data.read(newBytes);
		}
		data.close();
	}
}