module Padrino::Helpers::OutputHelpers

def self.handlers
  @_template_handlers ||= []
end

def self.included(base) # @private
  base.send(:include, SinatraCurrentEngine) unless base.method_defined?(:current_engine)
end

def self.register(handler)
  handlers << handler
end

def block_is_template?(block)
  handler = find_proper_handler
  block && handler && handler.block_is_type?(block)
end

def capture_html(*args, &block)
  handler = find_proper_handler
  captured_block, captured_html = nil, ""
  if handler && handler.is_type? && handler.block_is_type?(block)
    captured_html, captured_block = handler.capture_from_template(*args, &block)
  end
  # invoking the block directly if there was no template
  captured_html = block_given? && ( captured_block || block.call(*args) )  if captured_html.blank?
  captured_html
end

def concat_content(text="")
  handler = find_proper_handler
  if handler && handler.is_type?
    handler.concat_to_template(text)
  else # theres no template to concat, return the text directly
    text
  end
end

def concat_safe_content(text="")
  concat_content text.html_safe
end

def content_blocks
  @content_blocks ||= Hash.new { |h,k| h[k] = [] }
end

def content_for(key, content = nil, &block)
  content_blocks[key.to_sym] << (block_given? ? block : Proc.new { content })
end

def content_for?(key)
  content_blocks[key.to_sym].present?
end

def find_proper_handler
  OutputHelpers.handlers.map { |h| h.new(self) }.find { |h| h.engines.include?(current_engine) && h.is_type? }
end

def mark_safe(value)
  if value.respond_to? :map!
    value.map!{|v| v.html_safe if v }
  else
    value.html_safe if value
  end
end

def yield_content(key, *args)
  blocks = content_blocks[key.to_sym]
  return nil if blocks.empty?
  mark_safe(blocks.map { |content| capture_html(*args, &content) }.join)
end