class BitHash

# File lib/bit_hash.rb, line 9
def initialize(config_map=nil, *options)
  @options = {
    :base     => :url_safe,
    :char_set => nil,
  }
  @options = load_options(options)
  @config = Hash.new
  @default = Hash.new
  #validate mapping
  load_config_map(config_map) if config_map.kind_of? Array
  @config
end

# File lib/bit_hash.rb, line 115
def [](key)
  @config[key]
end

# File lib/bit_hash.rb, line 90
def []=(key,value)
  set(key,value)
end

# File lib/bit_hash.rb, line 132
def get_options(key)
  index = @config_map.index{|x|x[:name]==key}
  (index) ? @config_map[index].merge({:index => index}) : nil
end

# File lib/bit_hash.rb, line 74
def keys
  @config_map.map{ |c| c[:name]}
end

# File lib/bit_hash.rb, line 58
def load_config_map(config_map)
  raise ArgumentError, "Config Map must be an Array" unless config_map.kind_of? Array
  config_array = []
  new_config = {}
  config_map.each_index do |index|
    conf = config_map[index]
    raise ArgumentError, "#{conf[:name]} is a duplicate" if new_config.keys.index(conf[:name])
    new_config[conf[:name]] = get_check_config(index,conf)
    config_array[index] = conf 
  end
  @config = new_config.dup
  @default = new_config.dup
  @config_map = config_array
end

# File lib/bit_hash.rb, line 150
def parse(config_string, *options)
  options = load_options(options)
  config_string = config_string.from_insane(options[:base],options[:char_set]).to_s(2)
  config_array = config_string.split('')
  new_config = @default.dup
  @config_map.each do |conf|
    value = config_array.pop(conf[:size])
    break if value.nil?
    value = value.join('').to_i(2)
    new_config[conf[:name]] = (conf[:options].kind_of? Array ) ? conf[:options][value] : value
  end
  new_config
end

# File lib/bit_hash.rb, line 120
def replace(hash)
  cache = @config.dup
  hash.each do |key, value|
    if set(key,value).nil?
      @config = cache
      return nil
    end
  end
  @config
end

# File lib/bit_hash.rb, line 138
def replace_options(key, options)
  @config_map.map! do |conf|
    if conf[:name] == key
      options
    else
      conf
    end
  end
end

# File lib/bit_hash.rb, line 165
def save(config_string, *options)
  @config = parse(config_string, *options)
end

# File lib/bit_hash.rb, line 95
def set(key,value)
  conf = get_options(key)
  if conf && check_value(conf,value)
    @config[key] = value
  else
    nil
  end
end

# File lib/bit_hash.rb, line 105
def set!(key,value)
  conf = get_options(key)
  if conf && check_value!(conf,value)
    @config[key] = value
  else
    raise ArgumentError, "Key: '#{key}' not found in config"
  end
end

# File lib/bit_hash.rb, line 79
def set_default(key)
  conf = get_options(key)
  @config[conf[:name]] = 0
  if !conf[:default].nil?
    new_config[conf[:name]] = conf[:default]
  elsif !conf[:default_index].nil?
    new_config[conf[:name]] = conf[:options][conf.default_index]
  end
end

# File lib/bit_hash.rb, line 170
def to_bin
  bin_config = []
  @config_map.each do |conf|
    val = @config[conf[:name]]
    val = conf[:options].index(val) if conf[:options].kind_of? Array
    bin = "%0#{conf[:size]}d" % val.to_s(2).to_i
    bin_config.unshift(bin)
  end
  bin_config.join('')
end

# File lib/bit_hash.rb, line 203
def to_hash
  @config
end

# File lib/bit_hash.rb, line 182
def to_i
  to_bin.to_i(2)
end

# File lib/bit_hash.rb, line 188
def to_s(*options)
  options = load_options(options)
  str = ''
  str << to_i.to_insane(options[:base], options[:char_set])
  str
end

# File lib/bit_hash.rb, line 196
def valid_value?(key,val)
  check_value(get_options(key),val)
end

# File lib/bit_hash.rb, line 210
def check_value(conf,val)
  if conf[:options].kind_of?(Array)
    return false if conf[:options].index(val).nil?
  elsif conf[:options].kind_of?(Integer) && val.kind_of?(Integer)
    return false if val < 0 or val > conf[:options]
  else
    return false
  end
  true
end

# File lib/bit_hash.rb, line 222
def check_value!(conf,val)
  if conf[:options].kind_of? Array
    raise ArgumentError, "#{conf[:name]} is #{val} and is not a valid value within the stored array. #{conf[:options].to_s}" if conf[:options].index(val).nil?
  elsif conf[:options].kind_of? Integer
    raise ArgumentError, "#{conf[:name]} is #{val} and should not be less than 0" if val < 0
    raise ArgumentError, "#{conf[:name]} is #{val} and value is not less than #{conf[:options]}" if val > conf[:options]
  else
    raise ArgumentError, "#{conf[:name]} is not a valid value please associate it with an object in an array or give it an integer value" 
  end
  true
end

# File lib/bit_hash.rb, line 245
def get_check_config(key,conf)
  raise ArgumentError, "config is not a Hash" unless conf.kind_of? Hash
  raise ArgumentError, ":name cannot be nil for [#{key}]" if conf[:name].nil?
  raise ArgumentError, ":options cannot be nil for [#{key}]" if conf[:options].nil?
  if conf[:options].kind_of? Integer
    conf[:size] = conf[:options]
  elsif conf[:options].kind_of? Array
    conf[:size] = conf[:options].size
  elsif conf[:options].kind_of? Symbol || conf[:options].kind_of?(String)
    raise ArgumentError, ":options Character set cannot have duplicate characters" if conf[:options].kind_of?(String) && (conf[:options].size != conf[:options].split(//).uniq.size)
    raise ArgumentError, ":options"
    raise ArgumentError, ":size needs to be an integer larger than 0 [#{conf[:name]}]" unless conf[:size].kind_of? Integer and conf[:size] > 0
  else
    raise ArgumentError, ":options needs to be an Array or Integer for [#{conf[:name]}]" 
  end
  if !conf[:default].nil?
    raise ArgumentError, "default value of (#{conf[:default]}) is not valid for #{conf[:name]}" unless check_value(conf,conf[:default])
    default = conf[:default]
  elsif !conf[:default_index].nil?
    raise ArgumentError, ":default_index must be an integer #{conf[:name]}" unless conf[:default_index].kind_of? Integer
    unless default = conf[:options][conf[:default_index]]
      raise ArgumentError, ":default_index must be a valid option array index #{conf[:name]}"
    end
  end
  conf[:size] = (conf[:size]-1).to_s(2).size
  default ||= (conf[:options].kind_of? Integer) ? 0 : conf[:options][0]
end

# File lib/bit_hash.rb, line 234
def load_options(options)
  new_options = @options.dup
  if options[0].kind_of? Hash
    new_options.merge(options[0])
  else
    new_options[:base] = options[0] unless options[0].nil?
    new_options[:char_set] = options[1] unless options[1].nil?
  end
  new_options
end