class Asciidoctor::AbstractNode

def attr(name, default = nil, inherit = true)
  name = name.to_s if name.is_a?(Symbol)
  inherit = false if self == @document
  if !inherit
    default.nil? ? @attributes[name] : @attributes.fetch(name, default)
  else
    default.nil? ? @attributes.fetch(name, @document.attr(name)) :
        @attributes.fetch(name, @document.attr(name, default))
  end
end

def attr?(name, expect = nil, inherit = true)
  name = name.to_s if name.is_a?(Symbol)
  inherit = false if self == @document
  if expect.nil?
    if @attributes.has_key? name
      true
    elsif inherit
      @document.attributes.has_key? name
    else
      false
    end
  else
    if @attributes.has_key? name
      @attributes[name] == expect
    elsif inherit && @document.attributes.has_key?(name)
      @document.attributes[name] == expect
    else
      false
    end
  end
end

def generate_data_uri(target_image, asset_dir_key = nil)
  Helpers.require_library 'base64'
  ext = File.extname(target_image)[1..-1]
  mimetype = 'image/' + ext
  mimetype = "#{mimetype}+xml" if ext == 'svg'
  if asset_dir_key
    #asset_dir_path = normalize_system_path(@document.attr(asset_dir_key), nil, nil, :target_name => asset_dir_key)
    #image_path = normalize_system_path(target_image, asset_dir_path, nil, :target_name => 'image')
    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
    puts "asciidoctor: WARNING: image to embed not found or not readable: #{image_path}"
    return "data:#{mimetype}:base64,"
    #return 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=='
  end
  bindata = nil
  if IO.respond_to? :binread
    bindata = IO.binread(image_path)
  else
    bindata = File.open(image_path, 'rb') {|file| file.read }
  end
  "data:#{mimetype};base64,#{Base64.encode64(bindata).delete("\n")}"
end

def get_binding template
  binding
end

def icon_uri(name)
  if attr? 'icon'
    image_uri(attr('icon'), nil)
  else
    image_uri("#{name}.#{@document.attr('icontype', 'png')}", 'iconsdir')
  end
end

def image_uri(target_image, asset_dir_key = 'imagesdir')
  if target_image.include?(':') && target_image.match(Asciidoctor::REGEXP[:uri_sniff])
    target_image
  elsif @document.safe < Asciidoctor::SafeMode::SECURE && @document.attr?('data-uri')
    generate_data_uri(target_image, asset_dir_key)
  elsif asset_dir_key && attr?(asset_dir_key)
    normalize_web_path(target_image, @document.attr(asset_dir_key))
  else
    normalize_web_path(target_image)
  end
end

def initialize(parent, context)
  @parent = (context != :document ? parent : nil)
  if !parent.nil?
    @document = parent.is_a?(Document) ? parent : parent.document
  else
    @document = nil
  end
  
  @context = context
  @attributes = {}
  @passthroughs = []
end

def media_uri(target, asset_dir_key = 'imagesdir')
  if target.include?(':') && target.match(Asciidoctor::REGEXP[:uri_sniff])
    target
  elsif asset_dir_key && attr?(asset_dir_key)
    normalize_web_path(target, @document.attr(asset_dir_key))
  else
    normalize_web_path(target)
  end
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 start.nil?
    start = @document.base_dir
  end
  if jail.nil? && @document.safe >= SafeMode::SAFE
    jail = @document.base_dir
  end
  PathResolver.new.system_path(target, start, jail, opts)
end

def normalize_web_path(target, start = nil)
  PathResolver.new.web_path(target, start)
end

def read_asset(path, warn_on_failure = false)
  if File.readable? path
    File.read(path).chomp
  else
    puts "asciidoctor: WARNING: file does not exist or cannot be read: #{path}" if warn_on_failure
    nil
  end
end

def renderer
  @document.renderer
end

def set_attr(key, val, overwrite = nil)
  if overwrite.nil?
    @attributes[key] = val
    true
  else
    if overwrite || @attributes.has_key?(key)
      @attributes[key] = val
      true
    else
      false
    end
  end
end

def update_attributes(attributes)
  @attributes.update(attributes)
  nil
end