require 'json'
require 'solrizer'

module Ddr
  module SolrDocumentBehavior
    extend ActiveSupport::Concern

    included do
      alias_method :pid, :id
    end

    class NotFound < Error; end

    module ClassMethods
      def find(id)
        query = Ddr::Index::Query.new { id id }
        if doc = query.docs.first
          return doc
        end
        raise NotFound, "SolrDocument not found for \"#{id}\"."
      end

      def find_by_permanent_id(ark)
        query = Ddr::Index::Query.new do
          q *:*
          where permanent_id: ark
        end
        if doc = query.docs.first
          return doc
        end
        raise NotFound, "SolrDocument not found for permanent id \"#{ark}\"."
      end
    end

    def inspect
      "#<#{self.class.name} id=#{id.inspect}>"
    end

    def method_missing(name, *args, &block)
      if args.empty? && !block
        begin
          field = Ddr::Index::Fields.get(name)
        rescue NameError
          # pass
        else
          # Preserves the default behavior of the deprecated method
          # Blacklight::Solr::Document#get, which this procedure
          # effectively replaces.
          val = self[field]
          return val.is_a?(Array) ? val.join(", ") : val
        end
      end
      super
    end

    def resource
      @resource = Valkyrie::MetadataAdapter.find(:index_solr).query_service.find_by(id: id)
    end

    ### DDRevo: Not sure if / where this is used
    def to_partial_path
      'document'
    end

    ### DDRevo: This is probably no longer needed
    def safe_id
      id.sub(/:/, "-")
    end

    ### DDRevo: No longer relevant
    # def object_profile
    #   @object_profile ||= get_json(Ddr::Index::Fields::OBJECT_PROFILE)
    # end

    ### DDRevo: No longer relevant
    # def object_state
    #   object_profile["objState"]
    # end

    def object_create_date
      parse_date(self[Ddr::Index::Fields::RESOURCE_CREATE_DATE])
    end

    def object_modified_date
      parse_date(self[Ddr::Index::Fields::RESOURCE_MODIFIED_DATE])
    end

    def last_fixity_check_on
      get_date(Ddr::Index::Fields::LAST_FIXITY_CHECK_ON)
    end

    def last_virus_check_on
      get_date(Ddr::Index::Fields::LAST_VIRUS_CHECK_ON)
    end

    ### DDRevo: No longer relevant
    # def datastreams
    #   object_profile["datastreams"]
    # end

    ### DDRevo: No longer relevant
    # def has_datastream?(dsID)
    #   datastreams[dsID].present?
    # end

    def has_admin_policy?
      admin_policy_id.present?
    end

    def admin_policy
      if has_admin_policy?
        self.class.find(admin_policy_id)
      end
    end

    def has_children?
      resource.children.present?
    end

    ### DDRevo: No longer relevant
    # def label
    #   object_profile["objLabel"]
    # end

    def title_display
      title
    end

    def identifier
      # We want the multivalued version here
      self[Solrizer.solr_name(:identifier, :stored_searchable, type: :text)]
    end

    def source
      self[Solrizer.solr_name(:source, :stored_searchable, type: :text)]
    end

    def has_thumbnail?
      resource.has_thumbnail?
    end

    def has_content?
      resource.has_content?
    end

    def has_intermediate_file?
      resource.has_intermediate_file?
    end

    def has_extracted_text?
      resource.has_extracted_text?
    end

    ### DDRevo: Not relevant as coded.  Not sure if comparable functionality is needed
    # def content_ds
    #   datastreams[Ddr::Datastreams::CONTENT]
    # end

    def content_mime_type
      resource.content_type
    end
    # For duck-typing with Ddr::HasContent
    alias_method :content_type, :content_mime_type

    def content_human_size
      resource.content_human_size
    end

    ### DDRevo: Not relevant as coded.  Not sure if comparable functionality is needed
    # def content_checksum
    #   content_ds["dsChecksum"] rescue nil
    # end

    def targets
      @targets ||= query_service.find_inverse_references_by(resource: resource, property: 'for_collection_id')
    end

    def targets_count
      @targets_count = targets.count
    end

    def has_target?
      targets_count > 0
    end

    ### DDRevo Still relevant?
    # def association(name)
    #   get_pid(ActiveFedora::SolrService.solr_name(name, :symbol))
    # end

    def tableized_name
      resource_model.tableize
    end

    def rights_statement
      @rights_statement ||= RightsStatement.call(self)
    end

    def roles
      # @roles ||= Ddr::Auth::Roles::Role.from_json(access_role)
      @roles ||= resource.roles
    end

    def resource_roles
      resource.resource_roles
    end

    def inherited_roles
      resource.inherited_roles
    end

    def structure
      JSON.parse(fetch(Ddr::Index::Fields::STRUCTURE))
    rescue
      nil
    end

    def effective_permissions(agents)
      Ddr::Auth::EffectivePermissions.call(self, agents)
    end

    def research_help
      research_help_contact = self[Ddr::Index::Fields::RESEARCH_HELP_CONTACT] || inherited_research_help_contact
      Ddr::Contact.call(research_help_contact) if research_help_contact
    end

    def parent_id
      is_part_of || is_member_of_collection
    end

    def has_parent?
      parent_id.present?
    end

    def parent
      if has_parent?
        self.class.find(parent_id)
      end
    end

    def multires_image_file_paths
      if structure
        structure_docs.map { |doc| doc.multires_image_file_path }.compact
      else
        []
      end
    end

    # DRY HasAdminMetadata
    def finding_aid
      if ead_id
        FindingAid.new(ead_id)
      end
    end

    def intermediate_type
      if has_intermediate_file?
        resource.intermediate_type
      end
    end

    def intermediate_path
      if has_intermediate_file?
        resource.intermediate_path
      end
    end

    def intermediate_extension
      if has_intermediate_file?
        extensions = Ddr.preferred_file_extensions
        if extensions.include? intermediate_type
          extensions[intermediate_type]
        else
          intermediate_extension_default
        end
      end
    end

    def captionable?
      resource.captionable?
    end

    def caption_type
      if captionable?
        resource.caption_type
      end
    end

    def caption_extension
      if captionable?
        extensions = Ddr.preferred_file_extensions
        if extensions.include? caption_type
          extensions[caption_type]
        else
          caption_extension_default
        end
      end
    end

    def caption_path
      if captionable?
        resource.caption_path
      end
    end

    def streamable?
      resource.streamable?
    end

    def streamable_media_extension
      if streamable?
        extensions = Ddr.preferred_file_extensions
        if extensions.include? streamable_media_type
          extensions[streamable_media_type]
        else
          streamable_media_extension_default
        end
      end
    end

    def streamable_media_type
      if streamable?
        resource.streamable_media_type
      end
    end

    def streamable_media_path
      if streamable?
        resource.streamable_media_path
      end
    end

    def thumbnail_path
      if has_thumbnail?
        resource.thumbnail_path
      end
    end

    # FIXME - Probably need a more general solution mapping object reader methods to index field names.
    def rights
      self["rights_tesim"]
    end

    def children
      resource.children
    end

    private

    def query_service
      @query_service ||= Valkyrie::MetadataAdapter.find(:index_solr).query_service
    end

    # def targets_query
    #   "#{Ddr::Index::Fields::IS_EXTERNAL_TARGET_FOR}:#{internal_uri_for_query}"
    # end
    #
    # def internal_uri_for_query
    #   ActiveFedora::SolrService.escape_uri_for_query(internal_uri)
    # end
    #
    def get_date(field)
      parse_date(self[field])
    end

    def get_json(field)
      JSON.parse Array(self[field]).first
    end

    def parse_date(date)
      Time.parse(date).localtime if date
    end

    # def get_pid(field)
    #   ActiveFedora::Base.pid_from_uri(self[field]) rescue nil
    # end
    #
    def inherited_research_help_contact
      if doc = admin_policy
        doc.research_help_contact
      end
    end

    def structure_docs
      structure_repo_ids.map { |repo_id| self.class.find(repo_id) }.compact
    end

    # For simplicity, initial implementation returns repo ID's only from top-level
    # (i.e., not nested) contents.  This is done since we have not clarified what
    # an _ordered_ list of repo ID's should look like if structure contains nested
    # contents.
    def structure_repo_ids
      default_struct_map['contents'].map { |content| content['contents'].map { |content| content['repo_id'] } }.flatten
    end

    def default_struct_map
      structure['default'] || structure.values.first
    end

    def intermediate_extension_default
      # datastreams[Ddr::Datastreams::INTERMEDIATE_FILE].default_file_extension
      resource.intermediate_file.default_file_extension
    end

    def caption_extension_default
      # datastreams[Ddr::Datastreams::CAPTION].default_file_extension
      resource.caption.default_file_extension
    end

    def streamable_media_extension_default
      # datastreams[Ddr::Datastreams::STREAMABLE_MEDIA].default_file_extension
      resource.streamable_media.default_file_extension
    end

    ### DDRevo: Using resource.children rather than this query
    # def children_query
    #   case self[Ddr::Index::Fields::RESOURCE_MODEL]
    #   when 'Ddr::Collection'
    #     Ddr::Index::Query.build(self) do |parent|
    #       is_member_of_collection parent.id
    #     end
    #   when 'Ddr::Item'
    #     Ddr::Index::Query.build(self) do |parent|
    #       is_part_of parent.id
    #     end
    #   end
    # end
  end
end