module ActiveFedora
  module Associations
    # Filters a DirectContainer relationship, returning the first item that matches the given :type
    class DirectlyContainsOneAssociation < SingularAssociation #:nodoc:

      # Finds objects contained by the container predicate (either the configured has_member_relation or ldp:contains)
      # TODO: Refactor this to use solr (for efficiency) instead of parsing the RDF graph.  Requires indexing ActiveFedora::File objects into solr, including their RDF.type and, if possible, the id of their container
      def find_target
        # filtered_objects = container_association_proxy.to_a.select { |o| o.metadata_node.type.include?(options[:type]) }
        query_node = if container_predicate = options[:has_member_relation]
                       owner
                     else
                       container_predicate = ::RDF::Vocab::LDP.contains
                       container_association.container  # Use the :through association's container
                     end

        contained_uris = query_node.resource.query(predicate: container_predicate).map { |r| r.object.to_s }
        contained_uris.each do |object_uri|
          contained_object = klass.find(klass.uri_to_id(object_uri))
          return contained_object if get_type_from_record(contained_object).include?(options[:type])
        end
        return nil # if nothing was found & returned while iterating on contained_uris, return nil
      end

      # Adds record to the DirectContainer identified by the container_association
      # Relies on container_association.initialize_attributes to appropriately set things like record.uri
      def add_to_container(record)
        container_association.add_to_target(record)  # adds record to corresponding Container
        # TODO is send necessary?
        container_association.send(:initialize_attributes, record) # Uses the :through association initialize the record with things like the correct URI for a direclty contained object
      end

      # Replaces association +target+ with +record+
      # Ensures that this association's +type+ is set on the record and adds the record to the association's DirectContainer
      def replace(record, *)
        if record
          raise_on_type_mismatch(record)
          run_type_validator(record)
          remove_existing_target
          add_type_to_record(record, options[:type])
          add_to_container(record)
        else
          remove_existing_target
        end

        self.target = record
      end

      def updated?
        @updated
      end

      private

      def remove_existing_target
        @target ||= find_target
        if @target
          container_association_proxy.delete @target
          @updated = true
        end
      end

      # Overrides initialize_attributes to ensure that record is initialized with attributes from the corresponding container
      def initialize_attributes(record)
        super
        container_association.initialize_attributes(record)
      end

      # Returns the Reflection corresponding to the direct container association that's being filtered
      def container_reflection
        @container_reflection ||= @owner.class.reflect_on_association(@reflection.options[:through])
      end

      # Returns the DirectContainerAssociation corresponding to the direct container that's being filtered
      def container_association
        container_association_proxy.proxy_association
      end

      # Returns the ContainerAssociationProxy corresponding to the direct container that's being filtered
      def container_association_proxy
        @owner.send(@reflection.options[:through])
      end

      # Adds type_uri to the RDF.type assertions on record
      def add_type_to_record(record, type_uri)
        metadata_node = metadata_node_for_record(record)
        types = metadata_node.type
        unless types.include?(type_uri)
          types << type_uri
          metadata_node.set_value(:type, types)
        end
        return record
      end

      # Returns the RDF.type assertions for the record
      def get_type_from_record(record)
        metadata_node_for_record(record).type
      end

      # Returns the RDF node that contains metadata like RDF.type assertions for the record
      # Sometimes this is the record, other times it's record.metadata_node
      def metadata_node_for_record(record)
        if record.respond_to?(:type) && record.respond_to?(:set_value)
          return record
        elsif record.respond_to?(:metadata_node)
          return record.metadata_node
        else
          raise ArgumentError, "record must either have a metadata node or must respond to .type"
        end
      end

    end
  end
end