/*
    * Copyright 2007 the original author or authors.
    *
    * 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.goetz.domino.log4j;
  
  import java.net.InetAddress;
  import java.net.UnknownHostException;
  import java.util.Date;
  
  import lotus.domino.Database;
  import lotus.domino.DateTime;
  import lotus.domino.Document;
  import lotus.domino.NotesException;
  import lotus.domino.Session;
  
  import org.apache.log4j.AppenderSkeleton;
  import org.apache.log4j.Layout;
  import org.apache.log4j.SimpleLayout;
  import org.apache.log4j.helpers.LogLog;
  import org.apache.log4j.helpers.PatternConverter;
  import org.apache.log4j.helpers.PatternParser;
  import org.apache.log4j.spi.ErrorCode;
  import org.apache.log4j.spi.LoggingEvent;
  
  /***
   * This is the base appender for a log4j agent and servlet appender 
   * implementation that log to a Domino database using a memory buffer and 
   * delayed writing.
   *  
   * @author Bernd G?tz
   */
  public abstract class AbstractAppender extends AppenderSkeleton {
  
      /***
       * The total number of records processed by this Appender.
       */
      private long totalLogLinesCount = 0;
      
      /***
       * If this appender has been initialized or not.
       */
      private boolean initialized = false;
  
  	protected LogDocument doc = new LogDocument();
  	
  	private Date lastWrite = new Date();
  	
  	private static int DEFAULT_FLUSHTIMEOUT = 20000;
  	
  	private int flushTimeout = DEFAULT_FLUSHTIMEOUT;
  	
      /***
       * Creates a new DominoAppender.
       */
      public AbstractAppender() {
          super();
      }
  
      /***
  	 * Reads the message property that contains a pattern
  	 * converter layout including an additional variable: %u
  	 * for agent user.
  	 *
  	 * @param message the pattern layout
  	 */
  	public void setMessage(String message) {
  		doc.setMessage(message);
  	}
  
      /***
  	 * Returns the currently set message.
  	 *
  	 */
  	public String getMessage() {
  		return doc.getMessage();
  	}
  
  	/***
  	 * Sets the name under which the log entries appear.
  	 * 
  	 * @param appName application name
  	 */
  	public void setApplicationName(String appName) {
  		doc.setApplicationName(appName);
  	}
  	
 	/***
 	 * Returns the application name under which the log entries appear.
 	 * 
 	 * @return application name
 	 */
 	public String getApplicationName() {
 		return doc.getApplicationName();
 	}
 	
 	/***
      * Sets the form from the log4j properties.
      *
      * @param form the form name.
      */
     public void setFormName(String formName) {
     	doc.setFormName(formName);
     }
 
 	/***
      * Returns the form name.
      *
      */
     public String getFormName() {
     	return doc.getFormName();
     }
 
     /***
      * Sets the internal buffer size.
      *
      * @param bufferSize the new buffer size.
      */
     public void setMaxLines(int maxLines) {
         doc.setMaxLines(maxLines);
     }
 
     /***
      * Sets the internal buffer size.
      *
      */
     public int getMaxLines() {
         return doc.getMaxLines();
     }
 
     /***
      * Sets the Domino serverName to log to.
      *
      * @param serverName the server name where the databaseName to log to is on.
      */
     public void setServer(String serverName) {
         doc.setServerName(serverName);
     }
 
     /***
      * Returns the serverName name.
      *
      */
     public String getServer() {
         return doc.getServerName();
     }
 
     /***
 	 * Returns the databaseName name.
 	 *
 	 */
 	public String getDatabase() {
 		return doc.getDatabaseName();
 	}
 
 	/***
      * Sets the databaseName path to log to.
      *
      * @param databaseName the path to the databaseName to log to.
      */
     public void setDatabase(String databaseName) {
     	doc.setDatabaseName(databaseName);
     }
 
     public int getFlushTimeout() {
 		return flushTimeout;
 	}
 
 	public void setFlushTimeout(int flushTimeout) {
 		this.flushTimeout = flushTimeout;
 	}
 
 	/***
      * Always returns false. This Appender creates it¥s own
      * SimpleLayout if no Layout is supplied.
      *
      * @return always false
      */
     public boolean requiresLayout() {
         return false;
     }
 
     /***
      * Returns the Layout used by this Appender.
      *
      * @return the current Layout.
      */
     public Layout getLayout() {
         return this.layout;
     }
 
     /***
      * Test if this Appender can append LoggingEvents.
      *
      * @param event the LoggingEvent to process.
      * @return false if the appender is not ready to get LoggingEvents,
      * true otherwise.
      */
     protected boolean checkEntryConditions(LoggingEvent event) 
     	throws NotesException {
 
         if (closed) {
             LogLog.warn("Appender [" + name + "] closed. Can¥t append.");
             return false;
         }
         // TODO: check database and current doc id here?
         return true;
     }
 
     /***
      * Writes the log entry to the notes document.
      * 
      * A log4j pattern parser is used. In addition %u is supported for user 
      * name. Sample: %d %t %u - %m
      *
      * @param doc current log document
      * @param event the LoggingEvent to act on.
      * @throws NotesException if the Appender could not
      * write to the current Document.
      */
     protected void addEvent(LoggingEvent event)
             throws NotesException {
     	// 1. replace %u by current agent user:
     	String p;
     	if (doc.messageContainsUserVariable()) {
         	p = replace(doc.getMessage(), "%u", retrieveUserName());
     	} else {
         	p = doc.getMessage();
     	}
         PatternConverter pc = new PatternParser(p).parse();
     	
         StringBuffer buf = new StringBuffer();
 
         while (pc != null) {
             pc.format(buf, event);
             pc = pc.next;
         }
         doc.add(buf.toString());
         totalLogLinesCount++;
 
         // log exception stack traces:
         if (event.getThrowableInformation() != null) {
         	int l = event.getThrowableStrRep().length;
         	String[] t = event.getThrowableStrRep();
         	for (int i = 0; i < l; i++) {
         		doc.add(t[i]);
                 totalLogLinesCount++;
         	}
         }
     }
 
     /***
 	 * Initializes application name and path. 
 	 * 
 	 * This is being called only once per appender instance, in contrast to 
 	 * <code>initAppend()</code> and <code>releaseAppend()</code> which are
 	 * being called each log <code>append</code> call. 
 	 * 
 	 */
 	protected abstract void initialize(LoggingEvent event) 
 		throws Exception;
 
 	/***
 	 * Returns the session for this log entry.
 	 * 
 	 * Domino invalidates the session for each new thread, the private session
 	 * object.
 	 * <p>The method is not called <code>getSession</code> because bean 
 	 * naming conventions would then interpret "session" as a property of the
 	 * agent.</p>  
 	 * 
 	 * @return current session.
 	 * @throws NotesException
 	 */
 	abstract Session retrieveSession() throws NotesException;
 
 	/***
      * Gets the Domino Database to log to.
      * Initializes communication with Domino, if this is the first call.
      * 
      * @return the Domino Database object to log to.
      */
     abstract Database getDominoDatabase(Session session) 
     	throws NotesException;
     
     /***
      * Initialises the appender, e.g. with thread initialisation.
      * 
      * @throws NotesException
      */
     abstract void initAppend() throws NotesException;
 
 	/***
 	 * Called to release resources on a per log statement level, e.g. thread
 	 * cleanup.
 	 * 
 	 * This method is always called, even in the case of an error. So be aware
 	 * that some resources might not be valid anymore. 
 	 */
 	abstract void releaseAppend();
 
     /***
      * Return the user name.
      *
 	 * <p>The method is not called <code>getUserName</code> because bean 
 	 * naming conventions would then interpret "userName" as a property of the
 	 * agent.</p>
 	 *   
      * @throws NotesException
      */
     abstract String retrieveUserName() throws NotesException;
 
 	/***
      * Appends the specified event to this DominoAppender. The
      * Logger is responsible for this.
      *
      * @param event the LoggingEvent to append.
      */
     public void append(LoggingEvent event) {
         try {
         	if (closed) {
                 LogLog.warn("Appender '" + getName() + 
                 		"' closed, can¥t append.");
                 return;
             }
         	// one time init for the layout:
             if (layout == null) {
                 layout = new SimpleLayout();
             }
             initAppend();
             if (!initialized) {
             	LogLog.debug("Initialize appender '" + getName() + 
             			"' now once.");
                 initialize(event);
                 initialized = true;
             }
             if (doc.getCurrentSize() == 0) {
             	doc.setStartTime(new Date());
             }
             addEvent(event);
             // either one of the following conditions leads to writing the 
             // document: 
             // 1) the document is full
             // 2) the number of maximum lines has been reached
             // 3) it's more than n seconds ago that we did not write the 
             //    document
             if (doc.isFull()) {
             	LogLog.debug("Document is full now");
                 writeDocument();
                 totalLogLinesCount += doc.getCurrentLines();
                 doc.reset(new Date());
                 return;
             }
             if (((new Date()).getTime() - lastWrite.getTime()) >= flushTimeout) {
             	// flush the document to the database:
             	LogLog.debug("Flush timeout value reached");
             	writeDocument();
             }
         } catch (NotesException e) {
             if (e.id == 4000) {
                 LogLog.debug("Field is too large, dropping current document");
             	// field is too large, drop current document:
             	doc.reset(new Date());
             }
     	    errorHandler.error("Received Notes exception", e,
   				   ErrorCode.GENERIC_FAILURE);
         } catch (Exception e) {
     	    errorHandler.error("Received exception", e,
    				   ErrorCode.GENERIC_FAILURE);
         } finally {
         	releaseAppend();
         }
     }
     
     /***
      * Returns the Domino Document that the current LoggingEvents should be
      * written to.
      *
      * @return the Domino Document to write logs to.
      */
     protected Document getLogDocument(Database db) 
     	throws NotesException {
     	
     	LogLog.debug("Return current log document");
     	
     	Document document = null;
     	
 		if (doc.getCurrentDocId() == null) {
 			// No document was created yet, start it now:
 			LogLog.debug("Create new log document");
             document = db.createDocument();
 		} else {
 			// a current document exists, use it:
 			try {
 				LogLog.debug("Retrieve log document using id '" + 
 					doc.getCurrentDocId() + "'");
 				document = db.getDocumentByID(doc.getCurrentDocId());
 				if ((document == null) || (!document.isValid()) ||
 					(document.isDeleted())) {
 					// not good, create a new one:
 					LogLog.debug("Create new log docunent anyway");
 					document = db.createDocument();
 				}
 			} catch (NotesException e) {
 				// the id is invalid, start a new document:
 				LogLog.debug("Invalid id, create new log document anyway");
 				document = db.createDocument();
 			}
 		}
         return document;
     }
 
     /***
      * Writes the document to the database without the finish date.
      * 
      * @param session
      * @throws NotesException
      */
     private void writeDocument() 
     	throws NotesException {
     	
     	if (!doc.isDirty()) {
     		LogLog.debug("No new entries in cache, don't write to database");
     		return;
     	}
     	
     	LogLog.debug("Writing Notes document now...");
     	lastWrite = new Date();
 
     	Session session = null;
     	Database db = null;
     	Document document = null;
 
     	try {
     		
     		session = retrieveSession();
     		if (session != null) {
     	    	db = getDominoDatabase(session);
     	    	document = getLogDocument(db);
     	    	
     	    	boolean isNew = document.isNewNote();
     	
     	    	if (isNew) {
     	    		LogLog.debug("Document is new, initializing...");
     	    		// only write these fields if the document was just created:
     		        document.replaceItemValue("Form", doc.getFormName());
     		        String serverName = session.getServerName();
     		        if (serverName.length() == 0) {
     		        	// local (or other reasons?)
     		        	try {
     		        		LogLog.debug("Trying to get the host name...");
     		        		serverName = InetAddress.getLocalHost().getHostName();
     		        	} catch (UnknownHostException e) {
     		        		LogLog.debug(
     		        				"Unknown host exception, setting server name to 'local'");
     		        		serverName = "local";
     		        	}
     		        }
     		        //document.replaceItemValue("UserName", session.getUserName());
     		        document.replaceItemValue("Server", serverName);
     		        document.replaceItemValue("AppName", doc.getApplicationName());
     		        document.replaceItemValue("AppPath", doc.getApplicationPath());
     		        DateTime start = retrieveSession().createDateTime(doc.getStartTime());
     		        document.replaceItemValue("StartTime", start);
     		        start.recycle();
     	    	}
     	    	
     	    	LogLog.debug("Setting events now...");
     	        document.replaceItemValue("Events", doc.getEvents());
     	
     	        if (doc.getFinishTime() != null) {
     	        	// finish the document:
     	        	LogLog.debug("Finish the document now...");
     	            DateTime t = retrieveSession().createDateTime("Today");
     	            t.setNow();
     	            document.replaceItemValue("FinishTime", t);        
     	            document.replaceItemValue("EventCount", 
     	            		new Long(doc.getCurrentLines()));
     	            doc.setCurrentDocId(null);
     	            t.recycle();
     	        }
     	        LogLog.debug("Saving Domino document now...");
     	        document.save();
     	        if (isNew && (doc.getFinishTime() == null)) {
     	        	// we only get a valid note id after save:
     	        	doc.setCurrentDocId(document.getNoteID());
     	        }
     		}
     	} finally {
     		if (document != null) {
     			document.recycle();
     		}
     		if (db != null) {
     			db.recycle();
     		}
 //    		if (session != null) {
 //    			session.recycle();
 //    		}
     	}
     }
     
     /***
      * Closes this appender.
      * 
      */
     public void close() {
     	// TODO write a tail to the last log doc.
         LogLog.debug("Closing the appender '" + getName() + "'");
         try {
         	writeDocument();
             releaseAppend();
         } catch (NotesException e) {
             LogLog.error("Caught Notes exception", e);
         }
         if (!closed) {
         	closed = true;
         }
     }
 
     /***
 	 * Replace a pattern in a string with Java 1.3.
 	 *
 	 * @param s is the original String which may contain substring aOldPattern
 	 * @param oldPattern is the non-empty substring which is to be replaced
 	 * @param newPattern is the replacement for aOldPattern
 	 */
 	protected String replace(final String s,
 			final String oldPattern, final String newPattern) {
 		if (oldPattern.equals("")) {
 			throw new IllegalArgumentException("Old pattern must have content.");
 		}
 
 		final StringBuffer result = new StringBuffer();
 		//startIdx and idxOld delimit various chunks of aInput; these
 		//chunks always end where aOldPattern begins
 		int startIdx = 0;
 		int idxOld = 0;
 		while ((idxOld = s.indexOf(oldPattern, startIdx)) >= 0) {
 			//grab a part of aInput which does not include aOldPattern
 			result.append(s.substring(startIdx, idxOld));
 			//add aNewPattern to take place of aOldPattern
 			result.append(newPattern);
 
 			//reset the startIdx to just after the current match, to see
 			//if there are any further matches
 			startIdx = idxOld + oldPattern.length();
 		}
 		//the final chunk will go to the end of aInput
 		result.append(s.substring(startIdx));
 		return result.toString();
 	}
 
 }