class Middleman::CoreExtensions::DefaultHelpers

def asset_path(kind, source)
  return source if source.to_s.include?('//') || source.to_s.start_with?('data:')
  asset_folder  = case kind
    when :css    then css_dir
    when :js     then js_dir
    when :images then images_dir
    when :fonts  then fonts_dir
    else kind.to_s
  end
  source = source.to_s.tr(' ', '')
  ignore_extension = (kind == :images || kind == :fonts) # don't append extension
  source << ".#{kind}" unless ignore_extension || source.end_with?(".#{kind}")
  asset_folder = '' if source.start_with?('/') # absolute path
  asset_url(source, asset_folder)
end

def asset_stamp
  false
end

def asset_url(path, prefix='')
  # Don't touch assets which already have a full path
  if path.include?('//') or path.start_with?('data:')
    path
  else # rewrite paths to use their destination path
    if resource = sitemap.find_resource_by_destination_path(url_for(path))
      resource.url
    else
      path = File.join(prefix, path)
      if resource = sitemap.find_resource_by_path(path)
        resource.url
      else
        File.join(config[:http_prefix], path)
      end
    end
  end
end

def auto_find_proper_handler(&block)
  engine = block_given? ? File.extname(block.source_location[0])[1..-1].to_sym : current_engine
  return if engine == :slim && engine == current_engine
  handler_class = ::Padrino::Helpers::OutputHelpers.handlers[engine]
  handler_class && handler_class.new(self)
end

def auto_javascript_include_tag
  auto_tag(:js) do |path|
    javascript_include_tag path
  end
end

def auto_stylesheet_link_tag
  auto_tag(:css) do |path|
    stylesheet_link_tag path
  end
end

def auto_tag(asset_ext, asset_dir=nil)
  if asset_dir.nil?
    asset_dir = case asset_ext
      when :js  then js_dir
      when :css then css_dir
    end
  end
  # If the basename of the request as no extension, assume we are serving a
  # directory and join index_file to the path.
  path = File.join(asset_dir, current_path)
  path = path.sub(/#{Regexp.escape(File.extname(path))}$/, ".#{asset_ext}")
  yield path if sitemap.find_resource_by_path(path)
end

def capture_html(*args, &block)
  result = if handler = auto_find_proper_handler(&block)
    handler.capture_from_template(*args, &block)
  else
    block.call(*args)
  end
  ActiveSupport::SafeBuffer.new.safe_concat(result)
end

def content_tag(name, content = nil, options = nil, &block)
  if block_given?
    options = content if content.is_a?(Hash)
    content = capture_html(&block)
  end
  options    = parse_data_options(name, options)
  attributes = tag_attributes(options)
  output = ActiveSupport::SafeBuffer.new
  output.safe_concat "<#{name}#{attributes}>"
  if content.respond_to?(:each) && !content.is_a?(String)
    content.each { |c| output.safe_concat c; output.safe_concat ::Padrino::Helpers::TagHelpers::NEWLINE }
  else
    output.safe_concat "#{content}"
  end
  output.safe_concat "</#{name}>"
  block_is_template?(block) ? concat_content(output) : output
end

def form_tag(url, options={}, &block)
  url = url_for(url, options)
  super
end

def initialize(app, options_hash={}, &block)
  super
  require 'active_support/core_ext/object/to_query'
  app.helpers ::Padrino::Helpers::OutputHelpers
  app.helpers ::Padrino::Helpers::TagHelpers
  app.helpers ::Padrino::Helpers::AssetTagHelpers
  app.helpers ::Padrino::Helpers::FormHelpers
  app.helpers ::Padrino::Helpers::FormatHelpers
  app.helpers ::Padrino::Helpers::RenderHelpers
  app.helpers ::Padrino::Helpers::NumberHelpers
  # app.helpers ::Padrino::Helpers::TranslationHelpers
  app.helpers ::Padrino::Helpers::Breadcrumbs
  app.config.define_setting :relative_links, false, 'Whether to generate relative links instead of absolute ones'
end

def link_to(*args, &block)
  url_arg_index = block_given? ? 0 : 1
  options_index = block_given? ? 1 : 2
  if block_given? && args.size > 2
    raise ArgumentError.new('Too many arguments to link_to(url, options={}, &block)')
  end
  if url = args[url_arg_index]
    options = args[options_index] || {}
    raise ArgumentError.new('Options must be a hash') unless options.is_a?(Hash)
    # Transform the url through our magic url_for method
    args[url_arg_index] = url_for(url, options)
    # Cleanup before passing to Padrino
    options.delete(:relative)
    options.delete(:current_resource)
    options.delete(:find_resource)
    options.delete(:query)
    options.delete(:anchor)
    options.delete(:fragment)
  end
  super(*args, &block)
end

def page_classes(path = current_path.dup, options={})
  if path.is_a? Hash
    options = path
    path = current_path.dup
  end
  path << index_file if path.end_with?('/')
  path = ::Middleman::Util.strip_leading_slash(path)
  classes = []
  parts = path.split('.').first.split('/')
  parts.each_with_index { |_, i| classes << parts.first(i+1).join('_') }
  prefix = options[:numeric_prefix] || 'x'
  classes.map do |c|
    # Replace weird class name characters
    c = c.gsub(/[^a-zA-Z0-9\-_]/, '-')
    # Class names can't start with a digit
    c = "#{prefix}#{c}" if c =~ /\A\d/
    c
  end.join(' ')
end

def url_for(path_or_resource, options={})
  options_with_resource = options.dup
  options_with_resource[:current_resource] ||= current_resource
  ::Middleman::Util.url_for(self, path_or_resource, options_with_resource)
end