/*
    * Copyright (C) 2007-2012 Argeo GmbH
    *
    * Licensed 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.
   */
  package org.argeo.slc.log4j;
  
  import java.util.Date;
  import java.util.concurrent.BlockingQueue;
  
  import org.apache.log4j.AppenderSkeleton;
  import org.apache.log4j.Level;
  import org.apache.log4j.Logger;
  import org.apache.log4j.spi.LoggingEvent;
  import org.argeo.slc.core.execution.ExecutionThread;
  import org.argeo.slc.core.execution.ProcessThreadGroup;
  import org.argeo.slc.execution.ExecutionStep;
  
  /** Not meant to be used directly in standard log4j config */
  public class SlcExecutionAppender extends AppenderSkeleton {
  
  	private Boolean disabled = false;
  
  	private String level = null;
  
  	private Level log4jLevel = null;
  
  	/** Marker to prevent stack overflow */
  	private ThreadLocal<Boolean> dispatching = new ThreadLocal<Boolean>() {
  
  		@Override
  		protected Boolean initialValue() {
  			return false;
  		}
  	};
  
  	// private Layout layout = null;
  	// private String pattern = "%m - %c%n";
  	private Boolean onlyExecutionThread = false;
  
  	public void init() {
  		// if (layout != null)
  		// setLayout(layout);
  		// else
  		// setLayout(new PatternLayout(pattern));
  		Logger.getRootLogger().addAppender(this);
  	}
  
  	@Override
  	protected void append(LoggingEvent event) {
  		if (disabled)
  			return;
  
  		if (dispatching.get())
  			return;
  
  		if (level != null && !level.trim().equals("")) {
  			if (log4jLevel == null || !log4jLevel.toString().equals(level))
  				try {
  					log4jLevel = Level.toLevel(level);
  				} catch (Exception e) {
  					System.err
  							.println("Log4j level could not be set for level '"
  									+ level + "', resetting it to null.");
  					e.printStackTrace();
  					level = null;
  				}
  
  			if (log4jLevel != null
  					&& !event.getLevel().isGreaterOrEqual(log4jLevel)) {
  				return;
  			}
  		}
  
  		// Check whether we are within an executing process
  		Thread currentThread = Thread.currentThread();
  		if (currentThread.getThreadGroup() instanceof ProcessThreadGroup) {
  			if (onlyExecutionThread
  					&& !(currentThread instanceof ExecutionThread))
  				return;
  
  			final String type;
  			if (event.getLevel().equals(Level.ERROR)
  					|| event.getLevel().equals(Level.FATAL))
  				type = ExecutionStep.ERROR;
  			else if (event.getLevel().equals(Level.WARN))
  				type = ExecutionStep.WARNING;
  			else if (event.getLevel().equals(Level.INFO))
  				type = ExecutionStep.INFO;
 			else if (event.getLevel().equals(Level.DEBUG))
 				type = ExecutionStep.DEBUG;
 			else if (event.getLevel().equals(Level.TRACE))
 				type = ExecutionStep.TRACE;
 			else
 				type = ExecutionStep.INFO;
 
 			ExecutionStep step = new ExecutionStep(event.getLoggerName(),
 					new Date(event.getTimeStamp()), type, event.getMessage()
 							.toString());
 
 			try {
 				dispatching.set(true);
 				BlockingQueue<ExecutionStep> steps = ((ProcessThreadGroup) currentThread
 						.getThreadGroup()).getSteps();
 				if (steps.remainingCapacity() == 0) {
 					stdOut("WARNING: execution steps queue is full, skipping step: "
 							+ step);
 					// FIXME understand why it block indefinitely: the queue
 					// should be emptied by the logging thread
 				} else {
 					steps.add(step);
 				}
 			} finally {
 				dispatching.set(false);
 			}
 		}
 	}
 
 	public void destroy() throws Exception {
 		Logger.getRootLogger().removeAppender(this);
 	}
 
 	public void close() {
 	}
 
 	public boolean requiresLayout() {
 		return false;
 	}
 
 	// public void setLayout(Layout layout) {
 	// this.layout = layout;
 	// }
 
 	/** For development purpose, since using regular logging is not easy here */
 	static void stdOut(Object obj) {
 		System.out.println(obj);
 	}
 
 	// public void setPattern(String pattern) {
 	// this.pattern = pattern;
 	// }
 
 	public void setOnlyExecutionThread(Boolean onlyExecutionThread) {
 		this.onlyExecutionThread = onlyExecutionThread;
 	}
 
 	public void setDisabled(Boolean disabled) {
 		this.disabled = disabled;
 	}
 
 	public void setLevel(String level) {
 		this.level = level;
 	}
 
 }