/*
 * 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.
 */

// Contributors: Mathias Rupprecht <mmathias.rupprecht@fja.com>

package org.apache.log4j.spi;

import org.apache.log4j.Layout;
import org.apache.log4j.helpers.LogLog;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.InterruptedIOException;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;

/**
   The internal representation of caller location information.

   @since 0.8.3
*/
public class LocationInfo implements java.io.Serializable {

  /**
     Caller's line number.
  */
  transient String lineNumber;
  /**
     Caller's file name.
  */
  transient String fileName;
  /**
     Caller's fully qualified class name.
  */
  transient String className;
  /**
     Caller's method name.
  */
  transient String methodName;
  /**
     All available caller information, in the format
     <code>fully.qualified.classname.of.caller.methodName(Filename.java:line)</code>
    */
  public String fullInfo;

  private static StringWriter sw = new StringWriter();
  private static PrintWriter pw = new PrintWriter(sw);

  private static Method getStackTraceMethod;
  private static Method getClassNameMethod;
  private static Method getMethodNameMethod;
  private static Method getFileNameMethod;
  private static Method getLineNumberMethod;


  /**
     When location information is not available the constant
     <code>NA</code> is returned. Current value of this string
     constant is <b>?</b>.  */
  public final static String NA = "?";

  static final long serialVersionUID = -1325822038990805636L;

    /**
     * NA_LOCATION_INFO is provided for compatibility with log4j 1.3.
     * @since 1.2.15
     */
    public static final LocationInfo NA_LOCATION_INFO =
            new LocationInfo(NA, NA, NA, NA);



  // Check if we are running in IBM's visual age.
  static boolean inVisualAge = false;
  static {
    try {
      inVisualAge = Class.forName("com.ibm.uvm.tools.DebugSupport") != null;
      LogLog.debug("Detected IBM VisualAge environment.");
    } catch(Throwable e) {
      // nothing to do
    }
      try {
          Class[] noArgs = null;
          getStackTraceMethod = Throwable.class.getMethod("getStackTrace", noArgs);
          Class stackTraceElementClass = Class.forName("java.lang.StackTraceElement");
          getClassNameMethod = stackTraceElementClass.getMethod("getClassName", noArgs);
          getMethodNameMethod = stackTraceElementClass.getMethod("getMethodName", noArgs);
          getFileNameMethod = stackTraceElementClass.getMethod("getFileName", noArgs);
          getLineNumberMethod = stackTraceElementClass.getMethod("getLineNumber", noArgs);
      } catch(ClassNotFoundException ex) {
          LogLog.debug("LocationInfo will use pre-JDK 1.4 methods to determine location.");
      } catch(NoSuchMethodException ex) {
          LogLog.debug("LocationInfo will use pre-JDK 1.4 methods to determine location.");
      }
  }

  /**
     Instantiate location information based on a Throwable. We
     expect the Throwable <code>t</code>, to be in the format

       <pre>
        java.lang.Throwable
        ...
          at org.apache.log4j.PatternLayout.format(PatternLayout.java:413)
          at org.apache.log4j.FileAppender.doAppend(FileAppender.java:183)
        at org.apache.log4j.Category.callAppenders(Category.java:131)
        at org.apache.log4j.Category.log(Category.java:512)
        at callers.fully.qualified.className.methodName(FileName.java:74)
        ...
       </pre>

       <p>However, we can also deal with JIT compilers that "lose" the
       location information, especially between the parentheses.
        @param t throwable used to determine location, may be null.
        @param fqnOfCallingClass class name of first class considered part of
           the logging framework.  Location will be site that calls a method on this class.

    */
    public LocationInfo(Throwable t, String fqnOfCallingClass) {
      if(t == null || fqnOfCallingClass == null)
        return;
      if (getLineNumberMethod != null) {
          try {
              Object[] noArgs = null;
              Object[] elements =  (Object[]) getStackTraceMethod.invoke(t, noArgs);
              String prevClass = NA;
              for(int i = elements.length - 1; i >= 0; i--) {
                  String thisClass = (String) getClassNameMethod.invoke(elements[i], noArgs);
                  if(fqnOfCallingClass.equals(thisClass)) {
                      int caller = i + 1;
                      if (caller < elements.length) {
                          className = prevClass;
                          methodName = (String) getMethodNameMethod.invoke(elements[caller], noArgs);
                          fileName = (String) getFileNameMethod.invoke(elements[caller], noArgs);
                          if (fileName == null) {
                              fileName = NA;
                          }
                          int line = ((Integer) getLineNumberMethod.invoke(elements[caller], noArgs)).intValue();
                          if (line < 0) {
                              lineNumber = NA;
                          } else {
                              lineNumber = String.valueOf(line);
                          }
                          StringBuffer buf = new StringBuffer();
                          buf.append(className);
                          buf.append(".");
                          buf.append(methodName);
                          buf.append("(");
                          buf.append(fileName);
                          buf.append(":");
                          buf.append(lineNumber);
                          buf.append(")");
                          this.fullInfo = buf.toString();
                      }
                      return;
                  }
                  prevClass = thisClass;
              }
              return;
          } catch(IllegalAccessException ex) {
              LogLog.debug("LocationInfo failed using JDK 1.4 methods", ex);
          } catch(InvocationTargetException ex) {
              if (ex.getTargetException() instanceof InterruptedException
                      || ex.getTargetException() instanceof InterruptedIOException) {
                  Thread.currentThread().interrupt();
              }
              LogLog.debug("LocationInfo failed using JDK 1.4 methods", ex);
          } catch(RuntimeException ex) {
              LogLog.debug("LocationInfo failed using JDK 1.4 methods", ex);
          }
      }

      String s;
      // Protect against multiple access to sw.
      synchronized(sw) {
        t.printStackTrace(pw);
        s = sw.toString();
        sw.getBuffer().setLength(0);
      }
      //System.out.println("s is ["+s+"].");
      int ibegin, iend;

      // Given the current structure of the package, the line
      // containing "org.apache.log4j.Category." should be printed just
      // before the caller.

      // This method of searching may not be fastest but it's safer
      // than counting the stack depth which is not guaranteed to be
      // constant across JVM implementations.
      ibegin = s.lastIndexOf(fqnOfCallingClass);
      if(ibegin == -1)
        return;

      //
      //   if the next character after the class name exists
      //       but is not a period, see if the classname is
      //       followed by a period earlier in the trace.
      //       Minimizes mistakeningly matching on a class whose
      //       name is a substring of the desired class.
      //       See bug 44888.
      if (ibegin + fqnOfCallingClass.length() < s.length() &&
              s.charAt(ibegin + fqnOfCallingClass.length()) != '.') {
          int i = s.lastIndexOf(fqnOfCallingClass + ".");
          if (i != -1) {
              ibegin = i;
          }
      }


      ibegin = s.indexOf(Layout.LINE_SEP, ibegin);
      if(ibegin == -1)
        return;
      ibegin+= Layout.LINE_SEP_LEN;

      // determine end of line
      iend = s.indexOf(Layout.LINE_SEP, ibegin);
      if(iend == -1)
        return;

      // VA has a different stack trace format which doesn't
      // need to skip the inital 'at'
      if(!inVisualAge) {
        // back up to first blank character
        ibegin = s.lastIndexOf("at ", iend);
        if(ibegin == -1)
          return;
        // Add 3 to skip "at ";
        ibegin += 3;
      }
      // everything between is the requested stack item
      this.fullInfo = s.substring(ibegin, iend);
    }

    /**
     *   Appends a location fragment to a buffer to build the 
     *     full location info.
     *    @param buf StringBuffer to receive content.
     *    @param fragment fragment of location (class, method, file, line),
     *        if null the value of NA will be appended.
     *    @since 1.2.15
     */
    private static final void appendFragment(final StringBuffer buf,
                                             final String fragment) {
          if (fragment == null) {
             buf.append(NA);
          } else {
             buf.append(fragment);
          }
    }

    /**
     * Create new instance.
     * @param file source file name
     * @param classname class name
     * @param method method
     * @param line source line number
     *
     * @since 1.2.15
     */
    public LocationInfo(
      final String file,
      final String classname,
      final String method,
      final String line) {
      this.fileName = file;
      this.className = classname;
      this.methodName = method;
      this.lineNumber = line;
      StringBuffer buf = new StringBuffer();
          appendFragment(buf, classname);
          buf.append(".");
          appendFragment(buf, method);
          buf.append("(");
          appendFragment(buf, file);
          buf.append(":");
          appendFragment(buf, line);
          buf.append(")");
          this.fullInfo = buf.toString();
    }

    /**
       Return the fully qualified class name of the caller making the
       logging request.
    */
    public
    String getClassName() {
      if(fullInfo == null) return NA;
      if(className == null) {
        // Starting the search from '(' is safer because there is
        // potentially a dot between the parentheses.
        int iend = fullInfo.lastIndexOf('(');
        if(iend == -1)
          className = NA;
        else {
          iend =fullInfo.lastIndexOf('.', iend);

          // This is because a stack trace in VisualAge looks like:

          //java.lang.RuntimeException
          //  java.lang.Throwable()
          //  java.lang.Exception()
          //  java.lang.RuntimeException()
          //  void test.test.B.print()
          //  void test.test.A.printIndirect()
          //  void test.test.Run.main(java.lang.String [])
          int ibegin = 0;
          if (inVisualAge) {
            ibegin = fullInfo.lastIndexOf(' ', iend)+1;
          }

          if(iend == -1)
            className = NA;
          else
            className = this.fullInfo.substring(ibegin, iend);
        }
      }
      return className;
    }

    /**
       Return the file name of the caller.

       <p>This information is not always available.
    */
    public
    String getFileName() {
      if(fullInfo == null) return NA;

      if(fileName == null) {
        int iend = fullInfo.lastIndexOf(':');
        if(iend == -1)
          fileName = NA;
        else {
          int ibegin = fullInfo.lastIndexOf('(', iend - 1);
          fileName = this.fullInfo.substring(ibegin + 1, iend);
        }
      }
      return fileName;
    }

    /**
       Returns the line number of the caller.

       <p>This information is not always available.
    */
    public
    String getLineNumber() {
      if(fullInfo == null) return NA;

      if(lineNumber == null) {
        int iend = fullInfo.lastIndexOf(')');
        int ibegin = fullInfo.lastIndexOf(':', iend -1);
        if(ibegin == -1)
          lineNumber = NA;
        else
          lineNumber = this.fullInfo.substring(ibegin + 1, iend);
      }
      return lineNumber;
    }

    /**
       Returns the method name of the caller.
    */
    public
    String getMethodName() {
      if(fullInfo == null) return NA;
      if(methodName == null) {
        int iend = fullInfo.lastIndexOf('(');
        int ibegin = fullInfo.lastIndexOf('.', iend);
        if(ibegin == -1)
          methodName = NA;
        else
          methodName = this.fullInfo.substring(ibegin + 1, iend);
      }
      return methodName;
    }
}