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

/**
 * log4js is a helper to log in JavaScript in simmilar manner than in log4j.
 * The API should be nearly the same.
 * Example:
 * <pre>
 *  //logging see log4js
 *  var log = new Logger(LogLevel.TRACE); //set the LogLevel
 *  log.setAppender(new WindowAppender()); //to log to seperate logwindow
 *  
 *  // if multiple appenders are set all will log
 *  log.setAppender(new FileAppender("C:\\somefile.log"));
 *  ...
 *  //call the log
 *  log.trace("trace me" );
 *  </pre>
 */
 
/**
 * LogLevel Enumeration
 */
var LogLevel = {
	FATAL: 5,
	ERROR: 4,
	WARN: 3,
	INFO: 2,
	DEBUG: 1,
	TRACE: 0,
	valueOf: function(level) {
		switch (level) {
			case this.TRACE:
				return "trace";
			case this.DEBUG:
				return "debug";
			case this.INFO:
				return "info";
			case this.WARN:
				return "warn";
			case this.ERROR:
				return "error";
			case this.FATAL:
				return "fatal";
			default:
				return "";
		}
	} 
	
};


/**
 * Logger to log messages to the defined appender.</p>
 * Default appender is DummyAppender, which is ignoring all messages. Please
 * use setAppender() to set a specific appender (e.g. WindowAppender).
 */
function Logger(logLevel) {
	this.appenders = [];
    this.level = logLevel || LogLevel.FATAL;
	/** appender to write in */
	this.appenders.push(new DummyAppender());
}

Logger.prototype = {
	
	setAppender: function(appender) {
		this.appenders.push(appender);
	},
	setLogLevel: function(level) {
		this.level = level;
	},
	isTraceEnabled: function() {
	    if (this.level <= LogLevel.TRACE) {
	        return true;
	    }
	    return false;
	},
	trace: function(message) {
	    if (this.isTraceEnabled()) {
	        this.log(message, LogLevel.TRACE);
	    }
	},
	isDebugEnabled: function() {
	    if (this.level <= LogLevel.DEBUG) {
	        return true;
	    }
	    return false;
	},
	debug: function(message) {
	    if (this.isDebugEnabled()) {
	        this.log(message, LogLevel.DEBUG);
	    }
	},
	isInfoEnabled: function() {
	    if (this.level <= LogLevel.INFO) {
	        return true;
	    }
	    return false;
	},
	info: function(message) {
	    if (this.isInfoEnabled()) {
	        this.log(message, LogLevel.INFO);
	    }
	},
	isWarnEnabled: function() {
	    if (this.level <= LogLevel.WARN) {
	        return true;
	    }
	    return false;
	},
	warn: function(message) {
	    if (this.isWarnEnabled()) {
	        this.log(message, LogLevel.WARN);
	    }
	},
	isErrorEnabled: function() {
	    if (this.level <= LogLevel.ERROR) {
	        return true;
	    }
	    return false;
	},
	error: function(message) {
	    if (this.isErrorEnabled()) {
	        this.log(message, LogLevel.ERROR);
	    }
	},
	isFatalEnabled: function() {
	    if (this.level <= LogLevel.FATAL) {
	        return true;
	    }
	    return false;
	},
	fatal: function(message) {
	    if (this.isFatalEnabled()) {
	        this.log(message, LogLevel.FATAL);
	    }
	},
	clear: function() {
		for(var i=0; i < this.appenders.length; i++) {
	    	this.appenders[i].clear();
		}
	},
	log: function(message, logLevel) {
		for(var i=0; i < this.appenders.length; i++) {
	    	this.appenders[i].append(message, logLevel);
		}
	}
}

/**
 * Dummy Appender doing nothing
 */
function DummyAppender() {}

DummyAppender.prototype = {
	append: function(message, logLevel) {},
	clear: function() {}
}

/**
 * Server side logging Appender
 */
function ServerSideAppender() { }
ServerSideAppender.prototype = {
    postURL: "/logging/message",
    append: function( message, loglevel) { 
        var async = new Asynchronous();
        
        async.post( this.postURL + "/" + LogLevel.valueOf( loglevel),            "application/text", message.length, message);
    },
    clear: function() { }
}

/**
 * Appender showing Logs in an own Window.
 */
function WindowAppender() {}

WindowAppender.prototype = {
	
	append: function(message, logLevel) {
		var now = new Date();
		
		if (!window.top.debugWindow || window.top.debugWindow.closed) {
			window.top.debugWindow = window.open("", "log4js",
				"left=0,top=0,width=300,height=700,scrollbars=yes," +
				"status=yes,resizable=yes");
			window.top.debugWindow.opener = self;
			var doc = window.top.debugWindow.document;
			
			if(doc.getElementById('logging-console') == null)
			{
				doc.open();
				doc.write("<DOCTYPE html PUBLIC -//W3C//DTD XHTML 1.0 Transitional//EN 	");
				doc.write("  http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd>\n\n");
				doc.write("<html xmlns=\"http://www.w3.org/1999/xhtml\">\n")
				doc.write("<head>\n<title>log4js</title>\n");
				doc.write("  <style>");
				doc.write("    body{font-family:Icon; margin:0px;} ");
				doc.write("    .fatal{color:red;} ");
				doc.write("    .error{color:red;} ");
				doc.write("    .warn{color:orange;} ");
				doc.write("    .info{color:blue;} ");
				doc.write("    .debug{color:black;}");
				doc.write("    .trace{color:grey;}");
				doc.write("  </style>");		  
				doc.write("</head>\n");
				doc.write("<body>\n");
				doc.write("<button value=\"Close\" onClick=\"self.close()\">Close</button>\n");
				//doc.write("<button value=\"Clear\" onClick=\"clearLogWindow();\">Clear</button>\n");
				doc.write("  <div id='logging-console'><ul id='log-list'></ul></div>\n");
				doc.write("</body>");
			
				window.top.debugWindow.blur();
				window.top.debugWindow.focus();
			}
			this.logConsole = doc.getElementById('logging-console');
			this.logList = doc.getElementById('log-list');
		}
		
		var loggingNode = window.top.debugWindow.document.createElement('li');
		loggingNode.className = LogLevel.valueOf(logLevel);
		
		var strNow = now.toLocaleString();
		var elem = loggingNode.appendChild( 
			window.top.debugWindow.document.createTextNode( strNow + ": " + message ));
		
		this.logList.appendChild(loggingNode);
	},
	clear: function(){
		while (this.logList.hasChildNodes()) {
        	this.logList.removeChild(this.logList.firstChild);
    	}	
	}
};

/**
 * Metatag Appender writing the logs to meta tags
 */
function MetatagAppender() {}

MetatagAppender.prototype = {
	append: function(message, level) {
		var now = new Date();
		
		var lines = message.split("\n");
		var headTag = document.getElementsByTagName("head")[0];
	
		for (var i = 1; i <= lines.length; i++) {
			var value = lines[i - 1];
	
			if (i == 1) {
				value = LogLevel.valueOf(level) + ": " + value;
			}
			else
			{
				value = "> " + value;
			}
	
			var metaTag = document.createElement("meta");
			metaTag.setAttribute("name", "X-log4js:" + Logger.currentLine++);
			metaTag.setAttribute("content", value);
			headTag.appendChild(metaTag);
		}
	},
	clear: function() {}
};

/**
 * File Appender writing the logs to a text file
 * @author Seth Chisamore
 */
function FileAppender(file) {this.file = file || "C:\\log4js.log";};

FileAppender.prototype = {
	writeFile: function(fileName, message) {
		var fso, fileHandle;
		fso = new ActiveXObject("Scripting.FileSystemObject");
		// try opening existing file, create if needed
		fileHandle = fso.OpenTextFile(fileName, 8, true);        
		// write out our data
		fileHandle.WriteLine(message);
		fileHandle.close();   
	},
	append: function(message, level) {
		var now = new Date();
		var message = now + " [" + LogLevel.valueOf(level) + "] " + message;
		this.writeFile(this.file, message);
	},
	clear: function() {}
};

/**
 * Windows Event Appender writes the logs to the Windows Event log
 * @author Seth Chisamore
 */
function WindowsEventAppender() {};

WindowsEventAppender.prototype = {
	writeWindowsEvent: function(level, data) {
		var shell;
		shell = new ActiveXObject("WScript.Shell");
		// write to windows event log
		shell.LogEvent(level, data);
	},
	append: function(message, level) {
		var now = new Date();
		var message = now + " [" + LogLevel.valueOf(level) + "] " + message;
		var level = 4;
		
		// Map log level to windows event log level.
		// Windows events: - SUCCESS: 0, ERROR: 1, WARNING: 2, INFORMATION: 4, AUDIT_SUCCESS: 8, AUDIT_FAILURE: 16
		switch (LogLevel.valueOf(level)) {	
			case "error":
				level = 1;
			case "warn":
				level = 2;
			default:
				level = 4;
		}
		this.writeWindowsEvent(level, message);
	},
	clear: function() {}
};

/**
 * Array extensions
 */
if (!Array.prototype.push) {
  Array.prototype.push = function() {
		var startLength = this.length;
		for (var i = 0; i < arguments.length; i++)
      		this[startLength + i] = arguments[i];
	  	return this.length;
  }
}

Array.prototype.contains = function(object) {
	for(var i = 0; i < this.length; i++) {
		if (object == this[i]) 
			return true;
	}
	return false;
}