_isFunction = require( "lodash/isFunction" )
  _isString = require( "lodash/isString" )
  _template = require( "lodash/template" )
  
  extend = require('extend')
  colors = require('colors')
  
  module.exports = ( config )->
    
    if not config?
  
  

  
      config = require( "./config" )
    
  
  

  
    return class Basic extends require('events').EventEmitter
  
  

  
      extend: extend
  
  
  

  
      defaults: =>
        return {}
  
  
  

  
      constructor: ( options = {} )->
        @on "_log", @_log
  
        @getter "classname", ->
          return @constructor.name.toLowerCase()
  
        @config = extend( true, {}, @defaults(), config.get( @_config_name or @classname, true ), options )
  
  
  

  
        @_initErrors()
  
        @initialize( options )
  
        @debug "loaded"
        return
  
  
  

  
      mixin: (mixins...)=>
        if mixins?.length
          for mxn in mixins
            for _fnname, fn of mxn.prototype when _fnname isnt "constructor"
              @[ _fnname ] = fn
        return
  
  
  

  
      initialize: ( options )->
        return
  
  
  

  
      define: ( prop, fnGet, fnSet, writable = true, enumerable = true )=>
        _oGetSet =
          enumerable: enumerable
          writable: writable
  
        if _isFunction( fnGet )
  
  

  
          _oGetSet =
            get: fnGet
          _oGetSet.set = fnSet if fnSet? and _isFunction( fnSet )
        else
          _oGetSet.value = fnGet
        
  
  

  
        Object.defineProperty @, prop, _oGetSet
        return
  
  
  

  
      getter: ( prop, _get, enumerable = true )=>
        _obj =
          enumerable: enumerable
  
  

  
  
        if _isFunction( _get )
          _obj.get = _get
        else
          _obj.value = _get
        Object.defineProperty @, prop, _obj
        return
  
  
  

  
      setter: ( prop, fnGet, enumerable = true )=>
        Object.defineProperty @, prop, set: fnGet, enumerable: enumerable, writable: true
        return
  
  
  

  
      _waitUntil: ( method, key = "ready", context = @ )=>
        return =>
          args = arguments
          if context[ key ]
            method.apply( @, args )
          else
            context.once key, =>
              method.apply( @, args )
              return
          return
  
  
  

  
      _handleError: ( cb, err, data = {}, errExnd )=>
  
  

  
        if _isString( err )
          _err = new Error()
          _err.name = err
          _err.message = @_ERRORS?[ err ][ 1 ]?( data ) or "unkown"
          _err.statusCode = @_ERRORS?[ err ][ 0 ] or 500
          _err.customError = true
        else
          _err = err
  
        if errExnd?
          _err.data = errExnd
  
        for _k, _v of data
          _err[ _k ] = _v
  
        if _isFunction( cb )
  
  

  
          cb( _err )
        else if _isString( cb )
          @log "error", cb, _err
        else if cb is true
          return _err
        else
          throw _err
        return _err
  
  
  

  
      log: ( severity, code, content... )=>
        args = [ "_log", severity, code ]
        @emit.apply( @, args.concat( content ) )
        return
  
  
  

  
      _log: ( severity, code, content... )=>
  
  

  
        
        if @_checkLogging( severity )
          _tmpl = "%s %s - #{ new Date().toString()[4..23]} - %s "
  
          args = [ _tmpl, severity.toUpperCase(), @_logname(), code ]
  
          if content.length
            args[ 0 ] += "\n"
            for _c in content
              args.push _c
  
          switch severity
            when "fatal"
              args[ 0 ] = args[ 0 ].red.bold.inverse
              console.error.apply( console, args )
              for arg in args when arg instanceof Error
                console.log arg.stack
                return
              console.trace()
            when "error"
              args[ 0 ] = args[ 0 ].red.bold
              console.error.apply( console, args )
            when "warning"
              args[ 0 ] = args[ 0 ].yellow.bold
              console.warn.apply( console, args )
            when "info"
              args[ 0 ] = args[ 0 ].blue.bold
              console.info.apply( console, args )
            when "debug"
              args[ 0 ] = args[ 0 ].green.bold
              console.log.apply( console, args )
            else
      
        return
  
  
  

  
      _logname: =>
        return @constructor.name
  
  
  

  
      fatal: ( code, content... )=>
        args = [ "_log", "fatal", code ]
        @emit.apply( @, args.concat( content ) )
        return
  
  
  

  
      error: ( code, content... )=>
        args = [ "_log", "error", code ]
        @emit.apply( @, args.concat( content ) )
        return
  
  
  

  
      warning: ( code, content... )=>
        args = ["_log",  "warning", code ]
        @emit.apply( @, args.concat( content ) )
        return
  
  
  

  
      info: ( code, content... )=>
        args = [ "_log", "info", code ]
        @emit.apply( @, args.concat( content ) )
        return
  
  
  

  
      debug: ( code, content... )=>
        args = [ "_log", "debug", code ]
        @emit.apply( @, args.concat( content ) )
        return
  
  
  

  
      _checkLogging: ( severity )=>
        if not @_logging_iseverity?
          @_logging_iseverity = @config.logging.severitys.indexOf( @config.logging.severity )
  
        iServ = @config.logging.severitys.indexOf( severity )
        if @config.logging.severity? and iServ <= @_logging_iseverity
          true
        else
          false
  
  
  

  
      _initErrors: =>
        @_ERRORS = @ERRORS()
        for key, msg of @_ERRORS
          if not _isFunction( msg[ 1 ] )
            @_ERRORS[ key ][ 1 ] = _template( msg[ 1 ] )
      
        return
  
  
  

  
      ERRORS: =>
        "ENOTIMPLEMENTED": [ 501, "This function is planed but currently not implemented" ]