module Metanorma::Utils

def guid_anchor?(id)
  /^_[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i
    .match?(id)
end

def line_sanitise(ret)
  ret.size == 1 and return ret
  (0...(ret.size - 1)).each do |i|
    last = firstchar_xml(ret[i].reverse)
    nextfirst = firstchar_xml(ret[i + 1])
    cjk1 = /#{CJK}/o.match?(last)
    cjk2 = /#{CJK}/o.match?(nextfirst)
    text1 = /[^\p{Z}\p{C}]/.match?(last)
    text2 = /[^\p{Z}\p{C}]/.match?(nextfirst)
    cjk1 && (cjk2 || !text2) and next
    !text1 && cjk2 and next
    ret[i] += " "
  end
  ret
end

def localdir(node)
  docfile = node.attr("docfile")
  docfile.nil? ? "./" : "#{Pathname.new(docfile).parent}/"
end

def noko(_script = "Latn", &block)
  fragment = ::Nokogiri::XML.parse(NOKOHEAD).fragment("")
  ::Nokogiri::XML::Builder.with fragment, &block
  fragment
    .to_xml(encoding: "UTF-8", indent: 0,
            save_with: Nokogiri::XML::Node::SaveOptions::AS_XML)
    .gsub("–", "\u0096").gsub("—", "\u0097")
    .gsub("–", "\u0096").gsub("—", "\u0097")
end

def noko_html(&block)
  doc = ::Nokogiri::XML.parse(NOKOHEAD)
  fragment = doc.fragment("")
  ::Nokogiri::XML::Builder.with fragment, &block
  fragment.to_xml(encoding: "UTF-8", indent: 0,
                  save_with: Nokogiri::XML::Node::SaveOptions::AS_XML)
    .lines.map do |l|
    l.gsub(/\s*\n/, "")
  end
end

def ns(xpath)
  xpath.gsub(%r{/([a-zA-Z])}, "/xmlns:\\1")
    .gsub(%r{::([a-zA-Z])}, "::xmlns:\\1")
    .gsub(%r{\[([a-zA-Z][a-z0-9A-Z@/-]* ?=)}, "[xmlns:\\1")
    .gsub(%r{\[([a-zA-Z][a-z0-9A-Z@/-]*[/\[\]])}, "[xmlns:\\1")
end

def numeric_escapes(xml)
  c = HTMLEntities.new
  xml.split(/(&[^ \r\n\t#&;]+;)/).map do |t|
    if /^(&[^ \t\r\n#;]+;)/.match?(t)
      c.encode(c.decode(t), :hexadecimal)
    else t
    end
  end.join
end

def rtl_script?(script)
  %w(Arab Aran Hebr).include? script
end

def set_nested_value(hash, keys, new_val)
  key = keys[0]
  if keys.length == 1
    hash[key] = if hash[key].is_a?(::Array) then (hash[key] << new_val)
                else hash[key].nil? ? new_val : [hash[key], new_val]
                end
  elsif hash[key].is_a?(::Array)
    hash[key][-1] = {} if !hash[key].empty? && hash[key][-1].nil?
    hash[key] << {} if hash[key].empty? || !hash[key][-1].is_a?(::Hash)
    set_nested_value(hash[key][-1], keys[1..-1], new_val)
  elsif hash[key].nil? || hash[key].empty?
    hash[key] = {}
    set_nested_value(hash[key], keys[1..-1], new_val)
  elsif hash[key].is_a?(::Hash) && !hash[key][keys[1]]
    set_nested_value(hash[key], keys[1..-1], new_val)
  elsif !hash[key][keys[1]]
    hash[key] = [hash[key], {}]
    set_nested_value(hash[key][-1], keys[1..-1], new_val)
  else
    set_nested_value(hash[key], keys[1..-1], new_val)
  end
  hash
end

def smartformat(text)
  ret = HTMLEntities.new.decode(
    text.gsub(/ --? /, " — ")
    .gsub("--", "—"),
  )
  ret = ret.gsub(%r{(#{CJK})(["'])}o, "\\1\u200a\\2")
    .gsub(%r{(["'])(#{CJK})}o, "\\1\u200a\\2")
  ret = ret.smart_format
  ret = ret.gsub(%r{(#{CJK})\u200a}o, "\\1")
    .gsub(%r{\u200a(#{CJK})}o, "\\1")
  HTMLEntities.new.encode(ret, :basic)
end

def strict_capitalize_first(str)
  str.split(/ /).each_with_index.map do |w, i|
    letters = w.chars
    letters.first.upcase! if i.zero?
    letters.join
  end.join(" ")
end

def strict_capitalize_phrase(str)
  str.split(/ /).map do |w|
    letters = w.chars
    letters.first.upcase!
    letters.join
  end.join(" ")
end

def to_ncname(name, asciionly: false)
  name, valid = to_ncname_prep(name, asciionly)
  valid and return name
  starting_char = name[0]
  starting_char.gsub!(INVALID_NCNAME_START_REGEXP, NCNAME_INVALID)
  name.size == 1 and return starting_char
  following_chars = name[1..-1]
  following_chars.gsub!(INVALID_NCNAME_CHAR_REGEXP, NCNAME_INVALID)
  following_chars.gsub!(":", NCNAME_INVALID)
  starting_char << following_chars
end

def to_ncname_prep(name, asciionly)
  name = name&.to_s
  name.nil? and name = ""
  asciionly and name = HTMLEntities.new.encode(name,
                                               :basic, :hexadecimal)
  [name, name.nil? || name.empty? || name.match?(SAFE_NCNAME_REGEXP)]
end

def to_xhtml_fragment(xml)
  doc = ::Nokogiri::XML.parse(NOKOHEAD)
  doc.fragment(xml)
end

def wrap_in_para(node, out)
  if node.blocks? then out << node.content
  else
    out.p { |p| p << node.content }
  end
end