<?php
  /**

   * PHP OpenCloud library.
   * 
   * @copyright 2014 Rackspace Hosting, Inc. See LICENSE for information.
   * @license   https://www.apache.org/licenses/LICENSE-2.0

   * @author    Jamie Hannaford <jamie.hannaford@rackspace.com>
   */
  
  namespace OpenCloud\Common\Log;
  
  use OpenCloud\Common\Exceptions\LoggingException;
  
  /**
   * Basic logger for OpenCloud which extends FIG's PSR-3 standard logger.
   * 
   * @link https://github.com/php-fig/log
   */
  class Logger extends AbstractLogger
  {   
      /**
       * Is this debug class enabled or not?
       * 
       * @var bool
       */

      private $enabled;

      
      /**
       * These are the levels which will always be outputted - regardless of 
       * user-imposed settings.
       * 
       * @var array 
       */
      private $urgentLevels = array(
          LogLevel::EMERGENCY,
          LogLevel::ALERT,
          LogLevel::CRITICAL
      );
      
      /**
       * Logging options.
       * 
       * @var array
       */
      private $options = array(
          'outputToFile' => false,
          'logFile'      => null,
          'dateFormat'   => 'd/m/y H:I',
          'delimeter'    => ' - '
      );

  
      public function __construct($enabled = false)
      {
          $this->enabled = $enabled;
      }
  
      public static function newInstance()
      {
          return new static();
      }

      /**
       * Determines whether a log level needs to be outputted.
       * 
       * @param  string $logLevel
       * @return bool
       */
      private function outputIsUrgent($logLevel)
      {
          return in_array($logLevel, $this->urgentLevels);
      }
      
      /**
       * Interpolates context values into the message placeholders.
       * 
       * @param string $message
       * @param array $context
       * @return type
       */
      private function interpolate($message, array $context = array())
      {
          // build a replacement array with braces around the context keys
          $replace = array();
          foreach ($context as $key => $val) {
              $replace['{' . $key . '}'] = $val;
          }
  
          // interpolate replacement values into the message and return
          return strtr($message, $replace);
      }
      
      /**
       * Enable or disable the debug class.
       * 
       * @param  bool $enabled
       * @return self
       */
      public function setEnabled($enabled)
      {
          $this->enabled = $enabled;
          return $this;
      }
      
      /**
       * Is the debug class enabled?
       * 
       * @return bool
       */

      public function isEnabled()

      {

          return $this->enabled === true;

      }
      
      /**
       * Set an array of options.
       * 
       * @param array $options
       */
      public function setOptions(array $options = array())
      {
          foreach ($options as $key => $value) {
              $this->setOption($key, $value);
          }

          return $this;

      }
      
      /**
       * Get all options.
       * 
       * @return array
       */
      public function getOptions()
      {
          return $this->options;
      }
      
      /**
       * Set an individual option.
       * 
       * @param string $key
       * @param string $value
       */
      public function setOption($key, $value)
      {
          if ($this->optionExists($key)) {
              $this->options[$key] = $value;

              return $this;

          }
      }
      
      /**
       * Get an individual option.
       * 
       * @param  string $key
       * @return string|null
       */
      public function getOption($key)
      {
          if ($this->optionExists($key)) {
              return $this->options[$key];
          }
      }
      
      /**
       * Check whether an individual option exists.
       * 
       * @param  string $key
       * @return bool
       */
      private function optionExists($key)
      {
          return array_key_exists($key, $this->getOptions());
      }
      
      /**
       * Outputs a log message if necessary.
       * 
       * @param string $logLevel
       * @param string $message
       * @param string $context
       */
      public function log($level, $message, array $context = array())
      {

          if ($this->outputIsUrgent($level) || $this->isEnabled()) {

              $this->dispatch($message, $context);
          }
      }
      
      /**
       * Used to format the line outputted in the log file.
       * 
       * @param  string $string
       * @return string
       */
      private function formatFileLine($string)
      {
          $format = $this->getOption('dateFormat') . $this->getOption('delimeter');
          return date($format) . $string;
      }
      
      /**
       * Dispatch a log output message.
       * 
       * @param string $message
       * @param array $context
       * @throws LoggingException
       */
      private function dispatch($message, $context)
      {
          $output = $this->interpolate($message, $context) . PHP_EOL;
          
          if ($this->getOption('outputToFile') === true) {
              $file = $this->getOption('logFile');
  
              if (!is_writable($file)) {
                  throw new LoggingException(
                      'The log file either does not exist or is not writeable'
                  );
              }
              
              // Output to file

              file_put_contents($file, $this->formatFileLine($output), FILE_APPEND);

          } else {

              echo $output;
          }
      }

  
      public function deprecated($method, $new)
      {
          $string = sprintf('The %s method is deprecated, please use %s instead', $method, $new);
          return $this->warning($string);
      }

      
  }