/*
 * Conditions Of Use
 *
 * This software was developed by employees of the National Institute of
 * Standards and Technology (NIST), an agency of the Federal Government.
 * Pursuant to title 15 Untied States Code Section 105, works of NIST
 * employees are not subject to copyright protection in the United States
 * and are considered to be in the public domain.  As a result, a formal
 * license is not needed to use the software.
 *
 * This software is provided by NIST as a service and is expressly
 * provided "AS IS."  NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED
 * OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT
 * AND DATA ACCURACY.  NIST does not warrant or make any representations
 * regarding the use of the software or the results thereof, including but
 * not limited to the correctness, accuracy, reliability or usefulness of
 * the software.
 *
 * Permission to use this software is contingent upon your acceptance
 * of the terms of this agreement.
 *
 */
/***************************************************************************
 * Product of NIST/ITL Advanced Networking Technologies Division (ANTD).    *
 ***************************************************************************/
package gov.nist.core;

import java.io.*;
import java.util.Properties;

// BEGIN ANDROID-added
// TODO: this class should be replaced by android logging mechanism.
public class LogWriter implements StackLogger {
    private static final String TAG = "SIP_STACK";

    private boolean mEnabled = true;

    public void logStackTrace() {
        // TODO
    }

    public void logStackTrace(int traceLevel) {
        // TODO
    }

    public int getLineCount() {
        return 0;
    }

    public void logException(Throwable ex) {
        //Log.e(TAG, "", ex);
    }
    public void logDebug(String message) {
        //Log.d(TAG, message);
    }
    public void logTrace(String message) {
        //Log.d(TAG, message);
    }
    public void logFatalError(String message) {
        //Log.e(TAG, message);
    }
    public void logError(String message) {
        //Log.e(TAG, message);
    }
    public boolean isLoggingEnabled() {
        return mEnabled;
    }
    public boolean isLoggingEnabled(int logLevel) {
        // TODO
        return mEnabled;
    }
    public void logError(String message, Exception ex) {
        //Log.e(TAG, message, ex);
    }
    public void logWarning(String string) {
        //Log.w(TAG, string);
    }
    public void logInfo(String string) {
        //Log.i(TAG, string);
    }

    public void disableLogging() {
        mEnabled = false;
    }

    public void enableLogging() {
        mEnabled = true;
    }

    public void setBuildTimeStamp(String buildTimeStamp) {
    }

    public void setStackProperties(Properties stackProperties) {
    }

    public String getLoggerName() {
        return "Android SIP Logger";
    }
}
// END android-added

// BEGIN android-deleted

//import org.apache.log4j.Appender;
//import org.apache.log4j.FileAppender;
//import org.apache.log4j.Level;
//import org.apache.log4j.Logger;
//import org.apache.log4j.Priority;
//import org.apache.log4j.SimpleLayout;
//
///**
// * A wrapper around log4j that is used for logging debug and errors. You can
// * replace this file if you want to change the way in which messages are logged.
// *
// * @version 1.2
// *
// * @author M. Ranganathan <br/>
// * @author M.Andrews
// * @author Jeroen van Bemmel
// * @author Jean Deruelle
// *
// */
//
//public class LogWriter implements StackLogger {
//
//    /**
//     * The logger to which we will write our logging output.
//     */
//    private Logger logger;
//
//    /**
//     * The stack name.
//     */
//    private String stackName;
//
//    /**
//     * Name of the log file in which the trace is written out (default is
//     * /tmp/sipserverlog.txt)
//     */
//    private String logFileName = null;
//
//    /**
//     * Flag to indicate that logging is enabled.
//     */
//    private volatile boolean needsLogging = false;
//
//    private int lineCount;
//
//    /**
//     * trace level
//     */
//
//    protected int traceLevel = TRACE_NONE;
//
//    private String buildTimeStamp;
//
//    private Properties configurationProperties;
//
//    /**
//     * log a stack trace. This helps to look at the stack frame.
//     */
//    public void logStackTrace() {
//        this.logStackTrace(TRACE_DEBUG);
//
//    }
//
//    public void logStackTrace(int traceLevel) {
//        if (needsLogging) {
//            StringWriter sw = new StringWriter();
//            PrintWriter pw = new PrintWriter(sw);
//            StackTraceElement[] ste = new Exception().getStackTrace();
//            // Skip the log writer frame and log all the other stack frames.
//            for (int i = 1; i < ste.length; i++) {
//                String callFrame = "[" + ste[i].getFileName() + ":"
//                        + ste[i].getLineNumber() + "]";
//                pw.print(callFrame);
//            }
//            pw.close();
//            String stackTrace = sw.getBuffer().toString();
//            Level level = this.getLevel(traceLevel);
//            Priority priority = this.getLogPriority();
//            if ( level.isGreaterOrEqual(priority)) {
//                logger.log(level,stackTrace);
//            }
//
//        }
//    }
//
//    /**
//     * Get the line count in the log stream.
//     *
//     * @return
//     */
//    public int getLineCount() {
//        return lineCount;
//    }
//
//    /**
//     * Get the logger.
//     *
//     * @return
//     */
//    public Logger getLogger() {
//        return logger;
//    }
//
//
//    /**
//     * This method allows you to add an external appender.
//     * This is useful for the case when you want to log to
//     * a different log stream than a file.
//     *
//     * @param appender
//     */
//    public void addAppender(Appender appender) {
//
//        this.logger.addAppender(appender);
//
//    }
//
//    /**
//     * Log an exception.
//     *
//     * @param ex
//     */
//    public void logException(Throwable ex) {
//
//        if (needsLogging) {
//
//            this.getLogger().error(ex.getMessage(), ex);
//        }
//    }
//
//
//
//
//    /**
//     * Counts the line number so that the debug log can be correlated to the
//     * message trace.
//     *
//     * @param message --
//     *            message to count the lines for.
//     */
//    private void countLines(String message) {
//        char[] chars = message.toCharArray();
//        for (int i = 0; i < chars.length; i++) {
//            if (chars[i] == '\n')
//                lineCount++;
//        }
//
//    }
//
//    /**
//     * Prepend the line and file where this message originated from
//     *
//     * @param message
//     * @return re-written message.
//     */
//    private String enhanceMessage(String message) {
//
//        StackTraceElement[] stackTrace = new Exception().getStackTrace();
//        StackTraceElement elem = stackTrace[2];
//        String className = elem.getClassName();
//        String methodName = elem.getMethodName();
//        String fileName = elem.getFileName();
//        int lineNumber = elem.getLineNumber();
//        String newMessage = className + "." + methodName + "(" + fileName + ":"
//                + lineNumber + ") [" + message + "]";
//        return newMessage;
//
//    }
//
//    /**
//     * Log a message into the log file.
//     *
//     * @param message
//     *            message to log into the log file.
//     */
//    public void logDebug(String message) {
//        if (needsLogging) {
//            String newMessage = this.enhanceMessage(message);
//            if ( this.lineCount == 0) {
//                getLogger().debug("BUILD TIMESTAMP = " + this.buildTimeStamp);
//                getLogger().debug("Config Propeties = " + this.configurationProperties);
//            }
//            countLines(newMessage);
//            getLogger().debug(newMessage);
//        }
//
//    }
//    
//    /**
//     * Log a message into the log file.
//     *
//     * @param message
//     *            message to log into the log file.
//     */
//    public void logTrace(String message) {
//        if (needsLogging) {
//            String newMessage = this.enhanceMessage(message);
//            if ( this.lineCount == 0) {
//                getLogger().debug("BUILD TIMESTAMP = " + this.buildTimeStamp);
//                getLogger().debug("Config Propeties = " + this.configurationProperties);
//            }
//            countLines(newMessage);
//            getLogger().trace(newMessage);
//        }
//
//    }
//
//    /**
//     * Set the trace level for the stack.
//     */
//    private void setTraceLevel(int level) {
//        traceLevel = level;
//    }
//
//    /**
//     * Get the trace level for the stack.
//     */
//    public int getTraceLevel() {
//        return traceLevel;
//    }
//
//    /**
//     * Log an error message.
//     *
//     * @param message --
//     *            error message to log.
//     */
//    public void logFatalError(String message) {
//        Logger logger = this.getLogger();
//        String newMsg = this.enhanceMessage(message);
//        countLines(newMsg);
//        logger.fatal(newMsg);
//
//    }
//
//    /**
//     * Log an error message.
//     *
//     * @param message --
//     *            error message to log.
//     *
//     */
//    public void logError(String message) {
//        Logger logger = this.getLogger();
//        String newMsg = this.enhanceMessage(message);
//        countLines(newMsg);
//        logger.error(newMsg);
//
//    }
//
//    public LogWriter() {
//    }
//    
//	public void setStackProperties(Properties configurationProperties) {
//
//        this.configurationProperties = configurationProperties;
//
//        String logLevel = configurationProperties
//                .getProperty("gov.nist.javax.sip.TRACE_LEVEL");
//
//        this.logFileName = configurationProperties
//                .getProperty("gov.nist.javax.sip.DEBUG_LOG");
//
//        this.stackName = configurationProperties
//                .getProperty("javax.sip.STACK_NAME");
//
//        //check whether a Log4j logger name has been
//        //specified. if not, use the stack name as the default
//        //logger name.
//        String category = configurationProperties
//                                .getProperty("gov.nist.javax.sip.LOG4J_LOGGER_NAME", this.stackName);
//
//
//        logger = Logger.getLogger(category);
//        if (logLevel != null) {
//            if (logLevel.equals("LOG4J")) {
//                //if TRACE_LEVEL property is specified as
//                //"LOG4J" then, set the traceLevel based on
//                //the log4j effective log level.
//                Level level = logger.getEffectiveLevel();
//                this.needsLogging = true;
//                if (level == Level.OFF)
//                    this.needsLogging = false;
//                this.traceLevel = TRACE_NONE;
//                if (level.isGreaterOrEqual(Level.DEBUG)) {
//                    this.traceLevel = TRACE_DEBUG;
//                } else if (level.isGreaterOrEqual(Level.INFO)) {
//                    this.traceLevel = TRACE_INFO;
//                } else if (level.isGreaterOrEqual(Level.WARN)) {
//                    this.traceLevel = TRACE_ERROR;
//                }
//            }
//            else {
//                try {
//                    int ll = 0;
//                    if (logLevel.equals("TRACE")) {
//                        ll = TRACE_DEBUG;
//                        Debug.debug = true;
//                        Debug.setStackLogger(this);
//                    } else if (logLevel.equals("DEBUG")) {
//                        ll = TRACE_DEBUG;
//                    } else if ( logLevel.equals("INFO")) {
//                        ll = TRACE_INFO;
//                    } else if (logLevel.equals("ERROR")) {
//                        ll = TRACE_ERROR;
//                    } else if (logLevel.equals("NONE") || logLevel.equals("OFF")) {
//                        ll = TRACE_NONE;
//                    } else {
//                        ll = Integer.parseInt(logLevel);
//                        if ( ll > 32 ) {
//                            Debug.debug = true;
//                            Debug.setStackLogger(this);
//                        }
//                    }
//
//                    this.setTraceLevel(ll);
//                    this.needsLogging = true;
//                    if (traceLevel == TRACE_DEBUG) {
//                        logger.setLevel(Level.DEBUG);
//                    } else if (traceLevel == TRACE_INFO) {
//                        logger.setLevel(Level.INFO);
//                    } else if (traceLevel == TRACE_ERROR) {
//                        logger.setLevel(Level.ERROR);
//                    } else if (traceLevel == TRACE_NONE) {
//                        logger.setLevel(Level.OFF);
//                        this.needsLogging = false;
//                    }
//
//                    /*
//                     * If user specifies a logging file as part of the startup
//                     * properties then we try to create the appender.
//                     */
//                    if (this.needsLogging && this.logFileName != null) {
//
//                        boolean overwrite = Boolean.valueOf(
//                                configurationProperties.getProperty(
//                                "gov.nist.javax.sip.DEBUG_LOG_OVERWRITE"));
//
//                        FileAppender fa = null;
//                        try {
//                            fa = new FileAppender(new SimpleLayout(),
//                                    this.logFileName, !overwrite);
//                        } catch (FileNotFoundException fnf) {
//
//                            // Likely due to some directoy not existing. Create
//                            // them
//                            File logfile = new File(this.logFileName);
//                            logfile.getParentFile().mkdirs();
//                            logfile.delete();
//
//                            try {
//                                fa = new FileAppender(new SimpleLayout(),
//                                        this.logFileName);
//                            } catch (IOException ioe) {
//                                ioe.printStackTrace(); // give up
//                            }
//                        } catch (IOException ex) {
//                            ex.printStackTrace();
//                        }
//
//                        if (fa != null)
//                            logger.addAppender(fa);
//                    }
//
//                } catch (NumberFormatException ex) {
//                    ex.printStackTrace();
//                    System.err.println("LogWriter: Bad integer " + logLevel);
//                    System.err.println("logging dislabled ");
//                    needsLogging = false;
//                }
//            }
//        } else {
//            this.needsLogging = false;
//
//        }
//
//        
//    }
//
//    /**
//     * @return flag to indicate if logging is enabled.
//     */
//    public boolean isLoggingEnabled() {
//
//        return this.needsLogging;
//    }
//
//    /**
//     * Return true/false if loging is enabled at a given level.
//     *
//     * @param logLevel
//     */
//    public boolean isLoggingEnabled(int logLevel) {
//        return this.needsLogging && logLevel <= traceLevel;
//    }
//
//
//    /**
//     * Log an error message.
//     *
//     * @param message
//     * @param ex
//     */
//    public void logError(String message, Exception ex) {
//        Logger logger = this.getLogger();
//        logger.error(message, ex);
//
//    }
//
//    /**
//     * Log a warning mesasge.
//     *
//     * @param string
//     */
//    public void logWarning(String string) {
//        getLogger().warn(string);
//
//    }
//
//    /**
//     * Log an info message.
//     *
//     * @param string
//     */
//    public void logInfo(String string) {
//        getLogger().info(string);
//    }
//
//    /**
//     * Disable logging altogether.
//     *
//     */
//    public void disableLogging() {
//        this.needsLogging = false;
//    }
//
//    /**
//     * Enable logging (globally).
//     */
//    public void enableLogging() {
//        this.needsLogging = true;
//
//    }
//
//    public void setBuildTimeStamp(String buildTimeStamp) {
//        this.buildTimeStamp = buildTimeStamp;
//
//    }
//
//    public Priority getLogPriority() {
//         if ( this.traceLevel == TRACE_INFO ) {
//            return Priority.INFO;
//        } else if ( this.traceLevel == TRACE_ERROR ) {
//            return Priority.ERROR;
//        } else if ( this.traceLevel == TRACE_DEBUG) {
//            return Priority.DEBUG;
//        } else if ( this.traceLevel == TRACE_TRACE) {
//            return Priority.DEBUG;
//        } else {
//            return Priority.FATAL;
//        }
//    }
//
//    public Level getLevel(int traceLevel) {
//        if ( traceLevel == TRACE_INFO ) {
//           return Level.INFO;
//       } else if ( traceLevel == TRACE_ERROR ) {
//           return Level.ERROR;
//       } else if ( traceLevel == TRACE_DEBUG) {
//           return Level.DEBUG;
//       } else if (traceLevel == TRACE_TRACE) {
//           return Level.ALL;
//       } else {
//           return Level.OFF;
//       }
//   }
//	
//	public String getLoggerName() {
//	    if ( this.logger != null ) {
//	        return logger.getName();
//	    } else {
//	        return null;
//	    }
//	}
//
//  
//}

// END android-deleted