module Metanorma
  class Requirements
    class Modspec < Default
      REQT_TYPE_NORM = {
        requirement: "general",
        recommendation: "general",
        permission: "general",
        requirements_class: "class",
        requirement_class: "class",
        recommendation_class: "class",
        permission_class: "class",
        conformance_test: "verification",
        conformance_class: "conformanceclass",
        abstract_test: "abstracttest",
      }.freeze

      def requirement_type_cleanup(reqt)
        ret = REQT_TYPE_NORM[reqt["type"]&.to_sym] or return
        reqt["type"] = ret
      end

      def requirement_metadata_component_tags
        %w(test-purpose test-method test-method-type conditions part description
           reference step guidance) +
          requirement_metadata_requirement_tags
      end

      def requirement_metadata_requirement_tags
        %w(conformance-test conformance-class abstract-test requirement-class
           recommendation-class permission-class requirement permission
           recommendation)
      end

      def requirement_metadata1(reqt, dlist, ins)
        ins1 = super
        dlist.xpath("./dt").each do |e|
          tag = e.text&.gsub(/ /, "-")&.downcase
          next unless requirement_metadata_component_tags.include?(tag)

          ins1.next = requirement_metadata1_component(e, tag)
          ins1 = ins1.next
        end
      end

      def requirement_metadata1_component(term, tag)
        val = term.at("./following::dd")
        val.name = tag
        val.xpath("./dl").each do |d|
          requirement_metadata1(val, d, d)
          d.remove
        end
        requirement_metadata_requirement_tags.include?(term.text) &&
          !val.text.empty? and
          val.children = "<identifier>#{val.text.strip}</identifier>"
        val
      end

      # separate from default model requirement_metadata_cleanup,
      # which extracts model:: ogc into reqt["model"]
      def requirement_metadata_cleanup(reqt)
        super
        requirement_metadata_to_component(reqt)
        requirement_metadata_to_requirement(reqt)
        requirement_subparts_to_blocks(reqt)
        requirement_target_identifiers(reqt)
      end

      def requirement_target_identifiers(reqt)
        reqt.xpath("./classification[tag = 'target']/value[link]").each do |v|
          v.children = v.at("./link/@target").text
        end
      end

      def requirement_metadata_to_component(reqt)
        xpath = requirement_metadata_component_tags - %w(description) -
          requirement_metadata_requirement_tags
        reqt.xpath(xpath.map { |x| ".//#{x}" }.join(" | ")).each do |c|
          c["class"] = c.name
          c.name = "component"
        end
      end

      def requirement_metadata_to_requirement(reqt)
        xpath = requirement_metadata_requirement_tags
        reqt.xpath(xpath.map { |x| "./#{x}" }.join(" | ")).each do |c|
          c["id"] = Metanorma::Utils::anchor_or_uuid
          c["model"] = reqt["model"] # all requirements must have a model
          requirement_metadata_to_requirement1(c)
        end
      end

      def requirement_metadata_to_requirement1(reqt)
        reqt["type"] = reqt.name.sub(/-/, "_")
        reqt.name =
          case reqt.name
          when "recommendation-class", "recommendation" then "recommendation"
          when "permission-class", "permission" then "permission"
          else "requirement"
          end
        requirement_type_cleanup(reqt)
      end

      def requirement_subparts_to_blocks(reqt)
        reqt.xpath(".//component | .//description").each do |c|
          next if %w(p ol ul dl table component description)
            .include?(c&.elements&.first&.name)

          c.children = "<p>#{c.children.to_xml}</p>"
        end
      end
    end
  end
end