module Validatable
  class ValidationBase #:nodoc:
    def self.required_option(*args)
      option(*args)
      requires(*args)
    end
    
    def self.option(*args)
      attr_accessor(*args)
      understands(*args)
    end
    
    def self.default(hash)
      defaults.merge! hash
    end
    
    def self.defaults
      @defaults ||= {}
    end
    
    def self.all_defaults
      return defaults.merge(self.superclass.all_defaults) if self.superclass.respond_to? :all_defaults
      defaults
    end
    
    def self.after_validate(&block)
      after_validations << block
    end
    
    def self.after_validations
      @after_validations ||= []
    end
    
    def self.all_after_validations
      return after_validations + self.superclass.all_after_validations if self.superclass.respond_to? :all_after_validations
      after_validations
    end

    include Understandable
    include Requireable
    
    option :message, :if, :times, :level, :groups, :key, :after_validate, :allow_nil, :allow_blank
    default :level => 1, :groups => []
    attr_accessor :attribute
    
    def initialize(klass, attribute, options={})
      must_understand options
      requires options
      self.class.all_understandings.each do |understanding|
        options[understanding] = self.class.all_defaults[understanding] unless options.has_key? understanding
        self.instance_variable_set("@#{understanding}", options[understanding])
      end
      self.attribute = attribute
      self.groups = [self.groups] unless self.groups.is_a?(Array)
      self.key = "#{klass.name}/#{self.class.name}/#{self.key || self.attribute}"
      raise_error_if_key_is_dup(klass)
    end
    
    def raise_error_if_key_is_dup(klass)
      message = "key #{self.key} must be unique, provide the :key option to specify a unique key"
      raise ArgumentError.new(message) if klass.validation_keys_include? self.key
    end
    
    def should_validate?(instance)
      result = validate_this_time?(instance)
      result &&= instance.instance_eval(&self.if) unless self.if.nil?
      result
    end
    
    def message(instance)
      @message.respond_to?(:call) ? instance.instance_eval(&@message) : @message
    end
    
    def validate_this_time?(instance)
      return true if @times.nil?
      self.times > instance.times_validated(self.key)
    end
    
    def run_after_validate(result, instance, attribute)
      self.class.all_after_validations.each do |block|
        block.call result, instance, attribute
      end
      instance.instance_eval_with_params result, attribute, &self.after_validate unless self.after_validate.nil?
    end
  end
end