view.co

let parent = Backbone.View

  fsr = ->
    {when, defer, reject} = $J.Deferred

    (when @fetchTemplate!, @serializeData!)then (tpl, data)~>
      return reject that if $J.assert tpl, 'falsy template'
      @renderHtml tpl, data


  $J.View = parent.extend {

    initialize: ->
      @data = {}
      @_sync = {}
      @_subviews = {}

    fetchTemplate: ->
      $J.Dom.html $ "##{@template}"
    renderHtml: (tpl, data)->
      _.template tpl, data
    serializeData: -> _.extend {}, @data, @_sync
    renderElement: ->
      @trigger '$J:render:before'
      @trigger '$J:render:full:before'

      fsr.call @
      .then (html)~>
        @removeSubviews!
        $J.Dom.html @$el, html
      .then ~>
        $J.Deferred.when @mapSubviews (view, selector)~>
          $el = @$ selector

          return if $J.assert $el.length > 0, 'subview selector missed'
          $J.advice $el.length is 1, 'subview selector more than 1 match'
          $J.Dom.appendInnerView $el, view if $el.has(view.el)length is 0

          if view instanceof $J.View
            view.renderElement!
          else
            view.render!
      .then ~>
        @trigger '$J:render:done'
        @trigger '$J:render:full:done'
        true
      , !~>
        @trigger '$J:render:fail', @@
        @trigger '$J:render:full:fail', @@

    renderFields: (syncName, fields)->
      return @renderElement! if !fields

      @trigger '$J:render:before'
      @trigger '$J:render:part:before', [syncName, fields]

      view = @
      fields = @parseFields fields

      fsr.call @
      .then (html)~>
        # $html = $J.Dom.html ($ document.createElement \div), html
        div = document.createElement \div
            &innerHTML = html
        $html = $ div
        _.each (@extractFields $html, syncName, fields), (src)~>
          @replaceWithSrc src

      .then ~>
        @trigger '$J:render:done'
        @trigger '$J:render:part:done', [syncName, fields]
        true
      , !~>
        @trigger '$J:render:fail', @@
        @trigger '$J:render:part:fail', @@

    parseFields: (fields)->
      fields = switch
      case _.isString fields
        fields.split ' '
      case _.isArray fields
        fields
      default
        throw new Error 'malformed fields'

      _.compact fields

    extractFields: ($el, syncName, fields)->
      $r = $!
      _.each fields, (field)~>
        $parts = $el.find "[j-field]" .filter ->
            _.any (($ @).attr 'j-field' .split ' '), -> it is "#{syncName}.#{field}" || it is "#{syncName}.*" || it is "*"
        $r := $r.add $parts

      $r.toArray!

    replaceWithSrc: (src)->
      $src = $ src
      id = ($src.attr \j-id) || ($src.attr \j-field)
      $dst = @$el.find "[j-id=\"#{id}\"],:not([j-id])[j-field=\"#{id}\"]"

      return if $dst.length == 0 || $src.length == 0
      $J.Dom.replaceWith $dst, $src

    sync: (syncName, synchronizer, events)->
      @unsync syncName
      @_sync[syncName] = synchronizer

      @listenTo synchronizer, '$J:sync', !(fields)~>
        @renderFields syncName, fields

      if events
        @listenTo synchronizer, events, !~>
          @render!

      synchronizer.trigger '$J:sync:start', @

      @

    unsync: (syncName)->
      if @_sync[syncName]
        @stopListening that
        that.trigger '$J:sync:end', @
      delete @_sync[syncName]

      @

    setView: (selector, view)->
      $el = @$ selector
      $J.Dom.setInnerView $el, view if $el.length > 0 && $el.has(view.el)length is 0

      @_subviews[selector] = [view]
      view.on \all, @~_handleSubViewEvent

      @

    _handleSubViewEvent: !(name)->
      return if (name.substring 0, 3) is '$J:'
      @trigger.apply @, @@

    appendView: (selector, views)->
      views = [views] if !_.isArray views

      for view of views
        @_subviews@@[selector]push view
        view.on \all, @~_handleSubViewEvent

      @



    ##### override methods to manage subviews
    remove: $J.before parent::remove, !->
      @removeSubviews!
      @unsync key for key in @_sync

    delegateEvents: $J.after parent::delegateEvents, !->
      @mapSubviews !-> it.delegateEvents! if it.$el
    undelegateEvents: $J.before parent::undelegateEvents, !->
      @mapSubviews !-> it.undelegateEvents! if it.$el

    setElement: $J.after parent::setElement, ->
      $J.advice @$el.length is 1, '`view.$el` should contain exactly one element'

    render: ->
      @renderElement!
      @

    mapSubviews: (iterator, context)->
      _.flatten _.map @_subviews, (views, selector)->
        _.map views, (view)->
          iterator.call context, view, selector

    removeSubviews: ->
      _.each @_subviews, (views, selector)~>
        $J.Dom.removeInnerView @$ selector

  }