require 'logger'
require 'rainbow'

module Onering
  class Logger
    def self.setup(options={})
      outputfn = options[:destination]
      @_verbosity = 1

      if options[:destination] == /STDOUT/i
        options[:destination] = STDOUT

      elsif options[:destination] == /STDERR/i or
            options[:destination].nil?
        options[:destination] = STDERR

      elsif File.writable?(options[:destination])
        options[:destination] = File.open(options[:destination], 'a')

      else
        options[:destination] = STDERR
      end

      @_logger = ::Logger.new(options[:destination])
      @_logger.formatter = (options[:formatter] || proc{|severity, datetime, source, msg|
        case severity.downcase.to_sym
        when :fatal then sevtag = '!!'
        when :error then sevtag = 'EE'
        when :warn then sevtag = 'WW'
        when :info then sevtag = 'II'
        when :debug then sevtag = 'DD'
        when :output then sevtag = ''
        else sevtag = '??'
        end

        if options[:sevtag] == false
          logline = [(source.nil? ? nil : "[#{source}]"), msg].compact.join(' ')
        else
          logline = ["#{sevtag} ", (source.nil? ? nil : "[#{source}]"), msg].compact.join(' ')
        end

        if options[:destination] === STDOUT or options[:destination] === STDERR
          case severity.downcase.to_sym
          when :fatal, :error
            logline = logline.foreground(:red)
          when :warn
            logline = logline.foreground(:yellow)
          when :info
            logline = logline.foreground(:green)
          when :debug, :debug2, :debug3
            logline = logline.foreground(:blue)
          end
        end

        options[:destination].puts(logline)
      })

      self.level = (options[:threshold] || :info)

      self.debug("onering-client v#{Onering::Client::VERSION} started")
      self.debug("Logger is initialized. Output is #{outputfn || 'stderr'}, threshold: #{options[:threshold]} or worse", "Onering::Logger")
    end


    def self.logger()
      return @_logger
    end

    def self.level=(severity)
      @_logger.sev_threshold = _get_level(severity)
      @_verbosity = (Integer(severity.to_s[-1]) rescue 1)

      @_logger.sev_threshold
    end


    def self.log(severity, message, source=nil, verbosity=1)
      if defined?(@_logger)
        if @_verbosity >= verbosity
          @_logger.add(_get_level(severity), message, source)
          return true
        end
      end

      return false
    end

    def self.fatal(message, source=nil, raise_error=false)
      self.log(:fatal, message, source)
      raise Onering::Client::FatalError.new(message) if raise_error === true
    end

    def self.fatal!(message, source=nil)
      self.fatal(message, source, true)
    end

    def self.error(message, source=nil)
      self.log(:error, message, source)
    end

    def self.warn(message, source=nil)
      self.log(:warn, message, source)
    end

    def self.info(message, source=nil)
      self.log(:info, message, source)
    end

    def self.debug(message, source=nil)
      self.log(:debug, message, source)
    end

    def self.debug2(message, source=nil)
      self.log(:debug, message, source, 2)
    end

    def self.debug3(message, source=nil)
      self.log(:debug, message, source, 3)
    end

    def self.output(message, source=nil)
      self.log(:output, message, source)
    end

    def self._get_level(severity)
      case severity.to_sym
      when :fatal
        return ::Logger::FATAL
      when :error
        return ::Logger::ERROR
      when :warn
        return ::Logger::WARN
      when :info
        return ::Logger::INFO
      else
        return ::Logger::DEBUG
      end
    end
  end
end