<?php

/**
 * The main logger class for SimpleSAMLphp.
 *
 * @author Lasse Birnbaum Jensen, SDU.
 * @author Andreas Åkre Solberg, UNINETT AS. <andreas.solberg@uninett.no>
 * @package simpleSAMLphp
 * @version $ID$
 */

class SimpleSAML_Logger
{
    private static $loggingHandler = NULL;
    private static $logLevel = NULL;
    private static $captureLog = FALSE;
    private static $capturedLog = array();

    /**
     * Array with messages logged before the logging handler was initialized.
     *
     * @var array
     */
    private static $earlyLog = array();


    /**
     * This constant defines the string we set the track ID to while we are fetching the track ID from the session
     * class. This is used to prevent infinite recursion.
     */
    private static $TRACKID_FETCHING = '_NOTRACKIDYET_';

    /**
     * This variable holds the track ID we have retrieved from the session class. It can also be NULL, in which case
     * we haven't fetched the track ID yet, or TRACKID_FETCHING, which means that we are fetching the track ID now.
     */
    private static $trackid = NULL;

    /**
     * This variable holds the format used to log any message. Its use varies depending on the log handler used (for
     * instance, you cannot control here how dates are displayed when using syslog or errorlog handlers), but in
     * general the options are:
     *
     * - %date{<format>}: the date and time, with its format specified inside the brackets. See the PHP documentation
     *   of the strftime() function for more information on the format. If the brackets are omitted, the standard
     *   format is applied. This can be useful if you just want to control the placement of the date, but don't care
     *   about the format.
     *
     * - %process: the name of the SimpleSAMLphp process. Remember you can configure this in the 'logging.processname'
     *   option.
     *
     * - %level: the log level (name or number depending on the handler used).
     *
     * - %stat: if the log entry is intended for statistical purposes, it will print the string 'STAT ' (bear in mind
     *   the trailing space).
     *
     * - %trackid: the track ID, an identifier that allows you to track a single session.
     *
     * - %srcip: the IP address of the client. If you are behind a proxy, make sure to modify the
     *   $_SERVER['REMOTE_ADDR'] variable on your code accordingly to the X-Forwarded-For header.
     *
     * - %msg: the message to be logged.
     *
     * @var string The format of the log line.
     */
    private static $format = '%date{%b %d %H:%M:%S} %process %level %stat[%trackid] %msg';

    const EMERG = 0;
    const ALERT = 1;
    const CRIT = 2;
    const ERR = 3;
    const WARNING = 4;
    const NOTICE = 5;
    const INFO = 6;
    const DEBUG = 7;


    /**
     * Log an emergency message.
     *
     * @var string $string The message to log.
     */
    public static function emergency($string)
    {
        self::log(self::EMERG, $string);
    }


    /**
     * Log a critical message.
     *
     * @var string $string The message to log.
     */
    public static function critical($string)
    {
        self::log(self::CRIT, $string);
    }


    /**
     * Log an alert.
     *
     * @var string $string The message to log.
     */
    public static function alert($string)
    {
        self::log(self::ALERT, $string);
    }


    /**
     * Log an error.
     *
     * @var string $string The message to log.
     */
    public static function error($string)
    {
        self::log(self::ERR, $string);
    }


    /**
     * Log a warning.
     *
     * @var string $string The message to log.
     */
    public static function warning($string)
    {
        self::log(self::WARNING, $string);
    }

    /**
     * We reserve the notice level for statistics, so do not use this level for other kind of log messages.
     *
     * @var string $string The message to log.
     */
    public static function notice($string)
    {
        self::log(self::NOTICE, $string);
    }


    /**
     * Info messages are a bit less verbose than debug messages. This is useful to trace a session.
     *
     * @var string $string The message to log.
     */
    public static function info($string)
    {
        self::log(self::INFO, $string);
    }


    /**
     * Debug messages are very verbose, and will contain more information than what is necessary for a production
     * system.
     *
     * @var string $string The message to log.
     */
    public static function debug($string)
    {
        self::log(self::DEBUG, $string);
    }


    /**
     * Statistics.
     *
     * @var string $string The message to log.
     */
    public static function stats($string)
    {
        self::log(self::NOTICE, $string, TRUE);
    }


    /**
     * Set the logger to capture logs.
     *
     * @var boolean $val Whether to capture logs or not. Defaults to TRUE.
     */
    public static function setCaptureLog($val = TRUE)
    {
        self::$captureLog = $val;
    }


    /**
     * Get the captured log.
     */
    public static function getCapturedLog()
    {
        return self::$capturedLog;
    }


    private static function createLoggingHandler()
    {
        // set to FALSE to indicate that it is being initialized
        self::$loggingHandler = FALSE;

        // get the configuration
        $config = SimpleSAML_Configuration::getInstance();
        assert($config instanceof SimpleSAML_Configuration);

        // get the metadata handler option from the configuration
        $handler = $config->getString('logging.handler', 'syslog');

        // setting minimum log_level
        self::$logLevel = $config->getInteger('logging.level', self::INFO);

        $handler = strtolower($handler);

        if ($handler === 'syslog') {
            $sh = new SimpleSAML_Logger_LoggingHandlerSyslog();
        } elseif ($handler === 'file') {
            $sh = new SimpleSAML_Logger_LoggingHandlerFile();
        } elseif ($handler === 'errorlog') {
            $sh = new SimpleSAML_Logger_LoggingHandlerErrorLog();
        } else {
            throw new Exception(
                'Invalid value for the [logging.handler] configuration option. Unknown handler: ' . $handler
            );
        }

        self::$format = $config->getString('logging.format', self::$format);
        $sh->setLogFormat(self::$format);

        // set the session handler
        self::$loggingHandler = $sh;
    }


    private static function log($level, $string, $statsLog = FALSE)
    {
        if (self::$loggingHandler === NULL) {
            /* Initialize logging. */
            self::createLoggingHandler();

            if (!empty(self::$earlyLog)) {
                error_log('----------------------------------------------------------------------');
                // output messages which were logged before we properly initialized logging
                foreach (self::$earlyLog as $msg) {
                    self::log($msg['level'], $msg['string'], $msg['statsLog']);
                }
            }
        } elseif (self::$loggingHandler === FALSE) {
            // some error occurred while initializing logging
            if (empty(self::$earlyLog)) {
                // this is the first message
                error_log('--- Log message(s) while initializing logging ------------------------');
            }
            error_log($string);

            self::$earlyLog[] = array('level' => $level, 'string' => $string, 'statsLog' => $statsLog);
            return;
        }

        if (self::$captureLog) {
            $ts = microtime(TRUE);
            $msecs = (int) (($ts - (int) $ts) * 1000);
            $ts = GMdate('H:i:s', $ts).sprintf('.%03d', $msecs).'Z';
            self::$capturedLog[] = $ts.' '.$string;
        }

        if (self::$logLevel >= $level || $statsLog) {
            if (is_array($string)) {
                $string = implode(",", $string);
            }

            $formats = array('%trackid', '%msg', '%srcip', '%stat');
            $replacements = array(self::getTrackId(), $string, $_SERVER['REMOTE_ADDR']);

            $stat = '';
            if ($statsLog) {
                $stat = 'STAT ';
            }
            array_push($replacements, $stat);

            $string = str_replace($formats, $replacements, self::$format);
            self::$loggingHandler->log($level, $string);
        }
    }


    /**
     * Retrieve the track ID we should use for logging. It is used to avoid infinite recursion between the logger class
     * and the session class.
     *
     * @return string The track ID we should use for logging, or 'NA' if we detect recursion.
     */
    private static function getTrackId()
    {
        if (self::$trackid === self::$TRACKID_FETCHING) {
            // recursion detected!
            return 'NA';
        }

        if (self::$trackid === NULL) {
            // no track ID yet, fetch it from the session class

            // mark it as currently being fetched
            self::$trackid = self::$TRACKID_FETCHING;

            // get the current session. This could cause recursion back to the logger class
            $session = SimpleSAML_Session::getSessionFromRequest();

            // update the track ID
            self::$trackid = $session->getTrackID();
        }

        assert('is_string(self::$trackid)');
        return self::$trackid;
    }
}