require 'ostruct'
module Blacklight
  ##
  # An OpenStruct that responds to common Hash methods
  class OpenStructWithHashAccess < OpenStruct
    delegate :keys, :each, :map, :has_key?, :empty?, :delete, :length, :reject!, :select!, :include, :fetch, :to_json, :as_json, :to => :to_h

    if ::RUBY_VERSION < '2.0'
      def []=(key, value)
        send "#{key}=", value
      end

      def [](key)
        send key
      end
    end

    ##
    # Expose the internal hash
    # @return [Hash]
    def to_h
      @table
    end

    ##
    # Merge the values of this OpenStruct with another OpenStruct or Hash
    # @param [Hash,#to_h]
    # @return [OpenStructWithHashAccess] a new instance of an OpenStructWithHashAccess
    def merge other_hash
      self.class.new to_h.merge((other_hash if other_hash.is_a? Hash) || other_hash.to_h)
    end

    ##
    # Merge the values of another OpenStruct or Hash into this object
    # @param [Hash,#to_h]
    # @return [OpenStructWithHashAccess] a new instance of an OpenStructWithHashAccess
    def merge! other_hash
      @table.merge!((other_hash if other_hash.is_a? Hash) || other_hash.to_h)
    end 
  end


  ##
  # An OpenStruct refinement that converts any hash-keys into  
  # additional instances of NestedOpenStructWithHashAccess
  class NestedOpenStructWithHashAccess < OpenStructWithHashAccess
    attr_reader :nested_class
    delegate :default_proc=, :to => :to_h

    def initialize klass, *args
      @nested_class = klass
      hash = {}

      hashes_and_keys = args.flatten
      lazy_configs = hashes_and_keys.extract_options!

      args.each do |v|
        if v.is_a? Hash
          key = v.first
          value = v[key]

          hash[key] = nested_class.new value
        else
          hash[v] = nested_class.new
        end
      end

      lazy_configs.each do |k,v|
        hash[k] = nested_class.new v
      end

      super hash
      set_default_proc!
    end

    ##
    # Add an new key to the object, with a default default
    def << key
      @table[key]
    end

    ##
    # Add a new key/value to the object; if it's a Hash, turn it
    # into another NestedOpenStructWithHashAccess
    def []=(key, value)
      if value.is_a? Hash
        send "#{key}=", nested_class.new(value)
      elsif ::RUBY_VERSION < '2.0'
        send "#{key}=", value
      else
        super
      end
    end

    ##
    # Before serializing, we need to reset the default proc
    # so it can be serialized appropriately
    def marshal_dump
      h = to_h.dup
      h.default = nil

      [nested_class, h]
    end

    ##
    # After deserializing, we need to re-add the default proc
    # to the internal hash
    def marshal_load x
      @nested_class = x.first
      super x.last
      set_default_proc!
    end

    private
    def set_default_proc!
      self.default_proc = lambda do |hash, key|
        hash[key] = self.nested_class.new
      end
    end
  end
end