<?php
/**
 * FuzeWorks Framework Core.
 *
 * The FuzeWorks PHP FrameWork
 *
 * Copyright (C) 2013-2019 TechFuze
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * @author    TechFuze
 * @copyright Copyright (c) 2013 - 2019, TechFuze. (http://techfuze.net)
 * @license   https://opensource.org/licenses/MIT MIT License
 *
 * @link  http://techfuze.net/fuzeworks
 * @since Version 0.0.1
 *
 * @version Version 1.3.0
 */

namespace FuzeWorks;

use Exception;
use FuzeWorks\Exception\ConfigException;
use FuzeWorks\Exception\EventException;
use Throwable;

/**
 * Logger Class.
 *
 * The main tool to handle errors and exceptions. Provides some tools for debugging and tracking where errors take place
 * All fatal errors get catched by this class and get displayed if configured to do so.
 * Also provides utilities to benchmark the application.
 *
 * @author    TechFuze <contact@techfuze.net>
 * @copyright Copyright (c) 2013 - 2019, TechFuze. (http://techfuze.net)
 */
class Logger {

    /**
     * All log entries, unsorted.
     *
     * @var array
     */
    public static array $logs = [];

    /**
     * whether to output the log after FuzeWorks has run.
     *
     * @var bool
     */
    private static bool $print_to_screen = false;

    /**
     * Whether the Logger has been enabled or not
     *
     * @var bool
     */
    private static bool $isEnabled = false;

    /**
     * whether to output the log of the last entire request to a file after FuzeWorks has run.
     *
     * @var bool
     */
    private static $log_last_request = false;

    /**
     * Whether to output the log of all errors to a file after FuzeWorks has run
     *
     * @var bool
     */
    private static $log_errors_to_file = false;

    /**
     * The template to use when parsing the debug log
     * 
     * @var string Template name
     */
    private static string $logger_template = 'logger_cli';

    /**
     * whether to output the log after FuzeWorks has run, regardless of conditions.
     *
     * @var bool
     */
    public static bool $debug = false;

    /**
     * List of all benchmark markpoints.
     * 
     * @var array
     */
    public static array $markPoints = [];

    /**
     * Initiates the Logger.
     *
     * Registers the error and exception handler, when required to do so by configuration
     * @throws ConfigException
     */
    public function __construct()
    {
        // Get the config file
        $cfg_error = Factory::getInstance()->config->getConfig('error');

        // Register the error handler, Untestable
        // @codeCoverageIgnoreStart
        if ($cfg_error->get('fuzeworks_error_reporting') == true)
        {
            self::enableHandlers();
        }
        // @codeCoverageIgnoreEnd

        // Set PHP error reporting
        if ($cfg_error->get('php_error_reporting'))
            error_reporting(true);
        else
            error_reporting(false);

        // Set the environment variables
        self::$log_last_request = $cfg_error->get('log_last_request_to_file');
        self::$log_errors_to_file = $cfg_error->get('log_errors_to_file');
        self::newLevel('Logger Initiated');
    }

    /**
     * Enable error to screen logging.
     */
    public static function enable()
    {
        self::$isEnabled = true;
    }

    /**
     * Disable error to screen logging.
     */
    public static function disable()
    {
        self::$isEnabled = false;
    }

    /**
     * Returns whether screen logging is enabled.
     */
    public static function isEnabled(): bool
    {
        return self::$isEnabled;
    }

    /**
     * Enable outputting the debugger after the request has been processed
     */
    public static function enableScreenLog()
    {
        if (!Core::isProduction())
            self::$print_to_screen = true;
    }

    /**
     * Disable outputting the debugger after the request has been processed
     */
    public static function disableScreenLog()
    {
        self::$print_to_screen = false;
    }

    /**
     * Enable FuzeWorks error handling
     *
     * Registers errorHandler() and exceptionHandler() as the respective handlers for PHP
     * @codeCoverageIgnore
     */
    public static function enableHandlers()
    {
        Core::addErrorHandler(['\FuzeWorks\Logger', 'errorHandler']);
        Core::addExceptionHandler(['\FuzeWorks\Logger', 'exceptionHandler']);
    }

    /**
     * Disable FuzeWorks error handling
     *
     * Unregisters errorHandler() and exceptionHandler() as the respective handlers for PHP
     * @codeCoverageIgnore
     */
    public static function disableHandlers()
    {
        Core::removeErrorHandler(['\FuzeWorks\Logger', 'errorHandler']);
        Core::removeExceptionHandler(['\FuzeWorks\Logger', 'exceptionHandler']);
    }

    /**
     * Function to be run upon FuzeWorks shutdown.
     *
     * @codeCoverageIgnore
     *
     * Logs data to screen when requested to do so
     * @throws EventException
     */
    public static function shutdown()
    {
        // And finally stop the Logging
        self::stopLevel();

        if (self::$debug === true || self::$print_to_screen) {
            self::log('Parsing debug log');
            self::logToScreen();
        }

        if (self::$log_last_request == true)
            self::logLastRequest();

        if (self::$log_errors_to_file == true)
            self::logErrorsToFile();
    }

    /**
     * Function to be run upon FuzeWorks shutdown.
     *
     * @codeCoverageIgnore
     *
     * Logs a fatal error and outputs the log when configured or requested to do so
     */
    public static function shutdownError()
    {
        $error = error_get_last();
        if ($error !== null) {
             // Log it!
            $thisType = self::getType($error['type']);
            $LOG = array('type' => (!is_null($thisType) ? $thisType : 'ERROR'),
                'message' => $error['message'],
                'logFile' => $error['file'],
                'logLine' => $error['line'],
                'runtime' => round(self::getRelativeTime(), 4),);
            self::$logs[] = $LOG;

            if ($thisType == 'ERROR')
            {
               self::haltExecution($LOG);
            }
        }
    }

    /**
     * System that redirects the errors to the appropriate logging method.
     *
     * @param int $type Error-type, Pre defined PHP Constant
     * @param string error. The error itself
     * @param string File. The absolute path of the file
     * @param int Line. The line on which the error occured.
     * @param array context. Some of the error's relevant variables
     */
    public static function errorHandler(int $type = E_USER_NOTICE, $error = 'Undefined Error', $errFile = null, $errLine = null)
    {
        // Check type
        $thisType = self::getType($type);
        $LOG = array('type' => (!is_null($thisType) ? $thisType : 'ERROR'),
            'message' => (!is_null($error) ? $error : ''),
            'logFile' => (!is_null($errFile) ? $errFile : ''),
            'logLine' => (!is_null($errLine) ? $errLine : ''),
            'runtime' => round(self::getRelativeTime(), 4),);
        self::$logs[] = $LOG;
    }

    /**
     * Exception handler
     * Will be triggered when an uncaught exception occurs. This function shows the error-message, and shuts down the script.
     * Please note that most of the user-defined exceptions will be caught in the router, and handled with the error-controller.
     *
     * @param Throwable $exception The occurred exception.
     * @param bool $haltExecution. Defaults to true
     */
    public static function exceptionHandler(Throwable $exception, bool $haltExecution = true)
    {
        $LOG = [
            'type' => $exception instanceof Exception ? "EXCEPTION" : "ERROR",
            'message' => $exception->getMessage(),
            'logFile' => $exception->getFile(),
            'logLine' => $exception->getLine(),
            'context' => $exception->getTraceAsString(),
            'runtime' => round(self::getRelativeTime(), 4),];
        self::$logs[] = $LOG;

        // And return a 500 because this error was fatal
        if ($haltExecution)
            self::haltExecution($LOG);
    }

    /**
     * Set the template that FuzeWorks should use to parse debug logs
     * 
     * @codeCoverageIgnore
     * 
     * @var string Name of the template file
     */
    public static function setLoggerTemplate($templateName)
    {
        self::$logger_template = $templateName;
    }

    /**
     * Output the entire log to the screen. Used for debugging problems with your code.
     * @codeCoverageIgnore
     * @throws EventException
     */
    public static function logToScreen()
    {
        // Send a screenLogEvent, allows for new screen log designs
        $event = Events::fireEvent('screenLogEvent');
        if ($event->isCancelled()) {
            return;
        }

        $logs = self::$logs;
        require(dirname(__DIR__) . DS . 'Layout' . DS . 'layout.' . self::$logger_template . '.php');
    }

    /**
     * Output the entire log to a file. Used for debugging problems with your code.
     * @codeCoverageIgnore
     */
    public static function logLastRequest()
    {
        ob_start(function () {});
        $logs = self::$logs;
        require(dirname(__DIR__) . DS . 'Layout' . DS . 'layout.logger_file.php');
        $contents = ob_get_clean();
        $file = Core::$logDir . DS . 'fwlog_request.log';
        if (is_writable(dirname($file)))
            file_put_contents($file, $contents);
    }

    /**
     * Output all errors to a file. Used for tracking all errors in FuzeWorks and associated code
     * @codeCoverageIgnore
     */
    public static function logErrorsToFile()
    {
        ob_start(function() {});
        $logs = [];
        foreach (self::$logs as $log)
        {
            if ($log['type'] === 'ERROR' || $log['type'] === 'EXCEPTION')
                $logs[] = $log;
        }
        require(dirname(__DIR__) . DS . 'Layout' . DS . 'layout.logger_file.php');
        $contents = ob_get_clean();
        $file = Core::$logDir . DS . 'fwlog_errors.log';
        if (is_writable(dirname($file)))
            file_put_contents($file, $contents, FILE_APPEND);
    }

    /* =========================================LOGGING METHODS============================================================== */

    /**
     * Set a benchmark mark point.
     * 
     * Multiple calls to this function can be made so that several
     * execution points can be timed.
     * 
     * @param string $name   Marker name
     * @return  void
     */
    public static function mark(string $name)
    {
        $LOG = array('type' => 'BMARK',
            'message' => (!is_null($name) ? $name : ''),
            'logFile' => '',
            'logLine' => '',
            'context' => '',
            'runtime' => round(self::getRelativeTime(), 4),);

        self::$logs[] = $LOG;
    }

    /**
     * Create an information log entry.
     *
     * @param string $msg  The information to be logged
     * @param string|null $mod  The name of the module
     * @param string|null $file The file where the log occurred
     * @param int|null $line The line where the log occurred
     */
    public static function log(string $msg, string $mod = null, string $file = null, int $line = null)
    {
        self::logInfo($msg, $mod, $file, $line);
    }

    /**
     * Create an information log entry.
     *
     * @param string $msg  The information to be logged
     * @param string|null $mod  The name of the module
     * @param string|null $file The file where the log occurred
     * @param int|null $line The line where the log occurred
     */
    public static function logInfo(string $msg, string $mod = null, string $file = null, int $line = null)
    {
        $LOG = array('type' => 'INFO',
            'message' => ($msg),
            'logFile' => (!is_null($file) ? $file : ''),
            'logLine' => (!is_null($line) ? $line : ''),
            'context' => (!is_null($mod) ? $mod : ''),
            'runtime' => round(self::getRelativeTime(), 4),);

        self::$logs[] = $LOG;
    }

    /**
     * Create an information log entry.
     *
     * @param string $msg  The information to be logged
     * @param string|null $mod  The name of the module
     * @param string|null $file The file where the log occurred
     * @param int|null $line The line where the log occurred
     */
    public static function logDebug(string $msg, string $mod = null, string $file = null, int $line = null)
    {
        $LOG = array('type' => 'DEBUG',
            'message' => ($msg),
            'logFile' => (!is_null($file) ? $file : ''),
            'logLine' => (!is_null($line) ? $line : ''),
            'context' => (!is_null($mod) ? $mod : ''),
            'runtime' => round(self::getRelativeTime(), 4),);

        self::$logs[] = $LOG;
    }

    /**
     * Create a error log entry.
     *
     * @param string $msg  The information to be logged
     * @param string|null $mod  The name of the module
     * @param string|null $file The file where the log occurred
     * @param int|null $line The line where the log occurred
     */
    public static function logError(string $msg, string $mod = null, string $file = null, int $line = null)
    {
        $LOG = array('type' => 'ERROR',
            'message' => ($msg),
            'logFile' => (!is_null($file) ? $file : ''),
            'logLine' => (!is_null($line) ? $line : ''),
            'context' => (!is_null($mod) ? $mod : ''),
            'runtime' => round(self::getRelativeTime(), 4),);

        self::$logs[] = $LOG;
    }

    /**
     * Create a warning log entry.
     *
     * @param string $msg  The information to be logged
     * @param string|null $mod  The name of the module
     * @param string|null $file The file where the log occurred
     * @param int|null $line The line where the log occurred
     */
    public static function logWarning(string $msg, string $mod = null, string $file = null, int $line = null)
    {
        $LOG = array('type' => 'WARNING',
            'message' => ($msg),
            'logFile' => (!is_null($file) ? $file : ''),
            'logLine' => (!is_null($line) ? $line : ''),
            'context' => (!is_null($mod) ? $mod : ''),
            'runtime' => round(self::getRelativeTime(), 4),);

        self::$logs[] = $LOG;
    }

    /**
     * Create a new Level log entry. Used to categorise logs.
     *
     * @param string $msg  The name of the new level
     * @param string|null $mod  The name of the module
     * @param string|null $file The file where the log occurred
     * @param int|null $line The line where the log occurred
     */
    public static function newLevel(string $msg, string $mod = null, string $file = null, int $line = null)
    {
        $LOG = array('type' => 'LEVEL_START',
            'message' => ($msg),
            'logFile' => (!is_null($file) ? $file : ''),
            'logLine' => (!is_null($line) ? $line : ''),
            'context' => (!is_null($mod) ? $mod : ''),
            'runtime' => round(self::getRelativeTime(), 4),);

        self::$logs[] = $LOG;
    }

    /**
     * Create a stop Level log entry. Used to close log categories.
     *
     * @param string|null $msg  The name of the new level
     * @param string|null $mod  The name of the module
     * @param string|null $file The file where the log occurred
     * @param int|null $line The line where the log occurred
     */
    public static function stopLevel(string $msg = null, string $mod = null, string $file = null, int $line = null)
    {
        $LOG = array('type' => 'LEVEL_STOP',
            'message' => (!is_null($msg) ? $msg : ''),
            'logFile' => (!is_null($file) ? $file : ''),
            'logLine' => (!is_null($line) ? $line : ''),
            'context' => (!is_null($mod) ? $mod : ''),
            'runtime' => round(self::getRelativeTime(), 4),);

        self::$logs[] = $LOG;
    }

    /* =========================================OTHER METHODS============================================================== */

    /**
     * Returns a string representation of an error
     * Turns a PHP error-constant (or integer) into a string representation.
     *
     * @param int $type PHP-constant errorType (e.g. E_NOTICE).
     *
     * @return string String representation
     */
    public static function getType(int $type): string
    {
        switch ($type) {
            case E_PARSE:
            case E_CORE_ERROR:
            case E_COMPILE_ERROR:
            case E_USER_ERROR:
            case E_STRICT:
            case E_RECOVERABLE_ERROR:
            case E_ERROR:
                return 'ERROR';
            case E_NOTICE:
            case E_CORE_WARNING:
            case E_COMPILE_WARNING:
            case E_USER_WARNING:
            case E_USER_NOTICE:
            case E_USER_DEPRECATED:
            case E_DEPRECATED:
            case E_WARNING:
                return 'WARNING';
        }

        return 'Unknown error: ' . $type;
    }

    /**
     * Halts the Execution of FuzeWorks
     *
     * Will die a message if not intercepted by haltExecutionEvent.
     * @param array $log
     * @codeCoverageIgnore
     */
    public static function haltExecution(array $log)
    {
        self::logError("Halting execution...");
        try {
            $event = Events::fireEvent("haltExecutionEvent", $log);
        } catch (EventException $e) {
            self::logError("Can't fire haltExecutionEvent: '".$e->getMessage()."'");
            die(PHP_EOL . "FuzeWorks execution halted. See error log for more information");
        }
        if ($event->isCancelled() == true)
            return;

        die(PHP_EOL . "FuzeWorks execution halted. See error log for more information");
    }

    /**
     * Get the relative time since the framework started.
     *
     * Used for debugging timings in FuzeWorks
     *
     * @return float Time passed since FuzeWorks init
     */
    private static function getRelativeTime(): float
    {
        $startTime = STARTTIME;
        return microtime(true) - $startTime;
    }
}