class Middleman::Sitemap::Store

def ensure_resource_list_updated!
  @lock.synchronize do
    return unless @needs_sitemap_rebuild
    @needs_sitemap_rebuild = false
    @app.logger.debug "== Rebuilding resource list"
    @resources = @resource_list_manipulators.inject([]) do |result, (_, inst)|
      newres = inst.manipulate_resource_list(result)
      # Reset lookup cache
      reset_lookup_cache!
      newres.each do |resource|
        @_lookup_by_path[resource.path] = resource
        @_lookup_by_destination_path[resource.destination_path] = resource
      end
      newres
    end
  end
end

def extensionless_path(file)
  path = file.dup
  path = remove_templating_extensions(path)
  # If there is no extension, look for one
  path = find_extension(path, file) if File.extname(strip_away_locale(path)).empty?
  path
end

def file_to_path(file)
  file = File.join(@app.root, file)
  prefix = @app.source_dir.sub(/\/$/, "") + "/"
  return false unless file.start_with?(prefix)
  path = file.sub(prefix, "")
  # Replace a file name containing automatic_directory_matcher with a folder
  unless @app.config[:automatic_directory_matcher].nil?
    path = path.gsub(@app.config[:automatic_directory_matcher], "/")
  end
  extensionless_path(path)
end

def find_extension(path, file)
  input_ext = File.extname(file)
  if !input_ext.empty?
    input_ext = input_ext.split(".").last.to_sym
    if @app.template_extensions.has_key?(input_ext)
      path << ".#{@app.template_extensions[input_ext]}"
    end
  end
  path
end

def find_resource_by_destination_path(request_path)
  @lock.synchronize do
    request_path = ::Middleman::Util.normalize_path(request_path)
    ensure_resource_list_updated!
    @_lookup_by_destination_path[request_path]
  end
end

def find_resource_by_path(request_path)
  @lock.synchronize do
    request_path = ::Middleman::Util.normalize_path(request_path)
    ensure_resource_list_updated!
    @_lookup_by_path[request_path]
  end
end

def initialize(app)
  @app   = app
  @resources = []
  @_cached_metadata = {}
  @resource_list_manipulators = []
  @needs_sitemap_rebuild = true
  @lock = Monitor.new
  reset_lookup_cache!
  # Register classes which can manipulate the main site map list
  register_resource_list_manipulator(:on_disk, Middleman::Sitemap::Extensions::OnDisk.new(self))
  # Proxies
  register_resource_list_manipulator(:proxies, @app.proxy_manager)
end

def metadata_for_file(source_file)
  blank_metadata = { :options => {}, :locals => {}, :page => {}, :blocks => [] }
  provides_metadata.inject(blank_metadata) do |result, (callback, matcher)|
    next result if matcher && !source_file.match(matcher)
    metadata = callback.call(source_file).dup
    if metadata.has_key?(:blocks)
      result[:blocks] << metadata[:blocks]
      metadata.delete(:blocks)
    end
    result.deep_merge(metadata)
  end
end

def metadata_for_path(request_path)
  return @_cached_metadata[request_path] if @_cached_metadata[request_path]
  blank_metadata = { :options => {}, :locals => {}, :page => {}, :blocks => [] }
  @_cached_metadata[request_path] = provides_metadata_for_path.inject(blank_metadata) do |result, (callback, matcher)|
    case matcher
    when Regexp
      next result unless request_path =~ matcher
    when String
      next result unless File.fnmatch("/" + Util.strip_leading_slash(matcher), "/#{request_path}")
    end
    metadata = callback.call(request_path).dup
    result[:blocks] += Array(metadata.delete(:blocks))
    result.deep_merge(metadata)
  end
end

def provides_metadata(matcher=nil, &block)
  @_provides_metadata ||= []
  @_provides_metadata << [block, matcher] if block_given?
  @_provides_metadata
end

def provides_metadata_for_path(matcher=nil, &block)
  @_provides_metadata_for_path ||= []
  if block_given?
    @_provides_metadata_for_path << [block, matcher]
    @_cached_metadata = {}
  end
  @_provides_metadata_for_path
end

def rebuild_resource_list!(reason=nil)
  @lock.synchronize do
    @needs_sitemap_rebuild = true
  end
end

def register_resource_list_manipulator(name, inst, unused=true)
  @resource_list_manipulators << [name, inst]
  rebuild_resource_list!(:registered_new)
end

def remove_templating_extensions(path)
  # Strip templating extensions as long as Tilt knows them
  path = path.sub(File.extname(path), "") while ::Tilt[path]
  path
end

def reset_lookup_cache!
  @lock.synchronize {
    @_lookup_by_path = {}
    @_lookup_by_destination_path = {}
  }
end

def resources(include_ignored=false)
  @lock.synchronize do
    ensure_resource_list_updated!
    if include_ignored
      @resources
    else
      @resources.reject(&:ignored?)
    end
  end
end

def strip_away_locale(path)
  if app.respond_to? :langs
    path_bits = path.split('.')
    lang = path_bits.last
    if app.langs.include?(lang.to_sym)
      return path_bits[0..-1].join('.')
    end
  end
  path
end