module MetaMongo

# File lib/meta_mongo.rb, line 34
def check_missing_keys(obj, *keys)
  keys.each do |key|
    missing_key(key) if !obj.key?(key)
  end
end

# File lib/meta_mongo.rb, line 18
def create_method(klass, method, block)
  klass.singleton_class.send(:define_method, :foo, &block)
end

# File lib/meta_mongo.rb, line 10
def create_model(name)
  Utils.create_class(name)
end

# File lib/meta_mongo.rb, line 28
def extend_module(klass, mod)
  klass.class_eval do
    extend mod
  end
end

# File lib/meta_mongo.rb, line 22
def include_module(klass, mod)
  klass.class_eval do
    include mod
  end
end

# File lib/meta_mongo.rb, line 69
def init(hash)
  models = hash["models"]

  missing_key("models") unless models
  wrong_type("models") unless models.is_a?(Array)

  models.each do |model|
    check_missing_keys(model, "name", "attributes")

    if !model["attributes"].is_a?(Array)
      wrong_type("attributes")
    end

    attrs = parse_attributes(model["attributes"])

    klass = MetaMongo.create_model(model["name"])
    MetaMongo.include_module(klass, Mongoid::Document)
    MetaMongo.include_module(klass, Mongoid::Timestamps)
    MetaMongo.extend_module(klass, Enumerize)

    if relations = model["relations"]
      wrong_type("relations") unless relations.is_a?(Array)
      relations.each do |relation|
        relation.each_pair do |func, args|
          MetaMongo.run_method(klass, func, *args)
        end
      end
    end

    attrs.each do |att|
      MetaMongo.run_method(klass, :field, att[:field], type: att[:type])

      att[:vals].each do |val|
        MetaMongo.run_method(klass, :validates, att[:field], val)
      end

      if enum = att[:enum]
        MetaMongo.run_method(klass, :enumerize, att[:field], enum)
      end
    end
  end
end

# File lib/meta_mongo.rb, line 40
def missing_key(key)
  raise BadHash.new("Missing '#{key}' key")
end

# File lib/meta_mongo.rb, line 48
def parse_attributes(attrs)
  out = []

  attrs.each do |my_attr|
    check_missing_keys my_attr, "field", "name", "type", "validations"

    out << {
      name:  my_attr["name"],
      field: my_attr["field"],
      type:  Utils.to_class(my_attr["type"]),
      vals:  my_attr["validations"],
      enum:  my_attr["enumerize"]
    }

    wrong_type("validations") if !out.last[:vals].is_a?(Array)

  end

  out
end

# File lib/meta_mongo.rb, line 14
def run_method(klass, method, *args)
  klass.send(method, *args)
end

# File lib/meta_mongo.rb, line 44
def wrong_type(key)
  raise BadHash.new("Invalid '#{key}' type")
end