# -*- coding: UTF-8 -*-

require 'ansi/code'
require 'logging'

module MJ; module Logging;

    #
    # Basic Layout for the logging framework.
    #
    # Will prefix message according to the following list:
    #
    #   WARNING => 'warning: '
    #   ERROR   => 'error: '
    #   REST    => ''
    class BasicLayout < ::Logging::Layout

        include ANSI::Code

        def format( event )
          obj = format_obj(event.data)

          return case event.level

          when ::Logging::level_num(:ERROR)
              red   { sprintf("error: %s\n", obj) }

          when ::Logging::level_num((:WARN))
              yellow { sprintf("warning: %s\n", obj) }

          else
              if obj.start_with?( '###')
                  blue { obj + "\n" }
              else
                  obj + "\n"
              end
          end
        end

    end # class BasicLayout





    # :TODO: Map the Logging Levels to Logger Levels instead of hardcoding them here.
    class LoggerAdapter

        def initialize( prefix )
            @prefix = prefix.upcase
        end

        def debug( string )
            logger.debug( "<#{@prefix}> #{string}" )
        end

        def debug?
            return logger.level > ::Logging.level_num(:debug)
        end

        def info( string )
            logger.info( "<#{@prefix}> info #{string}" )
        end

        def info?
            return logger.level > ::Logging.level_num(:info)
        end

        def warn( string )
            logger.arn( "<#{@prefix}> #{string}" )
        end

        def warn?
            return logger.level > ::Logging.level_num(:warn)
        end

        def error( string )
            logger.error( "<#{@prefix}> #{string}" )
        end

        def error?
            return logger.level > ::Logging.level_num(:error)
        end

        def fatal( string )
            logger.error( "<#{@prefix}> #{string}" )
        end

        def fatal?
            return logger.level > ::Logging.level_num(:error)
        end

        def unknown( string )
            logger.error( "<#{@prefix}> UNKNOWN: #{string}" )
        end
    end



    class Progressbar < ::Logging::Appender

        def initialize( title, total = 100, &block )
            super( 'Progressbar', :level => :DEBUG )
            @pbar = nil
            @oldlogger = nil
            if ::Logging.appenders['stdout'].level >= ::Logging::level_num(:INFO)
                # We only do the progressbar thing if there is no verbose output active.
                begin
                    # Remove the old stdout logger.
                    @oldlogger = ::Logging.appenders[ 'stdout' ]
                    ::Logging.logger[ 'root' ].remove_appenders( 'stdout' )
                    ::Logging.logger[ 'root' ].add_appenders( self )
                    # Add the progressbar logger
                    @pbar = ANSI::Progressbar.new( title, total )
                    yield
                ensure
                    @pbar.finish unless @pbar.nil?
                    # Reset the logger
                    ::Logging.logger[ 'root' ].remove_appenders( 'Progressbar' )
                    ::Logging.logger[ 'root' ].add_appenders( @oldlogger )
                end
            else
                # If there is verbose output just print the text
                logger.info( title )
                yield
            end
        end
    end # class Progressbar
end; end