module Storefront
  class AttributeProxy
    attr_reader :name, :model, :required, :disabled, :top_level
    
    def initialize(options = {})
      @name     = options[:name]
      @model    = options[:model]
      @required = options[:required].nil? ? model.required?(name) : options[:required]
      @disabled = options[:disabled]
      @top_level = options[:top_level]
    end
    
    def config
      Storefront.configuration
    end
    
    def required?
      @required
    end
    
    def disabled?
      @disabled
    end
    
    def humanize
      model.humanized_attribute_name(name)
    end
    
    def errors?
      top_level ? false : model.errors_on?(name, {})
    end
    
    def value(default = nil)
      return default if default.present?
      return nil if top_level
      if model.object.respond_to?(name)
        model.object.send(name)
      else
        nil
      end
    end
    
    def access_key
      name.to_s[0, 1]
    end
    
    def param_for(*parts)
      parts = parts.flatten.compact
      parts[0].to_s + parts[1..-1].map {|i| "[#{i}]"}.join("")
    end
    
    def to_id(options = {})
      parts = []
      parts << model.keys unless top_level
      parts << options[:parent_index].to_s if options[:parent_index].present?
      parts << name
      parts << options[:index].to_s if options[:index].present?
      parts << (options[:type] || "input").to_s
      
      parts.join(config.separator).underscore.strip.gsub(/[_\s]+/, config.separator)
    end
    
    def to_param(options = {})
      parts = []
      parts << model.keys unless top_level
      parts << options[:parent_index].to_s if options[:parent_index].present?
      parts << name
      parts << options[:index].to_s if options[:index].present?
      
      param_for(parts)
    end
    
    def input_type(options = {})
      model.default_input_type(name, options)
    end
    
    def to_label
      humanize
    end
    
    def validations
      return {} if top_level
      
      unless @validations.present?
        return {} unless model.validators?
        
        attr_name = humanize
        
        kinds = []
        
        @validations = model.validators_on(name).inject({}) do |hash, validator|
          key = case validator.kind
          when :presence
            :blank
          when :uniqueness
            :taken
          when :inclusion
            :inclusion
          when :length
            [:min, :max]
          when :format
            :invalid
          when :numericality
            :numericality
          else
            next
          end
          
          kinds << validator.kind
        
          value = case validator.kind
          when :presence
            true
          when :uniqueness
            true
          when :inclusion
            Array(validator.options[:in]).compact.join(", ")
          when :length
            {:min => validator.options[:minimum], :max => validator.options[:maximum]}
          when :format
            validator.options[:with].is_a?(::Regexp) ? validator.options[:with].source : validator.options[:with].to_s
          when :numericality
            true
          end
          
          unless validator.kind == :length
            message                                           = model.validation_message(name, key, :attribute => attr_name)
            
            hash[:"data-validates-#{validator.kind}"]         = value.to_s
            hash[:"data-validates-#{validator.kind}-message"] = message
          else
            key.each do |length_key|
              next unless value[length_key].present?
              message                                         = model.validation_message(name, length_key == :min ? :too_short : :too_long, :attribute => attr_name, :count => value[length_key])
              
              hash[:"data-validates-#{length_key}"]           = value[length_key].to_s
              hash[:"data-validates-#{length_key}-message"]   = message
            end
          end
          
          hash
        end
        
        @validations[:"data-validate"] = kinds.uniq.join(",") if kinds.present? && @validations.present?
      end
      
      @validations
    end
  end
end