class Asciidoctor::AbstractNode

def add_role name
  if (val = @attributes['role'])
    # NOTE center + include? is faster than split + include?
    if %( #{val} ).include? %( #{name} )
      false
    else
      @attributes['role'] = %(#{val} #{name})
      true
    end
  else
    @attributes['role'] = name
    true
  end
end

def attr name, default_value = nil, fallback_name = nil
  @attributes[name.to_s] || (fallback_name && @parent && @document.attributes[(fallback_name == true ? name : fallback_name).to_s] || default_value)
end

def attr? name, expected_value = nil, fallback_name = nil
  if expected_value
    expected_value == (@attributes[name.to_s] || (fallback_name && @parent ? @document.attributes[(fallback_name == true ? name : fallback_name).to_s] : nil))
  else
    (@attributes.key? name.to_s) || (fallback_name && @parent ? (@document.attributes.key? (fallback_name == true ? name : fallback_name).to_s) : false)
  end
end

def block?
  # :nocov:
  raise ::NotImplementedError
  # :nocov:
end

def converter
  @document.converter
end

def generate_data_uri(target_image, asset_dir_key = nil)
  ext = ::File.extname target_image
  # QUESTION what if ext is empty?
  mimetype = (ext == '.svg' ? 'image/svg+xml' : %(image/#{ext.slice 1, ext.length}))
  if asset_dir_key
    image_path = normalize_system_path(target_image, @document.attr(asset_dir_key), nil, target_name: 'image')
  else
    image_path = normalize_system_path(target_image)
  end
  if ::File.readable? image_path
    # NOTE base64 is autoloaded by reference to ::Base64
    %(data:#{mimetype};base64,#{::Base64.strict_encode64 ::File.binread image_path})
  else
    logger.warn %(image to embed not found or not readable: #{image_path})
    %(data:#{mimetype};base64,)
    # uncomment to return 1 pixel white dot instead
    #'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=='
  end
end

def generate_data_uri_from_uri image_uri, cache_uri = false
  if cache_uri
    # caching requires the open-uri-cached gem to be installed
    # processing will be automatically aborted if these libraries can't be opened
    Helpers.require_library 'open-uri/cached', 'open-uri-cached'
  elsif !RUBY_ENGINE_OPAL
    # autoload open-uri
    ::OpenURI
  end
  begin
    mimetype, bindata = ::OpenURI.open_uri(image_uri, URI_READ_MODE) {|f| [f.content_type, f.read] }
    # NOTE base64 is autoloaded by reference to ::Base64
    %(data:#{mimetype};base64,#{::Base64.strict_encode64 bindata})
  rescue
    logger.warn %(could not retrieve image data from URI: #{image_uri})
    image_uri
    # uncomment to return empty data (however, mimetype needs to be resolved)
    #%(data:#{mimetype}:base64,)
    # uncomment to return 1 pixel white dot instead
    #'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=='
  end
end

def has_role? name
  # NOTE center + include? is faster than split + include?
  (val = @attributes['role']) ? (%( #{val} ).include? %( #{name} )) : false
end

def icon_uri name
  if attr? 'icon'
    # Ruby 2.3 requires the extra brackets around the attr method call
    if (::File.extname (icon = (attr 'icon'))).empty?
      # QUESTION should we be adding the extension if the icon is an absolute URI?
      icon = %(#{icon}.#{@document.attr 'icontype', 'png'})
    end
  else
    icon = %(#{name}.#{@document.attr 'icontype', 'png'})
  end
  image_uri icon, 'iconsdir'
end

def image_uri(target_image, asset_dir_key = 'imagesdir')
  if (doc = @document).safe < SafeMode::SECURE && (doc.attr? 'data-uri')
    if ((Helpers.uriish? target_image) && (target_image = Helpers.encode_uri target_image)) ||
        (asset_dir_key && (images_base = doc.attr asset_dir_key) && (Helpers.uriish? images_base) &&
        (target_image = normalize_web_path target_image, images_base, false))
      if doc.attr? 'allow-uri-read'
        generate_data_uri_from_uri target_image, (doc.attr? 'cache-uri')
      else
        target_image
      end
    else
      generate_data_uri target_image, asset_dir_key
    end
  else
    normalize_web_path target_image, (asset_dir_key ? (doc.attr asset_dir_key) : nil)
  end
end

def initialize parent, context, opts = {}
  # document is a special case, should refer to itself
  if context == :document
    @document = self
  elsif parent
    @document = (@parent = parent).document
  end
  @node_name = (@context = context).to_s
  # NOTE the value of the :attributes option may be nil on an Inline node
  @attributes = (attrs = opts[:attributes]) ? attrs.merge : {}
  @passthroughs = []
end

def inline?
  # :nocov:
  raise ::NotImplementedError
  # :nocov:
end

def is_uri? str
  Helpers.uriish? str
end

def media_uri(target, asset_dir_key = 'imagesdir')
  normalize_web_path target, (asset_dir_key ? @document.attr(asset_dir_key) : nil)
end

def normalize_asset_path(asset_ref, asset_name = 'path', autocorrect = true)
  normalize_system_path(asset_ref, @document.base_dir, nil, target_name: asset_name, recover: autocorrect)
end

def normalize_system_path target, start = nil, jail = nil, opts = {}
  if (doc = @document).safe < SafeMode::SAFE
    if start
      start = ::File.join doc.base_dir, start unless doc.path_resolver.root? start
    else
      start = doc.base_dir
    end
  else
    start = doc.base_dir unless start
    jail = doc.base_dir unless jail
  end
  doc.path_resolver.system_path target, start, jail, opts
end

def normalize_web_path(target, start = nil, preserve_uri_target = true)
  if preserve_uri_target && (Helpers.uriish? target)
    Helpers.encode_uri target
  else
    @document.path_resolver.web_path target, start
  end
end

def option? name
  @attributes[%(#{name}-option)] ? true : false
end

def options
  ::Set.new.tap {|accum| @attributes.each_key {|k| accum << (k.slice 0, k.length - 7) if k.to_s.end_with? '-option' } }
end

def parent= parent
  @parent, @document = parent, parent.document
end

def read_asset path, opts = {}
  # remap opts for backwards compatibility
  opts = { warn_on_failure: (opts != false) } unless ::Hash === opts
  if ::File.readable? path
    # QUESTION should we chomp content if normalize is false?
    opts[:normalize] ? ((Helpers.prepare_source_string ::File.read path, mode: FILE_READ_MODE).join LF) : (::File.read path, mode: FILE_READ_MODE)
  elsif opts[:warn_on_failure]
    logger.warn %(#{(attr 'docfile') || '<stdin>'}: #{opts[:label] || 'file'} does not exist or cannot be read: #{path})
    nil
  end
end

def read_contents target, opts = {}
  doc = @document
  if (Helpers.uriish? target) || ((start = opts[:start]) && (Helpers.uriish? start) &&
      (target = doc.path_resolver.web_path target, start))
    if doc.attr? 'allow-uri-read'
      Helpers.require_library 'open-uri/cached', 'open-uri-cached' if doc.attr? 'cache-uri'
      begin
        if opts[:normalize]
          (Helpers.prepare_source_string ::OpenURI.open_uri(target, URI_READ_MODE) {|f| f.read }).join LF
        else
          ::OpenURI.open_uri(target, URI_READ_MODE) {|f| f.read }
        end
      rescue
        logger.warn %(could not retrieve contents of #{opts[:label] || 'asset'} at URI: #{target}) if opts.fetch :warn_on_failure, true
        return
      end
    else
      logger.warn %(cannot retrieve contents of #{opts[:label] || 'asset'} at URI: #{target} (allow-uri-read attribute not enabled)) if opts.fetch :warn_on_failure, true
      return
    end
  else
    target = normalize_system_path target, opts[:start], nil, target_name: (opts[:label] || 'asset')
    read_asset target, normalize: opts[:normalize], warn_on_failure: (opts.fetch :warn_on_failure, true), label: opts[:label]
  end
end

def reftext
  (val = @attributes['reftext']) ? (apply_reftext_subs val) : nil
end

def reftext?
  @attributes.key? 'reftext'
end

def remove_attr name
  @attributes.delete name
end

def remove_role name
  if (val = @attributes['role']) && ((val = val.split).delete name)
    if val.empty?
      @attributes.delete 'role'
    else
      @attributes['role'] = val.join ' '
    end
    true
  else
    false
  end
end

def role
  @attributes['role']
end

def role? expected_value = nil
  expected_value ? expected_value == @attributes['role'] : (@attributes.key? 'role')
end

def roles
  (val = @attributes['role']) ? val.split : []
end

def set_attr name, value = '', overwrite = true
  if overwrite == false && (@attributes.key? name)
    false
  else
    @attributes[name] = value
    true
  end
end

def set_option name
  @attributes[%(#{name}-option)] = ''
  nil
end

def update_attributes new_attributes
  @attributes.update new_attributes
end