/*
 * Copyright (c) 2008, 2009, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package build.tools.logutil;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
import java.io.IOException;

import java.util.LinkedList;
import java.util.Queue;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Input {

  /**
   * The name of the package this class will inhabit.
   */
  private String packageName;

  /**
   * The name of the generated class.
   */
  private String className;

  /**
   * The name of the group of exceptions handled by the class.
   */
  private String groupName;

  /**
   * The group of exceptions.
   */
  private Queue<InputException> exceptions;

  /**
   * Represents the current state of parsing the input.
   */
  private enum State
  {
    OUTER,
    IN_CLASS,
    IN_EXCEPTION_LIST
  };

  /**
   * Regular expression to match each code line.
   */
  private static final Pattern EXCEPTION_INFO_REGEX =
    Pattern.compile("(\\w+)\\s*(\\d+)\\s*(\\w+)");

  /**
   * Parses the specified file to create a new {@link Input}
   * object.
   *
   * @param filename the file to parse.
   * @throws FileNotFoundException if the file can't be found.
   * @throws IOException if an I/O error occurs.
   */
  public Input(final String filename)
  throws FileNotFoundException, IOException {
    BufferedReader r =
      new BufferedReader(new InputStreamReader(new FileInputStream(filename)));
    State state = State.OUTER;
    InputException current = null;
    exceptions = new LinkedList<InputException>();
    String line;
    while ((line = r.readLine()) != null) {
      // Skip ; comments
      if (line.startsWith(";"))
        continue;

      int index = line.indexOf("(");
      if (index == -1)
        continue;

      switch (state) {
      case OUTER:
        state = State.IN_CLASS;
        String[] classInfo = line.substring(index).split(" ");
        packageName = classInfo[0].substring(2, classInfo[0].length() - 1);
        className = classInfo[1].substring(1, classInfo[1].length() - 1);
        groupName = classInfo[2];
        break;
      case IN_CLASS:
        state = State.IN_EXCEPTION_LIST;
        break;
      case IN_EXCEPTION_LIST:
        boolean inQuote = false;
        boolean inCode = false;
        boolean end = false;
        int start = index + 1;
        Queue<String> lines = new LinkedList<String>();
        for (int a = start; a < line.length(); ++a) {
          if (line.charAt(a) == '(' && !inCode && !inQuote) {
            if (current == null)
              current =
                new InputException(line.substring(start, a).trim());
            start = a + 1;
            inCode = true;
          }
          if (line.charAt(a) == '"')
            inQuote = !inQuote;
          if (line.charAt(a) == ')' && !inQuote) {
            if (inCode) {
              lines.offer(line.substring(start, a));
              inCode = false;
            } else
              end = true;
          }
          if (!end && a == line.length() - 1)
            line += r.readLine();
        }
        for (String l : lines) {
          int stringStart = l.indexOf("\"") + 1;
          int stringEnd = l.indexOf("\"", stringStart);
          Matcher matcher = EXCEPTION_INFO_REGEX.matcher(l.substring(0, stringStart));
          if (matcher.find())
            current.add(new InputCode(matcher.group(1),
                                      Integer.parseInt(matcher.group(2)),
                                      matcher.group(3),
                                      l.substring(stringStart, stringEnd)));
        }
        exceptions.offer(current);
        current = null;
        break;
      }
    }
  }

  /**
   * Returns the name of this group of exceptions.
   *
   * @return the name of this group of exceptions.
   */
  public String getGroupName()
  {
    return groupName;
  }

  /**
   * Returns the name of the package this class will go in.
   *
   * @return the name of the package.
   */
  public String getPackageName()
  {
    return packageName;
  }

  /**
   * Returns the name of the generated class.
   *
   * @return the name of the class.
   */
  public String getClassName()
  {
    return className;
  }

  /**
   * Returns the exceptions contained in this class.
   *
   * @return the exceptions.
   */
  public Queue<InputException> getExceptions() {
    return exceptions;
  }

  /**
   * Returns a textual representation of this input.
   *
   * @return a textual representation.
   */
  public String toString() {
    return getClass().getName() +
      "[packageName=" + packageName +
      ",className=" + className +
      ",groupName=" + groupName +
      ",exceptions=" + exceptions +
      "]";
  }

}