class AttributeField
  
  include Mongoid::Document
  include Mongoid::Timestamps
  include ::AttributeFieldsHelper

  field :key
  field :markup ,:default=>"text_field"
  field :option_list ,:type => Hash,:default => {}
  field :markup_options,:type => Hash
  # field :locale, :type => Boolean, :default => true
  # field :list_options, :type => Array
  field :built_in, :type => Boolean, :default => false
  field :disabled, :type => Boolean, :default => false
  field :to_delete,:type=> Boolean,:default => false
  field :typeA,:type=> Hash,:default=>{}
  field :typeB,:type=> Hash,:default=>{}
  field :typeC,:type=> Hash,:default=>{:claendar=>"west_claendar"}
  field :typeD,:type=> Hash,:default=>{}
  field :typeE,:type=> Hash,:default=>{}


  #field :title, localize: true

  field :title, localize: true
  

  belongs_to :attribute
  # belongs_to :role
  has_many :attribute_values,:autosave => true, :dependent => :destroy
  before_save :check_option_list
  # validates_uniqueness_of :key
  def add_more
     (get_data["add_more"] == "true" ? true : false) rescue false
  end

  def locale
    default = true
    if get_data["locale"].nil? 
      return default
    else
      (get_data["locale"] == "true"  ? true : false) rescue default
    end
  end

  def self_defined_markup_options?
    (self.attribute.role.method(self[:key].pluralize.to_sym)  && self.attribute.role.method(self[:key].pluralize+"_for_"+markup)) rescue false
  end

  def markup_value=(var)
    if !self_defined_markup_options?
      self[:markup_value] = (eval(var)  rescue {})
    end
  end

  def option_list
    if self_defined_markup_options?
      #Class need to have corresponding field and value agent 
     # Ex: For "status" the class must have field called "statuses" for the relation and "statuses_for_select" for the select function 
     method = self.attribute.role.method(self[:key].pluralize+"_for_"+markup)
      return  (method.call rescue {})
    elsif self[:option_list].nil?  || (self[:option_list].empty?)
      return {}
    else
      return self[:option_list]
    end
  end



  def markup_options=(var)
    self[:markup_options] = (eval(var)  rescue {})
  end

  def markup_options
    if self[:markup_options].nil?
      return {}
    else
      Hash[self[:markup_options].map{|key,val|[key.to_sym,val]}]  rescue {}
    end

  end

  def role
    self.attribute.role
  end

  def panel
    panel  = LIST[:markups][self[:markup]]["panel"]
  end

  def get_data
    self[panel]
  end


  # def title_translations
  #   if locale
  #     return self.locale_title_translations
  #   else
  #     return  self[:neutral_title] #Hash[VALID_LOCALES.map{|d| [d,neutral_title]}]
  #   end
  # end

  # def title_translations=(var)
  #    if locale
  #     self.locale_title_translations = var
  #   end
  # end

  # def title
  #   if locale
  #     return self.locale_title
  #   else
  #     return self.neutral_title
  #   end
  # end

  # def check_title
  #    if locale 
  #     self.locale_title_translations = self[:temp_title]
  #   else
  #     self.neutral_title = self[:temp_title]
  #   end    
  #   self.unset("temp_title")
  # end

  # def title=(var)
  #    self["temp_title"] = var
  # end

  # # Convert the string list_options into an array
  # def select_list_options=(var)
  #   self.list_options = var.gsub(' ', '').split(',')
  # end
  
  # # Convert the array list_options into a string
  # def select_list_options
  #   self.list_options.to_a.join(', ')
  # end
  
  def is_built_in?
    self.built_in
  end
  
  def is_disabled?
    self.disabled
  end

protected
  def check_option_list
    self[:option_list] = self[panel]["option_list"]
  end

end
