package inputOutput;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.PushbackReader;
import java.io.Reader;

/**
 *  This class filters out Java-style comments.
 *  It replaces "/*" comments with a single space,
 *  and "//" comments with a newline.
 *
 *  NOTE: The algorithm used here is not perfect;
 *        It should ignore cases of "/*" and "//" within literal 
 *        strings. Perfecting the algorithm is left as an exercise
 *        for the reader (pun intended!).
 *
 *  @author B. J. Higgs
 */
public class CommentFilterReader extends PushbackReader
{
    public CommentFilterReader(Reader in)
    {
        super(in);
    }
    
    /**
     *  Read a single character. 
     *  This method will block until a character is available, 
     *  an I/O error occurs, or the end of the stream is reached. 
     *
     *  @return The character read, as an integer in the range 
     *          0 to 16383 (0x00-0xffff), 
     *          or -1 if the end of the stream has been reached
     */
    public int read() 
        throws IOException
    {
        int c = readNextNonCommentChar();
        return c;
    }
    
    /**
     *  Reads the input, and returns the next non-comment character.
     *  It detects the start and end of both kinds of Java comments,
     *  and skips over comment characters as it detects them.
     *
     *  @return The character read, as an integer in the range 
     *          0 to 16383 (0x00-0xffff), 
     *          or -1 if the end of the stream has been reached
     */
    private int readNextNonCommentChar() 
        throws IOException
    {
        int c = super.read();
        if (c == '/')
        {
            // Possible start of comment, so check for '*' or '/'
            int lookAheadChar = super.read();
            switch (lookAheadChar)
            {
                case '*':
                    // We've found a '/*' comment, so silently
                    // consume characters until we see a '*/'
                    while (true)
                    {
                        c = super.read();
                        if (c == -1)
                            break;      // End of stream
                        if (c == '*')
                        {
                            lookAheadChar = super.read();
                            if (lookAheadChar == '/')
                            {
                                c = ' '; // Replace comment with space
                                break;  // End of comment
                            }
                        }
                    }
                    break;
                        
                case '/':
                    // We've found a '//' comment, so silently
                    // consume characters until we see a newline
                    while (true)
                    {
                        c = super.read();
                        if (c == -1)
                            break;      // End of stream
                        if (c == '\n')
                        {
                            // Newline ends comment -- 
                            // return the newline
                            break;
                        }
                    }
                    break;
                        
                default:
                    // Not a command, so push back the look 
                    // ahead char so it gets read on the next read.
                    unread(lookAheadChar);
                    break;
            }
        }
        
        // No matter how we get here, 
        // c will contain the character to return.
        return c;
    }
    
    /**
     *  Read characters into a portion of an array. 
     *  This method will block until some input is available,
     *  an I/O error occurs, or the end of the stream is reached.
     *
     *  @param cbuf - Destination buffer 
     *  @param off - Offset at which to start storing characters 
     *  @param len - Maximum number of characters to read 
     *  @return The number of characters read, 
     *          or -1 if the end of the stream has been reached
     */
    public int read(char[] cbuf, int off, int len) 
        throws IOException
    {
        int count = 0;
        // For loop takes into account the available size of the 
        // buffer as well as the maximum number of characters to copy.
        for (int avail = cbuf.length - off; 
	   len > 0 && avail > 0; 
	   len--, avail--)
        {
            int c = readNextNonCommentChar();
            if (c == -1)
            {
                // If this read didn't read any characters, 
                // return end of stream; otherwise, return 
                // the actual number read. (The next call will
                // return end of stream.)
                if (count == 0)
                    count = -1;
                break;
            }
            // Move character into buffer and keep count and 
            // offset updated.
            cbuf[off++] = (char)c;
            count++;
        }
        
        return count;
    }
    
    /**
     *  Skip non-comment characters. 
     *  This method will block until some characters are available, 
     *  an I/O error occurs, or the end of the stream is reached.
     *
     *  @param n The number of characters to skip
     *  @return The number of characters actually skipped
     */
    public long skip(long n) 
        throws IOException
    {
        long count = 0;
        for (count = 0; count < n; count++)
        {
            int c = readNextNonCommentChar();
            if (c == -1)
                break;
        }
        
        return count;
    }


    /**
     *  Main entry point, for testing.
     *  Expects one or two arguments:
     *      inputFileName   -- the name of the file to read
     *      outputFileName  -- the name of the file to write 
     *                         the results
     *  (If only one argument is supplied, the output is to System.out)
     *  
     */
    public static void main(String[] args)
    {
        try
        {
            BufferedReader reader = new BufferedReader( 
                                            new CommentFilterReader(
                                                new FileReader(
                                                    args[0])));
            PrintWriter writer = null;
            if (args.length > 1)
            {
                writer = new PrintWriter( 
                            new BufferedWriter(
                                new FileWriter(args[1])));
            }
            else
            {
                writer = new PrintWriter(
                            new OutputStreamWriter(
                                System.out));
            }
            
            while (true)
            {
                String line = reader.readLine();
                if (line == null)
                    break;
                writer.println(line);
            }
            reader.close();
            writer.close();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}