# frozen_string_literal: true

module Briard
  module Readers
    module NpmReader
      def get_npm(id: nil, **_options)
        return { 'string' => nil, 'state' => 'not_found' } unless id.present?

        id = normalize_id(id)
        response = Maremma.get(id, accept: 'json', raw: true)
        string = response.body.fetch('data', nil)

        { 'string' => string }
      end

      def read_npm(string: nil, **options)
        if string.present?
          errors = jsonlint(string)
          return { 'errors' => errors } if errors.present?
        end

        read_options = ActiveSupport::HashWithIndifferentAccess.new(options.except(:doi, :id, :url,
                                                                                   :sandbox, :validate, :ra))

        meta = string.present? ? Maremma.from_json(string) : {}

        types = {
          'resourceTypeGeneral' => 'Software',
          'reourceType' => 'NPM Package',
          'schemaOrg' => 'SoftwareSourceCode',
          'citeproc' => 'article',
          'bibtex' => 'misc',
          'ris' => 'GEN'
        }.compact

        creators = if meta.fetch('author', nil).present?
                     get_authors(Array.wrap(meta.fetch('author', nil)))
                   else
                     [{ 'nameType' => 'Organizational', 'name' => ':(unav)' }]
                   end
        # contributors = get_authors(from_citeproc(Array.wrap(meta.fetch("editor", nil))))
        # dates = if date = get_date_from_date_parts(meta.fetch("issued", nil))
        #           if Date.edtf(date).present?
        #             [{ "date" => date,
        #               "dateType" => "Issued" }]
        #           end
        #         end
        # publication_year = get_date_from_date_parts(meta.fetch("issued", nil)).to_s[0..3]
        rights_list = if meta.fetch('license', nil)
                        [{ 'rights' => meta.fetch('license') }.compact]
                      end
        # related_identifiers = if meta.fetch("container-title", nil).present? && meta.fetch("ISSN", nil).present?
        #                         [{ "type" => "Periodical",
        #                           "relationType" => "IsPartOf",
        #                           "relatedIdentifierType" => "ISSN",
        #                           "title" => meta.fetch("container-title", nil),
        #                           "relatedIdentifier" => meta.fetch("ISSN", nil) }.compact]
        #                       end
        # container = if meta.fetch("container-title", nil).present?
        #   first_page = meta.fetch("page", nil).present? ? meta.fetch("page").split("-").map(&:strip)[0] : nil
        #   last_page = meta.fetch("page", nil).present? ? meta.fetch("page").split("-").map(&:strip)[1] : nil

        #   { "type" => "Periodical",
        #     "title" => meta.fetch("container-title", nil),
        #     "identifier" => meta.fetch("ISSN", nil),
        #     "identifierType" => meta.fetch("ISSN", nil).present? ? "ISSN" : nil,
        #     "volume" => meta.fetch("volume", nil),
        #     "issue" => meta.fetch("issue", nil),
        #     "firstPage" => first_page,
        #     "lastPage" => last_page
        #    }.compact
        # else
        #   nil
        # end

        # identifiers = [normalize_id(meta.fetch("id", nil)), normalize_doi(meta.fetch("DOI", nil))].compact.map do |r|
        #   r = normalize_id(r)

        #   if r.start_with?("https://doi.org")
        #     { "identifierType" => "DOI", "identifier" => r }
        #   else
        #       { "identifierType" => "URL", "identifier" => r }
        #   end
        # end.uniq

        # id = Array.wrap(identifiers).first.to_h.fetch("identifier", nil)
        # doi = Array.wrap(identifiers).find { |r| r["identifierType"] == "DOI" }.to_h.fetch("identifier", nil)

        # state = id.present? || read_options.present? ? "findable" : "not_found"
        subjects = Array.wrap(meta.fetch('keywords', nil)).map do |s|
          { 'subject' => s }
        end

        {
          # "id" => id,
          # "identifiers" => identifiers,
          'types' => types,
          # "doi" => doi_from_url(doi),
          # "url" => normalize_id(meta.fetch("URL", nil)),
          'titles' => [{ 'title' => meta.fetch('name', nil) }],
          'creators' => creators,
          # "contributors" => contributors,
          # "container" => container,
          # "publisher" => meta.fetch("publisher", nil),
          # "related_identifiers" => related_identifiers,
          # "dates" => dates,
          # "publication_year" => publication_year,
          'descriptions' => if meta.fetch('description', nil).present?
                              [{ 'description' => sanitize(meta.fetch('description')),
                                 'descriptionType' => 'Abstract' }]
                            else
                              []
                            end,
          'rights_list' => rights_list,
          'version_info' => meta.fetch('version', nil),
          'subjects' => subjects
          # "state" => state
        }.merge(read_options)
      end
    end
  end
end