<?php

namespace Lumberjack;

//error_reporting(E_ALL|E_STRICT);

/*******************************************
* LumberJack
*
* LumberJack serves as a simple logging class with extensibility
*   through the use of LoggingAdapters, the default being BasicOutput.
*   Dependency injection is used to configure
*   which adapter will be utilized by LumberJack.
*
********************************************/

final class LumberJack {
	const DEBUG   = 5;
	const INFO    = 4;
	const WARNING = 3;
	const ERROR   = 2;
	const FATAL   = 1;
	const ALL     = 0;

	private $adapter;
	private $level = self::WARNING;
	private $pattern = '%p [%d{M d, o - H:i:sA}] %m%n';
	private $identifier;

	private static $loggers = NULL;

	private function __construct($identifier, LoggingAppender $adapter) {
	  $this->identifier = $identifier;
		$this->adapter = $adapter;
	}

	public static function instance($identifier, LoggingAdapter $adapter = NULL) {
		if(isset(self::$loggers[$identifier]) == FALSE) {
		  if(isset($adapter) == FALSE) {
        $adapter = new BasicOutput();
		  }
			self::$loggers[$identifier] = new LumberJack($identifier, $adapter);
		}
		return self::$loggers[$identifier];
	}

	public function info($message) {
	  $this->log(self::INFO, $message);
	}

	public function debug($message) {
	  $this->log(self::DEBUG, $message);
	}

	public function warn($message) {
	  $this->log(self::WARN, $message);
	}

	public function error($message) {
	  $this->log(self::ERROR, $message);
	}

	public function fatal($message) {
	  $this->log(self::FATAL, $message);
	}

	private function log($level, $message) {
    if($level <= $this->level) {
      $msg = PatternParser::parse($this->pattern, $this->identifier, $message, $level);
      $this->adapter->log($msg);
    }
	}

	public function setLevel($level) {
		$this->level = $level;
	}

	public function getLevel() {
		return $this->level;
	}

	private function setPattern($pattern) {
	  $this->pattern = $pattern;
	}
}

final class PatternParser {

  private static $trace = NULL;

  public static function parse($pattern, $identifier, $message, $level) {
    $count = preg_match_all('/(?:%(\w)(?:{(.+)})?(?!\w))/', $pattern, $matches, PREG_SET_ORDER);
    foreach($matches as $match) {
      $replacement = '';
      switch($match[1]) {
        case 'd':
          $replacement = @date($match[2]);
          break;
        case 'F':
          $replacement = self::trace('file');
          break;
        case 'i':
          $replacement = $identifier;
          break;
        case 'l':
          $replacement = self::trace('location');
          break;
        case 'L':
          $replacement = self::trace('line');
          break;
        case 'm':
          $replacement = $message;
          break;
        case 'M':
          $replacement = self::trace('function');
          break;
        case 'n':
          $replacement = (PHP_SAPI === 'cli') ? PHP_EOL : '<br/>';
          break;
        case 'p':
          $replacement = self::convert($level);
          break;
      }
      $pattern = str_replace($match[0], $replacement, $pattern);
    }
    return $pattern;
  }

  private static function trace($key) {
    if(isset(self::$trace)) {
      return isset($key) ? $trace[$key] : $trace;
    }
    $trace = debug_backtrace(DEBUG_BACKTRACE_PROVIDE_OBJECT|DEBUG_BACKTRACE_IGNORE_ARGS);
    foreach($trace as $current) {
      if(strpos($current['class'], 'LumberJack/') === FALSE) {
        $file = $current['file'];
        $current['location'] = $file;
        $current['file'] = substr(strrchr($file, '/'), 1);
        self::$trace = $current;
        break;
      }
    }
  }

  private static function convert($level) {
    switch($level) {
      case LumberJack::FATAL:
        return 'FATAL';
      case LumberJack::ERROR:
        return 'ERROR';
      case LumberJack::WARNING:
        return 'WARNING';
      case LumberJack::INFO:
        return 'INFO';
      case LumberJack::DEBUG:
        return 'DEBUG';
    }
  }
}


/*******************************************
* LoggingAppender
*
* LoggingAppender is an interface which can be implemented
*		to create new means of logging messages and errors from
*		the LumberJack library
*
*	Two implements are contained below: BasicOutput and FileLogging
* + BasicOutput simply prints messages to the screen, hence the name.
* + FileLogging writes all messages to a set
*
********************************************/
abstract class LoggingAppender {
	abstract public function log($message);
}

class BasicOutput extends LoggingAppender {
	public function log($message) {
	  echo $message;
	}
}

class FileLogging extends LoggingAppender {
	private $filename;

	public function __construct($filename = NULL){
		$date = date('omd');
		if($filename == NULL){
			$filename = 'errors-' . $date . '.log';
		}
		$this->filename = $filename;
	}

	public function log($message) {
		$handle = fopen($this->filename, 'a');
		if($handle != FALSE) {
			fwrite($handle, $message);
			fclose($handle);
		}
	}
}

?>