/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You 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 org.apache.creadur.tentacles;
  
  import java.io.ByteArrayInputStream;
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.ArrayList;
  import java.util.List;
  
  import org.codehaus.swizzle.stream.DelimitedTokenReplacementInputStream;
  import org.codehaus.swizzle.stream.ExcludeFilterInputStream;
  import org.codehaus.swizzle.stream.StringTokenHandler;
  
  /**
   * Little utility that will yank the author comments from java files.
   * 
   * If the resulting comment block is effectively empty, it will be yanked too.
   */
  public class Deauthorize {
  
  	/**
  	 * All input must be valid directories.
  	 * 
  	 * Invalid input is logged to System.err and skipped
  	 * 
  	 * @param args
  	 *            a list of directories to scan and fix
  	 * @throws Exception
  	 *             in case of errors.
  	 */
  	public static void main(final String[] args) throws Exception {
  
  		if (args.length == 0) {
  			throw new IllegalArgumentException(
  					"At least one directory must be specified");
  		}
  
  		final List<File> dirs = new ArrayList<File>();
  
  		// Check the input args upfront
  		for (final String arg : args) {
  			final File dir = new File(arg);
  
  			if (not(dir.exists(), "Does not exist: %s", arg)) {
  				continue;
  			}
  			if (not(dir.isDirectory(), "Not a directory: %s", arg)) {
  				continue;
  			}
  
  			dirs.add(dir);
  		}
  
  		// Exit if we got bad input
  		if (dirs.size() != args.length) {
  			System.exit(1);
  		}
  
  		// Go!
  		for (final File dir : dirs) {
  			deauthorize(dir);
  		}
  	}
  
  	/**
  	 * Iterate over all the java files in the given directory
  	 * 
  	 * Read in the file so we can guess the line ending -- if we didn't need to
  	 * do that we could just stream. Run the content through Swizzle Stream and
  	 * filter out any author tags as well as any comment blocks that wind up (or
  	 * already were) empty as a result.
  	 * 
  	 * If that had any effect on the contents of the file, write it back out.
  	 * 
  	 * Should skip any files that are not readable or writable.
  	 * 
  	 * Will log an error on System.err for any files that were updated and were
  	 * not writable. Files that are not writable and don't need updating are
  	 * simply ignored.
  	 * 
  	 * @param dir
  	 * @throws IOException
  	 */
 	private static void deauthorize(final File dir) throws IOException {
 		deauthorize(dir, new IOSystem());
 	}
 
 	private static void deauthorize(final File dir, final IOSystem io)
 			throws IOException {
 		for (final File file : new FileSystem().collect(dir, ".*\\.java")) {
 
 			if (not(file.canRead(), "File not readable: %s",
 					file.getAbsolutePath())) {
 				continue;
 			}
 
 			final String text = io.slurp(file);
 
 			// You really can't trust text to be in the native line ending
 			final String eol = text.contains("\r\n") ? "\r\n" : "\n";
 			final String startComment = eol + "/*";
 			final String endComment = "*/" + eol;
 
 			final InputStream baseIn = new ByteArrayInputStream(text.getBytes());
 
 			// Yank author tags
 			InputStream in = new ExcludeFilterInputStream(baseIn, " * @author",
 					eol);
 
 			// Clean "empty" comments
 			in = new DelimitedTokenReplacementInputStream(in, startComment,
 					endComment, new StringTokenHandler() {
 						@Override
 						public String handleToken(final String commentBlock)
 								throws IOException {
 
 							// Yank if empty
 							if (commentBlock.replaceAll("[\\s*]", "").length() == 0) {
 								return eol;
 							}
 
 							// Keep otherwise
 							return startComment + commentBlock + endComment;
 						}
 					});
 
 			final byte[] content = io.read(in);
 
 			if (content.length != file.length()) {
 
 				if (not(file.canWrite(), "File not writable: %s",
 						file.getAbsolutePath())) {
 					continue;
 				}
 
 				io.copy(content, file);
 			}
 		}
 
 	}
 
 	private static boolean not(boolean b, final String message,
 			final Object... details) {
 		b = !b;
 		if (b) {
 			System.err.printf(message, details);
 			System.err.println();
 		}
 		return b;
 	}
 }