class Kramdown::Converter::Base

def self.apply_template(converter, body) # :nodoc:
  erb = ERB.new(get_template(converter.options[:template]))
  obj = Object.new
  obj.instance_variable_set(:@converter, converter)
  obj.instance_variable_set(:@body, body)
  erb.result(obj.instance_eval { binding })
end

def self.convert(tree, options = {})
  converter = new(tree, ::Kramdown::Options.merge(options.merge(tree.options[:options] || {})))
  if !converter.options[:template].empty? && converter.apply_template_before?
    apply_template(converter, '')
  end
  result = converter.convert(tree)
  if result.respond_to?(:encode!) && result.encoding != Encoding::BINARY
    result.encode!(tree.options[:encoding] ||
                   (raise ::Kramdown::Error, "Missing encoding option on root element"))
  end
  if !converter.options[:template].empty? && converter.apply_template_after?
    result = apply_template(converter, result)
  end
  [result, converter.warnings]
end

def self.get_template(template) # :nodoc:
  format_ext = '.' + ::Kramdown::Utils.snake_case(name.split("::").last)
  shipped = File.join(::Kramdown.data_dir, template + format_ext)
  if File.exist?(template)
    File.read(template)
  elsif File.exist?(template + format_ext)
    File.read(template + format_ext)
  elsif File.exist?(shipped)
    File.read(shipped)
  elsif template.start_with?('string://')
    template.delete_prefix("string://")
  else
    raise "The specified template file #{template} does not exist"
  end
end

def apply_template_after?
  true
end

def apply_template_before?
  false
end

def basic_generate_id(str)
  gen_id = str.gsub(/^[^a-zA-Z]+/, '')
  gen_id.tr!('^a-zA-Z0-9 -', '')
  gen_id.tr!(' ', '-')
  gen_id.downcase!
  gen_id
end

def convert(_el)
  raise NotImplementedError
end

def extract_code_language(attr)
  if attr['class'] && attr['class'] =~ /\blanguage-\S+/
    attr['class'].scan(/\blanguage-(\S+)/).first.first
  end
end

def extract_code_language!(attr)
  lang = extract_code_language(attr)
  attr['class'] = attr['class'].sub(/\blanguage-\S+/, '').strip if lang
  attr.delete('class') if lang && attr['class'].empty?
  lang
end

def format_math(el, opts = {})
  return nil unless @options[:math_engine]
  engine = ::Kramdown::Converter.math_engine(@options[:math_engine])
  if engine
    engine.call(self, el, opts)
  else
    warning("The configured math engine #{@options[:math_engine]} is not available.")
    nil
  end
end

def generate_id(str)
  str = ::Kramdown::Utils::Unidecoder.decode(str) if @options[:transliterated_header_ids]
  gen_id = basic_generate_id(str)
  gen_id = 'section' if gen_id.empty?
  @used_ids ||= {}
  if @used_ids.key?(gen_id)
    gen_id += "-#{@used_ids[gen_id] += 1}"
  else
    @used_ids[gen_id] = 0
  end
  @options[:auto_id_prefix] + gen_id
end

def highlight_code(text, lang, type, opts = {})
  return nil unless @options[:syntax_highlighter]
  highlighter = ::Kramdown::Converter.syntax_highlighter(@options[:syntax_highlighter])
  if highlighter
    highlighter.call(self, text, lang, type, opts)
  else
    warning("The configured syntax highlighter #{@options[:syntax_highlighter]} is not available.")
    nil
  end
end

def in_toc?(el)
  @options[:toc_levels].include?(el.options[:level]) && (el.attr['class'] || '') !~ /\bno_toc\b/
end

def initialize(root, options)
  @options = options
  @root = root
  @data = {}
  @warnings = []
end

def output_header_level(level)
  [[level + @options[:header_offset], 6].min, 1].max
end

def smart_quote_entity(el)
  res = @options[:smart_quotes][SMART_QUOTE_INDICES[el.value]]
  ::Kramdown::Utils::Entities.entity(res)
end

def warning(text)
  @warnings << text
end