hooks-mixin

methods = [
  'count'
  'create'
  'createChangeStream'
  'deleteAll'
  'deleteById'
  'destroyAll'
  'destroyById'
  'exists'
  'find'
  'findById'
  'findByIds'
  'findOne'
  'findOrCreate'
  'remove'
  'removeById'
  'replaceById'
  'replaceOrCreate'
  'update'
  'updateAll'
  'updateAttributes'
  'updateOrCreate'
  'upsert'
]

prefixes =
  belongsTo: [ '__get__' ]

  hasMany: [
    '__count__'
    '__create__'
    '__delete__'
    '__destroyById__'
    '__findById__'
    '__get__'
    '__updateById__'
  ]

  referencesMany: [
    '__exists__'
    '__link__'
    '__unlink__'
  ].concat @hasMany

  hasAndBelongsToMany: @referencesMany
  hasManyThrough: @referencesMany

  scopes: [
    '__get__'
    '__create__'
    '__delete__'
    '__update__'
    '__count__'
  ]

  embedsOne: [
    '__create__'
    '__get__'
    '__update__'
    '__destroy__'
  ]

  hasOne: @embedsOne

  embedsMany: [
    '__create__'
    '__get__'
    '__delete__'
    '__findById__'
    '__updateById__'
    '__destroyById__'
    '__count__'
  ]

fns =
  around: (base, wrapped) ->
    (args...) ->
      wrapped.apply this, [ base.bind(this) ].concat args
  before: (base, before) ->
    @around base, (fn, args...) ->
      before.apply this, args
      fn.apply this, args
  after: (base, after) ->
    @around base, (fn, args...) ->
      res = fn.apply this, args
      after.apply this, args
      res

hooks = (obj) ->
  ret = {}
  [ 'before', 'after', 'around' ].forEach (type) ->
    ret[type] = (method, fn) ->
      if typeof obj[method] is 'function'
        obj[method] = fns[type](obj[method], fn)
      else
        obj[method] = fn
      this
  ret

module.exports = (Model, options) ->

  isMethod =
    scope: (prop) ->
      /^__(get|create|delete|update|count)__\w*/.test prop
    remote: (prop) ->
      methods.indexOf(prop) > -1
    relation: (model) ->
      if Model.relations[model].through
        'hasManyThrough'
      else
        Model.relations[model].type

  if Model.modelName is 'User' or Model.base.modelName is 'User'
    methods = methods.concat [
      'login'
      'logout'
      'confirm'
      'resetPassword'
    ]

  if Model.dataSource.settings.connector is 'loopback-component-storage'
    methods = methods.concat [
      'download'
      'getFile'
      'getFiles'
      'removeFile'
      'getContainers'
      'createContainer'
      'destroyContainer'
      'getContainer'
      'upload'
    ]

  wrap = (fnName) ->
    hooks Model
      .before fnName, (item) ->
        Model.notifyObserversOf 'before:' + fnName, item
      .after fnName, (item) ->
        Model.notifyObserversOf 'after:' + fnName, item

  Model.on 'attached', ->
    Object.keys(Model).forEach (property) ->
      if isMethod.remote property
        wrap property

      if isMethod.scope property
        wrap property

      return

    Object.keys(Model.relations).forEach (targetModel) ->
      type = isMethod.relation targetModel

      prefixes[type]?.forEach (prefix) ->
        wrap prefix + targetModel

      return
    return

  return