class Webgen::PathHandler

# File lib/webgen/path_handler.rb, line 133
def initialize(website)
  super()
  @website = website
  @current_dest_node = nil
  @invocation_order = []
  @instances = {}
  @secondary_nodes = {}

  @website.blackboard.add_listener(:website_generated, 'path_handler') do
    @website.cache[:path_handler_secondary_nodes] = @secondary_nodes
  end

  used_secondary_paths = {}
  written_nodes = Set.new
  @website.blackboard.add_listener(:before_secondary_nodes_created, 'path_handler') do |path, source_alcn|
    (used_secondary_paths[source_alcn] ||= Set.new) << path if source_alcn
  end
  @website.blackboard.add_listener(:before_all_nodes_written, 'path_handler') do |node|
    used_secondary_paths = {}
    written_nodes = Set.new
  end
  @website.blackboard.add_listener(:after_node_written, 'path_handler') do |node|
    written_nodes << node.alcn
  end
  @website.blackboard.add_listener(:after_all_nodes_written, 'path_handler') do
    @secondary_nodes.delete_if do |path, data|
      if written_nodes.include?(data[1]) && (!used_secondary_paths[data[1]] ||
                                             !used_secondary_paths[data[1]].include?(path))
        data[2].each {|alcn| @website.tree.delete_node(@website.tree[alcn])}
        true
      end
    end
  end
end

# File lib/webgen/path_handler.rb, line 341
def create_secondary_nodes(path, content = '', source_alcn = nil)
  if (sn = @secondary_nodes[path]) && sn[1] != source_alcn
    raise Webgen::NodeCreationError.new("Duplicate secondary path name <#{path}>", 'path_handler', path)
  end
  @website.blackboard.dispatch_msg(:before_secondary_nodes_created, path, source_alcn)

  path['modified_at'] ||= @website.tree[source_alcn]['modified_at'] if source_alcn
  path.set_io { StringIO.new(content) }

  nodes = if path['handler']
            @website.blackboard.dispatch_msg(:apply_meta_info_to_path, path)
            create_nodes_with_path_handler(path, path['handler'])
          else
            create_nodes([path])
          end
  @website.blackboard.dispatch_msg(:after_secondary_nodes_created, path, nodes)

  if source_alcn
    path.set_io(&nil)
    _, _, stored_alcns = @secondary_nodes.delete(path)
    cur_alcns = nodes.map {|n| n.alcn}
    (stored_alcns - cur_alcns).each {|n| @website.tree.delete_node(@website.tree[n])} if stored_alcns
    @secondary_nodes[path.dup] = [content, source_alcn, cur_alcns]
  end

  nodes
end

# File lib/webgen/path_handler.rb, line 212
def instance(handler)
  @instances[handler.intern] ||= extension(handler).new(@website)
end

# File lib/webgen/path_handler.rb, line 226
def populate_tree
  raise Webgen::NodeCreationError.new("Can't populate tree twice", 'path_handler') if @website.tree.root

  time = Benchmark.measure do
    meta_info, rest = @website.ext.source.paths.partition {|path| path.path =~ /[\/.]metainfo$/}

    used_paths = []

    @website.blackboard.add_listener(:before_node_created, 'path_handler (temp_populate_tree)') do |path|
      used_paths << path
    end
    create_nodes(meta_info, [:meta_info])
    create_nodes(rest)
    @website.blackboard.remove_listener(:before_node_created, 'path_handler (temp_populate_tree)')

    unused_paths = rest - used_paths
    @website.logger.vinfo do
      "The following source paths have not been used: #{unused_paths.join(', ')}"
    end if unused_paths.length > 0

    (@website.cache[:path_handler_secondary_nodes] || {}).each do |path, (content, source_alcn, _)|
      next if !@website.tree[source_alcn]
      create_secondary_nodes(path, content, source_alcn)
    end
  end
  @website.logger.vinfo do
    "Populating node tree took " << ('%2.2f' % time.real) << ' seconds'
  end

  @website.blackboard.dispatch_msg(:after_tree_populated)
end

# File lib/webgen/path_handler.rb, line 197
def register(klass, options={}, &block)
  name = do_register(klass, options, false, &block)
  ext_data(name).patterns = options[:patterns] || []
  pos = if options[:insert_at].nil? || options[:insert_at] == :end
          -1
        elsif options[:insert_at] == :front
          0
        else
          options[:insert_at].to_i
        end
  @invocation_order.delete(name)
  @invocation_order.insert(pos, name)
end

# File lib/webgen/path_handler.rb, line 262
def write_tree
  passes = 0
  content = nil

  begin
    at_least_one_node_written = false
    @website.cache.reset_volatile_cache
    @website.blackboard.dispatch_msg(:before_all_nodes_written)
    @website.tree.node_access[:alcn].sort_by {|a, n| [n['write_order'].to_s, a]}.each do |name, node|
      begin
        next if node == @website.tree.dummy_root ||
          (node['passive'] && !node['no_output'] && !@website.ext.item_tracker.node_referenced?(node)) ||
          ((@website.config['website.dry_run'] || node['no_output'] || @website.ext.destination.exists?(node.dest_path)) &&
           !@website.ext.item_tracker.node_changed?(node))

        @website.blackboard.dispatch_msg(:before_node_written, node)
        if !node['no_output']
          content = write_node(node)
          at_least_one_node_written = true
        end
        @website.blackboard.dispatch_msg(:after_node_written, node, content)
      rescue Webgen::Error => e
        e.path = node.alcn if e.path.to_s.empty?
        e.location = "path_handler.#{name_of_instance(node.node_info[:path_handler])}" unless e.location
        raise
      rescue Exception => e
        raise Webgen::RenderError.new(e, "path_handler.#{name_of_instance(node.node_info[:path_handler])}", node)
      end
    end
    @website.blackboard.dispatch_msg(:after_all_nodes_written)
    passes += 1 if at_least_one_node_written
  end while at_least_one_node_written

  @website.blackboard.dispatch_msg(:website_generated)
  passes
end

# File lib/webgen/path_handler.rb, line 318
def create_nodes(paths, handlers = @invocation_order)
  nodes = []
  paths.each {|path| @website.blackboard.dispatch_msg(:apply_meta_info_to_path, path)}
  handlers.each do |name|
    paths_for_handler(name.to_s, paths).each do |path|
      nodes += create_nodes_with_path_handler(path, name)
    end
  end
  nodes
end

# File lib/webgen/path_handler.rb, line 388
def create_nodes_with_path_handler(path, handler) #:yields: path
  *data = instance(handler).parse_meta_info!(path)

  (path.meta_info.delete('versions') || {'default' => {}}).map do |name, mi|
    vpath = path.dup
    (mi ||= {})['version'] ||= name
    vpath.meta_info.merge!(mi)
    @website.logger.debug do
      "Creating node version '#{vpath['version']}' from path <#{vpath}> with #{handler} handler"
    end
    @website.blackboard.dispatch_msg(:before_node_created, vpath)
    instance(handler).create_nodes(vpath, *data)
  end.flatten.compact.each do |node|
    @website.blackboard.dispatch_msg(:after_node_created, node)
  end
rescue Webgen::Error => e
  e.path = path.to_s if e.path.to_s.empty?
  e.location = "path_handler.#{handler}" unless e.location
  raise
rescue Exception => e
  raise Webgen::NodeCreationError.new(e, "path_handler.#{handler}", path)
end

# File lib/webgen/path_handler.rb, line 217
def name_of_instance(instance)
  @instances.rassoc(instance)[0] || 'unknown'
end

# File lib/webgen/path_handler.rb, line 370
def paths_for_handler(name, paths)
  patterns = ext_data(name).patterns || []

  options = (@website.config['path_handler.patterns.case_sensitive'] ? 0 : File::FNM_CASEFOLD) |
    (@website.config['path_handler.patterns.match_leading_dot'] ? File::FNM_DOTMATCH : 0) |
    File::FNM_PATHNAME

  paths.select do |path|
    path.meta_info['handler'] == name ||
      patterns.any? {|pat| Webgen::Path.matches_pattern?(path, pat, options)}
  end.sort {|a,b| a.path <=> b.path}
end

# File lib/webgen/path_handler.rb, line 300
def write_node(node)
  @current_dest_node = node
  @website.logger.info do
    "[#{(@website.ext.destination.exists?(node.dest_path) ? 'update' : 'create')}] <#{node.dest_path}>"
  end
  content = nil
  time = Benchmark.measure { content = node.content }
  @website.ext.destination.write(node.dest_path, content)
  @website.logger.vinfo do
    "[timing] <#{node.dest_path}> rendered in " << ('%2.2f' % time.real) << ' seconds'
  end
  content
ensure
  @current_dest_node = nil
end