module ActiveRecord::NestedAttributes

def _destroy
  marked_for_destruction?
end

def allow_destroy?(association_name)
  nested_attributes_options[association_name][:allow_destroy]
end

def assign_nested_attributes_for_collection_association(association_name, attributes_collection)
  options = nested_attributes_options[association_name]
  if attributes_collection.respond_to?(:permitted?)
    attributes_collection = attributes_collection.to_h
  end
  unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
    raise ArgumentError, "Hash or Array expected for `#{association_name}` attributes, got #{attributes_collection.class.name}"
  end
  check_record_limit!(options[:limit], attributes_collection)
  if attributes_collection.is_a? Hash
    keys = attributes_collection.keys
    attributes_collection = if keys.include?("id") || keys.include?(:id)
      [attributes_collection]
    else
      attributes_collection.values
    end
  end
  association = association(association_name)
  existing_records = if association.loaded?
    association.target
  else
    attribute_ids = attributes_collection.filter_map { |a| a["id"] || a[:id] }
    attribute_ids.empty? ? [] : association.scope.where(association.klass.primary_key => attribute_ids)
  end
  records = attributes_collection.map do |attributes|
    if attributes.respond_to?(:permitted?)
      attributes = attributes.to_h
    end
    attributes = attributes.with_indifferent_access
    if attributes["id"].blank?
      unless reject_new_record?(association_name, attributes)
        association.reader.build(attributes.except(*UNASSIGNABLE_KEYS))
      end
    elsif existing_record = find_record_by_id(association.klass, existing_records, attributes["id"])
      unless call_reject_if(association_name, attributes)
        # Make sure we are operating on the actual object which is in the association's
        # proxy_target array (either by finding it, or adding it if not found)
        # Take into account that the proxy_target may have changed due to callbacks
        target_record = find_record_by_id(association.klass, association.target, attributes["id"])
        if target_record
          existing_record = target_record
        else
          association.add_to_target(existing_record, skip_callbacks: true)
        end
        assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
        existing_record
      end
    else
      raise_nested_attributes_record_not_found!(association_name, attributes["id"])
    end
  end
  association.nested_attributes_target = records
end

def assign_nested_attributes_for_one_to_one_association(association_name, attributes)
  if attributes.respond_to?(:permitted?)
    attributes = attributes.to_h
  end
  unless attributes.is_a?(Hash)
    raise ArgumentError, "Hash expected for `#{association_name}` attributes, got #{attributes.class.name}"
  end
  options = nested_attributes_options[association_name]
  attributes = attributes.with_indifferent_access
  existing_record = send(association_name)
  if (options[:update_only] || !attributes["id"].blank?) && existing_record &&
      (options[:update_only] || existing_record.id.to_s == attributes["id"].to_s)
    assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy]) unless call_reject_if(association_name, attributes)
  elsif attributes["id"].present?
    raise_nested_attributes_record_not_found!(association_name, attributes["id"])
  elsif !reject_new_record?(association_name, attributes)
    assignable_attributes = attributes.except(*UNASSIGNABLE_KEYS)
    if existing_record && existing_record.new_record?
      existing_record.assign_attributes(assignable_attributes)
      association(association_name).initialize_attributes(existing_record)
    else
      method = :"build_#{association_name}"
      if respond_to?(method)
        send(method, assignable_attributes)
      else
        raise ArgumentError, "Cannot build association `#{association_name}'. Are you trying to build a polymorphic one-to-one association?"
      end
    end
  end
end

def assign_to_or_mark_for_destruction(record, attributes, allow_destroy)
  record.assign_attributes(attributes.except(*UNASSIGNABLE_KEYS))
  record.mark_for_destruction if has_destroy_flag?(attributes) && allow_destroy
end

def call_reject_if(association_name, attributes)
  return false if will_be_destroyed?(association_name, attributes)
  case callback = nested_attributes_options[association_name][:reject_if]
  when Symbol
    method(callback).arity == 0 ? send(callback) : send(callback, attributes)
  when Proc
    callback.call(attributes)
  end
end

def check_record_limit!(limit, attributes_collection)
  if limit
    limit = \
      case limit
      when Symbol
        send(limit)
      when Proc
        limit.call
      else
        limit
      end
    if limit && attributes_collection.size > limit
      raise TooManyRecords, "Maximum #{limit} records are allowed. Got #{attributes_collection.size} records instead."
    end
  end
end

def find_record_by_id(klass, records, id)
  if klass.composite_primary_key?
    id = Array(id).map(&:to_s)
    records.find { |record| Array(record.id).map(&:to_s) == id }
  else
    records.find { |record| record.id.to_s == id.to_s }
  end
end

def has_destroy_flag?(hash)
  Type::Boolean.new.cast(hash["_destroy"])
end

def raise_nested_attributes_record_not_found!(association_name, record_id)
  model = self.class._reflect_on_association(association_name).klass.name
  raise RecordNotFound.new("Couldn't find #{model} with ID=#{record_id} for #{self.class.name} with ID=#{id}",
                           model, "id", record_id)
end

def reject_new_record?(association_name, attributes)
  will_be_destroyed?(association_name, attributes) || call_reject_if(association_name, attributes)
end

def will_be_destroyed?(association_name, attributes)
  allow_destroy?(association_name) && has_destroy_flag?(attributes)
end