class BinData::SanitizedParameters

def [](param)
  @parameters[param]
end

def []=(param, value)
  @parameters[param] = value unless @all_sanitized
end

def all_sanitized?
  @all_sanitized
end

def delete(param)
  @parameters.delete(param)
end

def ensure_mandatory_parameters_exist
  @the_class.mandatory_parameters.each do |param|
    unless has_parameter?(param)
      raise ArgumentError,
              "parameter '#{param}' must be specified in #{@the_class}"
    end
  end
end

def ensure_mutual_exclusion_of_parameters
  return if length < 2
  @the_class.mutually_exclusive_parameters.each do |param1, param2|
    if has_parameter?(param1) and has_parameter?(param2)
      raise ArgumentError, "params '#{param1}' and '#{param2}' " +
                           "are mutually exclusive in #{@the_class}"
    end
  end
end

def ensure_no_nil_values
  @parameters.each do |param, value|
    if value.nil?
      raise ArgumentError,
            "parameter '#{param}' has nil value in #{@the_class}"
    end
  end
end

def has_parameter?(param)
  @parameters.has_key?(param)
end

def initialize(params, the_class)
  @all_sanitized = false
  @the_class = the_class
  @parameters = {}
  params.each { |param, value| @parameters[param.to_sym] = value }
  ensure_no_nil_values
end

def length
  @parameters.size
end

def merge_default_parameters!
  @the_class.default_parameters.each do |param, value|
    self[param] ||= value
  end
end

def move_unknown_parameters_to(dest)
  unless @all_sanitized
    unused_keys = @parameters.keys - @the_class.accepted_parameters.all
    unused_keys.each do |param|
      next if param == :onlyif
      dest[param] = @parameters.delete(param)
    end
  end
end

def needs_sanitizing?(param)
  has_parameter?(param) and not self[param].is_a?(SanitizedParameter)
end

def sanitize!(sanitizer)
  unless @all_sanitized
    merge_default_parameters!
    @the_class.sanitize_parameters!(self, sanitizer)
    ensure_mandatory_parameters_exist
    ensure_mutual_exclusion_of_parameters
    @all_sanitized = true
  end
end