package com.ronsoft.books.nio.regex;

import java.io.File;
import java.io.FileReader;
import java.io.LineNumberReader;
import java.io.IOException;
import java.util.List;
import java.util.LinkedList;
import java.util.Iterator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * A file searching class, similar to grep, which returns information about
 * lines matched in the specified files.  Instances of this class are tied
 * to a specific regular expression pattern and may be applied repeatedly
 * to multiple files.  Instances of Grep are thread safe, they may be shared.
 *
 * @author Michael Daudel (mgd@ronsoft.com) (original)
 * @author Ron Hitchens (ron@ronsoft.com) (hacked)
 * @version $Id: Grep.java,v 1.3 2002/04/11 02:58:04 ron Exp $
 */
public class Grep
{
	// The pattern to use for this instance
	private Pattern pattern;

	/**
	 * Instantiate a Grep object for the given pre-compiled Pattern object.
	 * @param pattern A java.util.regex.Pattern object specifying the
	 *  pattern to search for.
	 */
	public Grep (Pattern pattern)
	{
		this.pattern = pattern;
	}

	/**
	 * Instantiate a Grep object and compile the given regular expression
	 * string.
	 * @param regex The regular expression string to compile into a
	 *  Pattern for internal use.
	 * @param ignoreCase If true, pass Pattern.CASE_INSENSITIVE to the
	 *  Pattern constuctor so that seaches will be done without regard
	 *  to alphabetic case.  Note, this only applies to the ASCII
	 *  character set.  Use embedded expressions to set other options.
	 */
	public Grep (String regex, boolean ignoreCase)
	{
		this.pattern = Pattern.compile (regex,
			(ignoreCase) ? Pattern.CASE_INSENSITIVE : 0);
		
	}

	/**
	 * Instantiate a Grep object with the given regular expression string,
	 * with default options.
	 */
	public Grep (String regex)
	{
		this (regex, false);
	}

	// ---------------------------------------------------------------

	/**
	 * Perform a grep on the given file.
	 * @param file A File object denoting the file to scan for the
	 *  regex given when this Grep instance was constructed.
	 * @return A type-safe array of Grep.MatchedLine objects describing
	 *  the lines of the file matched by the pattern.
	 * @exception IOException If there is a problem reading the file.
	 */
	public MatchedLine [] grep (File file)
		throws IOException
	{
		List list = grepList (file);
		MatchedLine matches [] = new MatchedLine [list.size()];

		list.toArray (matches);

		return (matches);
	}

	/**
	 * Perform a grep on the given file.
	 * @param file A String filename denoting the file to scan for the
	 *  regex given when this Grep instance was constructed.
	 * @return A type-safe array of Grep.MatchedLine objects describing
	 *  the lines of the file matched by the pattern.
	 * @exception IOException If there is a problem reading the file.
	 */
	public MatchedLine [] grep (String fileName)
		throws IOException
	{
		return (grep (new File (fileName)));
	}

	/**
	 * Perform a grep on the given list of files.  If a given file cannot
	 * be read, it will be ignored as if empty.
	 * @param files An array of File objects to scan.
	 * @return A type-safe array of Grep.MatchedLine objects describing
	 *  the lines of the file matched by the pattern.
	 */
	public MatchedLine [] grep (File [] files)
	{
		List aggregate = new LinkedList();

		for (int i = 0; i < files.length; i++) {
			try {
				List temp = grepList (files [i]);

				aggregate.addAll (temp);
			} catch (IOException e) {
				// ignore I/O exceptions
			}
		}

		MatchedLine matches [] = new MatchedLine [aggregate.size()];

		aggregate.toArray (matches);

		return (matches);
	}

	// -------------------------------------------------------------

	/**
	 * Encapsulation of a matched line from a file.  This immutable
	 * object has three read-only properties:<ul>
	 * <li>getFile(): The File this match pertains to.</li>
	 * <li>getLineNumber(): The line number (1-relative) within the
	 *   file where the match was found.</li>
	 * <li>getLineText(): The text of the matching line</li>
	 * <li>start(): The index within the line where the matching
	 *  pattern begins.</li>
	 * <li>end(): The index, plus one, of the end of the matched
	 *  character sequence.</li>
	 * </ul>
	 */
	public static class MatchedLine
	{
		private File file;
		private int lineNumber;
		private String lineText;
		private int start;
		private int end;

		MatchedLine (File file, int lineNumber, String lineText,
			int start, int end)
		{
			this.file = file;
			this.lineNumber = lineNumber;
			this.lineText = lineText;
			this.start = start;
			this.end = end;
		}

		public File getFile()
		{
			return (this.file);
		}

		public int getLineNumber()
		{
			return (this.lineNumber);
		}

		public String getLineText()
		{
			return (this.lineText);
		}

		public int start()
		{
			return (this.start);
		}

		public int end()
		{
			return (this.end);
		}
	}

	// -----------------------------------------------------------

	/**
	 * Run the grepper on the given File.
	 * @return A (non-type-safe) List of MatchedLine objects.
	 */
	private List grepList (File file)
		throws IOException
	{
		if ( ! file.exists()) {
			throw new IOException ("Does not exist: " + file);
		}

		if ( ! file.isFile()) {
			throw new IOException ("Not a regular file: " + file);
		}

		if ( ! file.canRead()) {
			throw new IOException ("Unreadable file: " + file);
		}

		LinkedList list = new LinkedList();
		FileReader fr = new FileReader (file);
		LineNumberReader lnr = new LineNumberReader (fr);
		Matcher matcher = this.pattern.matcher ("");
		String line;

		while ((line = lnr.readLine()) != null) {
			matcher.reset (line);

			if (matcher.find()) {
				list.add (new MatchedLine (file,
					lnr.getLineNumber(), line,
					matcher.start(), matcher.end()));
			}
		}

		lnr.close();

		return (list);
	}

	// ---------------------------------------------------------------

	/**
	 * Test code to run grep operations.  Accepts two command-line
	 * options: -i or --ignore-case, compile the givn pattern so
	 * that case of alpha characters is ignored.  Or -1, which runs
	 * the grep operation on each individual file, rather that passing
	 * them all to one invocation.  This is just to test the different
	 * methods.  The printed ouptut is slightly different when -1 is
	 * specified.
	 */
	public static void main (String [] argv)
	{
		// set defaults
		boolean ignoreCase = false;
		boolean onebyone = false;
		List argList = new LinkedList();	// to gather args

		// loop through the args, looking for switches and saving
		// off the pattern an file names
		for (int i = 0; i < argv.length; i++) {
			if (argv [i].startsWith ("-")) {
				if (argv [i].equals ("-i")
					|| argv [i].equals ("--ignore-case"))
				{
					ignoreCase = true;
				}

				if (argv [i].equals ("-1")) {
					onebyone = true;
				}

				continue;
			}

			// not a switch, add it to the list
			argList.add (argv [i]);
		}

		// enough args to run?
		if (argList.size() < 2) {
			System.err.println ("usage: [options] pattern filename ...");
			return;
		}

		// first arg on the list will be taken as the regex pattern
		// pass the pattern to the new Grep object, along with the
		// current value of the ignore case flag
		Grep grepper = new Grep ((String) argList.remove (0),
			ignoreCase);

		// somewhat arbitrarily split into two ways of calling the
		// grepper and printing out the results.
		if (onebyone) {
			Iterator it = argList.iterator();

			// loop through the filenames and grep them
			while (it.hasNext()) {
				String fileName = (String) it.next();

				// print the filename once before each grep
				System.out.println (fileName + ":");

				MatchedLine [] matches = null;

				// catch exceptions 
				try {
					matches = grepper.grep (fileName);
				} catch (IOException e) {
					System.err.println ("\t*** " + e);
					continue;
				}

				// print out info about the matched lines
				for (int i = 0; i < matches.length; i++) {
					MatchedLine match = matches [i];

					System.out.println ("  "
						+ match.getLineNumber()
						+ " [" + match.start()
						+ "-" + (match.end() - 1)
						+ "]: "
						+ match.getLineText());
				}
			}
		} else {
			// convert the filename list to an array of File
			File [] files = new File [argList.size()];

			for (int i = 0; i < files.length; i++) {
				files [i] = new File ((String) argList.get (i));
			}

			// run the grepper, unreadable files are ignored
			MatchedLine [] matches = grepper.grep (files);

			// print out info about the matched lines
			for (int i = 0; i < matches.length; i++) {
				MatchedLine match = matches [i];

				System.out.println (match.getFile().getName()
					+ ", " + match.getLineNumber() + ": "
					+ match.getLineText());
			}
		}
	}
}