# form_name_with_sub_form
# item: editing item
# submit: string / 'submit'
class Locmare.FormBase extends Pettanr.View
  tagName: 'form'
  
  initialize: (options) ->
    @form_name = options.form_name #_with_sub_form
    @use_name = options.use_name || 'default'
    @item = options.item
    @element_form = options.element_form
    @submit = options.submit
    if /\./.test(@form_name)
      @sub_form_names = @form_name.split('.')
      @form_name = @sub_form_names.pop()
      @root_form_name = @sub_form_names.shift()
    else
      @sub_form_names = []
      #@form_name = @form_name
      @root_form_name = @form_name
    @manifest = LocalManifest.manifest().forms[@form_name].uses[@use_name]
    @fields = {}
    @on('change:field', @change)
  
  change: (field) ->
  
  fold_extend_settings: (params) ->
    @item.my_class().fold_extend_settings params[@item.item_name()]
  
  sub_form_name: () ->
    r = _.map @sub_form_names, (name) ->
      '[' + name + '_attributes' + ']'
    r.join()
  
  form_field_name: (field_name) ->
    @root_form_name + @sub_form_name() + '[' + field_name + ']'
  
  image_dir: () ->
    '/images/'
  
  quit: () ->
    null
  
class Locmare.Form extends Locmare.FormBase
  
  @factory: (options) ->
    custom_form = Pettanr.Views[Pettanr.camelize(options.item.model_name())].Form
    if custom_form
      new custom_form(options)
    else
      new Locmare.Form(options)
  
  initialize: (options) ->
    super(options)
    @submit = options.submit
    @child_forms = {}
    @item.boosts 'post'
    @init_fields()
  
  render: () ->
    this.$el.attr(@form_attr())
    this.$el.html('')
    @append_guidance()
    @error_explanation = null
    @div_fields = new Locmare.FormModule.Fields({
      parent: this, fields: @fields
    })
    #this.$el.append(@error_explanation.render().el) if not @error_explanation
    this.$el.append(@div_fields.render().el)
    @add_elements() if @element_form
    if @submit
      c = @submit_class()
      @div_submit = new c({form: this})
      this.$el.append(@div_submit.render().el)
      @delegateEvents({'submit': @method_type()})
    this
  
  form_attr: () ->
    {
      method: @method_type(),
      action: @action_url()
    }
  
  refresh: () ->
    _.each @fields, (field) =>
      field.refresh()
    _.each @child_forms, (child_form, name) =>
      child_form.refresh()
  
  method_type: () ->
    if @item.isNew()
      'post'
    else
      'put'
  
  action_url: () ->
    return null if !@submit    # element has not create actions
    if @item.isNew()
      @item.create_url()
    else
      @item.edit_url()
  
  add_elements: () ->
    _.each @item.my_class().child_models(), (element_model) =>
      items = @item.element_items(element_model)
      if @item.my_class().my_manifest().associations.is_has_one(element_model)
        @add_element(items)
      else
        _.each items, (item) =>
          @add_element(item)
  
  add_element: (element) ->
    form = Locmare.Form.factory({
      form_name: element.item_name(), 
      use_name: @use_name,
      item: element, 
      element_form: @element_form, 
      submit: null, 
    })
    this.$el.append(form.render().el)
    mm = @item.my_class().my_manifest()
    em = element.my_class().my_manifest()
    child_element_name = mm.associations.child_element_name(element.my_class())
    if mm.associations.is_has_one(em)
      @child_forms[child_element_name] = form
    else
      @child_forms[child_element_name] ||= []
      @child_forms[child_element_name].push(form)
    form
  
  remove_elements: () ->
    _.each @child_forms, (child_form, name) =>
      child_form.item.set({_destroy: true}, {silent: true})
      child_form.remove_elements()
  
  init_fields: () ->
    _.each @manifest.field_names, (field_name) =>
      field_manifest = @manifest.fields[field_name]
      boost_name = @item.my_class().find_boost_name(field_name)
      extend_model = if boost_name 
        @item.boosters[boost_name].extend_model()
      else
        null
      if boost_name and extend_model # field is extend setting AND template has a extend model
        extend_form_name = @item.boosters[boost_name].item_name()
        extend_item = @item.boosters[boost_name].extend_item()
        @fields[field_name] = new Locmare.ExtendForm({
          parent: this, 
          form_name: extend_form_name, 
          use_name: @use_name,
          item: extend_item, 
          field_name: field_name
        })
      else
        @fields[field_name] = new Locmare.FormModule.Field({
          form: this, 
          field_name: field_name, 
          field_manifest: field_manifest
        })
  
  submits: () ->
    {
      default: Locmare.FormModule.SubmitModule.Default
    }
  
  submit_class: () ->
    @submits()[@submit]
  
  post: () ->
    _.each @fields, (field) =>
      field.fold() if field.is_extend()
      @item.set(field.field_name, field.val())
    @item.unset('id')  # isNew use flag that id attr set
    @trigger('http_post', @item.create_url(), this)
    return false
  
  put: () ->
    _.each @fields, (field) =>
      field.fold() if field.is_extend()
      @item.set(field.field_name, field.val())
    @trigger('http_post', @item.update_url(), this)
    return false
  
  save: () ->
    @listenTo(@item, 'save:success', @success)
    @listenTo(@item, 'save:fail', @fail)
    @item.save()
  
  success: (model, response) ->
    if !Pettanr.cache.restore(model.cache_key())
      # item is new
      model.url = model.default_url()
      Pettanr.cache.store(model)
    else
      @item.fix()
    @trigger('success', model, response)
  
  fail: (model, response) ->
    @trigger('fail', response)
  
  quit: () ->
    @item.release()
  
  save_data: (inspire = false) ->
    @item.my_class().child_models()
    attrs = {}
    _.each @fields, (field) =>
      attrs[field.field_name] = @item.get(field.field_name)
    delete attrs['id'] if @item.isNew()
    _.each @child_forms, (child_form, name) =>
      mm = @item.my_class().my_manifest()
      em = child_form.item.my_class().my_manifest()
      if mm.associations.is_has_one(em)
        d = child_form.save_data(inspire)
        if inspire
          delete d['id']
          delete d[@item.item_name() + '_id']
        attrs[name + '_attributes'] = d
      else
        attrs[name + '_attributes'] = []
        _.each child_form, (form) =>
          d = form.save_data(inspire)
          if inspire
            delete d['id']
            delete d[@item.item_name() + '_id']
          attrs[name + '_attributes'].push(d)
    attrs
  
  append_guidance: () ->
    
  
class Locmare.ExtendForm extends Locmare.FormBase
  tagName: 'div'
  className: 'fields'
  
  initialize: (options) ->
    @parent = options.parent
    @field_name = options.field_name
    super(options)
    @listenTo(@item, 'input', @input)
    @field = new Locmare.FormModule.Field({
      form: @parent, 
      field_name: @field_name, 
      field_manifest: @parent.manifest.fields[@field_name]
    })
    @label = @field.label
    @init_fields()
  
  render: () ->
    this.$el.html('')
    if !@is_hidden()
      this.$el.append(@label.render().el) if not @label.hidden()
      @div_fields = new Locmare.FormModule.Fields({
        fields: @fields
      })
      this.$el.append(@div_fields.render().el)
    this
  
  refresh: () ->
    @field.refresh()
  
  input: (field) ->
    a = {}
    a[@field_name] = @val()
    @parent.item.set(a, {silent: true})
    @parent.item.trigger('input:' + @field_name + ':' + field)
    @parent.item.trigger('input:' + @field_name)
    @parent.item.trigger('input')
  
  fold: () ->
    _.each @fields, (field) =>
      @item.set(field.field_name, field.val())
  
  val: () ->
    JSON.stringify(@item.attributes)
  
  is_hidden: () ->
    _.isEmpty(@manifest.field_names)
  
  init_fields: () ->
    _.each @manifest.field_names, (field_name) =>
      field_manifest = @manifest.fields[field_name]
      @fields[field_name] = new Locmare.FormModule.ExtendField({
        form: this, 
        field_name: field_name, 
        field_manifest: field_manifest
      })
  
  form_field_name: (extend_field_name) ->
    # parent is field
    @parent.form_field_name(@field_name)  + '[' + extend_field_name + ']'
  
  is_extend: () ->
    true
  
  has_row_break: () ->
    true
  
  row_break: () ->
    if @has_row_break()
      Pettanr.View.rb()
    else
      null
  
class Locmare.FormModule
class Locmare.FormModule.Fields extends Pettanr.View
  tagName: 'div'
  className: 'fields'
  
  initialize: (options) ->
    @parent = options.parent
    @fields = options.fields
  
  render: () ->
    this.$el.html('')
    _.each @fields, (field) =>
      this.$el.append(field.render().el)
      this.$el.append(field.row_break()) if field.has_row_break()
    this
  
class Locmare.FormModule.SubmitModule
class Locmare.FormModule.SubmitModule.Default extends Pettanr.View
  tagName: 'div'
  className: 'actions'
  
  initialize: (options) ->
    @form = options.form
  
  render: () ->
    caption = I18n.t(@submit_name())
    this.$el.html('<input type="submit" name="commit" class="submit" value="' + caption + '"></input>')
    this
  
  submit_name: () ->
    if @form.item.isNew()
      @form.item.table_name() + '.submit.new'
    else
      @form.item.table_name() + '.submit.edit'