class RDoc::Generator::SDoc

def self.setup_options(options)
  opt = options.option_parser
  opt.separator nil
  opt.separator "SDoc generator options:"
  opt.separator nil
  opt.on("--github", "-g",
          "Generate links to github.") do |value|
    options.github = true
  end
  opt.separator nil
  opt.on("--version", "-v", "Output current version") do
    puts SDoc::VERSION
    exit
  end
  if options.respond_to?(:class_module_path_prefix)
    options.class_module_path_prefix = CLASS_DIR
  end
  if options.respond_to?(:file_path_prefix)
    options.file_path_prefix = FILE_DIR
  end
end

def class_dir
  CLASS_DIR
end

def copy_resources
  resources_path = @template_dir + RESOURCES_DIR
  debug_msg "Copying #{resources_path}/** to #{@outputdir}/**"
  FileUtils.cp_r resources_path.to_s, @outputdir.to_s unless @options.dry_run
end

def debug_msg( *msg )
  return unless $DEBUG_RDOC
  $stderr.puts( *msg )
end

def file_dir
  FILE_DIR
end

def generate
  @outputdir = Pathname.new(@options.op_dir).expand_path(@base_dir)
  @files = @store.all_files.sort
  @classes = @store.all_classes_and_modules.sort
  # Now actually write the output
  copy_resources
  @json_index.generate
  @json_index.generate_gzipped
  generate_search_index
  generate_class_tree
  generate_index_file
  generate_file_files
  generate_class_files
end

def generate_class_files
  debug_msg "Generating class documentation in #@outputdir"
  templatefile = @template_dir + 'class.rhtml'
  @classes.each do |klass|
    debug_msg "  working on %s (%s)" % [ klass.full_name, klass.path ]
    outfile     = @outputdir + klass.path
    rel_prefix = rel_prefix  = @outputdir.relative_path_from( outfile.dirname )
    debug_msg "  rendering #{outfile}"
    self.render_template( templatefile, binding(), outfile ) unless @options.dry_run
  end
end

def generate_class_tree
  debug_msg "Generating class tree"
  topclasses = @classes.select {|klass| !(RDoc::ClassModule === klass.parent) }
  tree = generate_file_tree + generate_class_tree_level(topclasses)
  debug_msg "  writing class tree to %s" % TREE_FILE
  File.open(TREE_FILE, "w", 0644) do |f|
    f.write('var tree = '); f.write(tree.to_json(:max_nesting => 0))
  end unless @options.dry_run
end

def generate_class_tree_level(classes, visited = {})
  tree = []
  classes.select do |klass|
    !visited[klass] && klass.with_documentation?
  end.sort.each do |klass|
    visited[klass] = true
    item = [
      klass.name,
      klass.document_self_or_methods ? klass.path : '',
      klass.module? ? '' : (klass.superclass ? " < #{String === klass.superclass ? klass.superclass : klass.superclass.full_name}" : ''),
      generate_class_tree_level(klass.classes_and_modules, visited)
    ]
    tree << item
  end
  tree
end

def generate_file_files
  debug_msg "Generating file documentation in #@outputdir"
  templatefile = @template_dir + 'file.rhtml'
  @files.each do |file|
    outfile     = @outputdir + file.path
    debug_msg "  working on %s (%s)" % [ file.full_name, outfile ]
    rel_prefix = rel_prefix  = @outputdir.relative_path_from( outfile.dirname )
    debug_msg "  rendering #{outfile}"
    self.render_template( templatefile, binding(), outfile ) unless @options.dry_run
  end
end

def generate_file_tree
  if @files.length > 1
    @files_tree = FilesTree.new
    @files.each do |file|
      @files_tree.add(file.relative_name, file.path)
    end
    [['', '', 'files', generate_file_tree_level(@files_tree)]]
  else
    []
  end
end

def generate_file_tree_level(tree)
  tree.children.keys.sort.map do |name|
    child = tree.children[name]
    if String === child
      [name, child, '', []]
    else
      ['', '', name, generate_file_tree_level(child)]
    end
  end
end

def generate_index_file
  debug_msg "Generating index file in #@outputdir"
  templatefile = @template_dir + 'index.rhtml'
  outfile      = @outputdir + 'index.html'
  rel_prefix = rel_prefix  = @outputdir.relative_path_from( outfile.dirname )
  self.render_template( templatefile, binding(), outfile ) unless @options.dry_run
end

def generate_search_index
  debug_msg "Generating search engine index in #@outputdir"
  templatefile = @template_dir + 'search_index.rhtml'
  outfile      = @outputdir + 'panel/links.html'
  self.render_template( templatefile, binding(), outfile ) unless @options.dry_run
end

def index
  # Break early to avoid a big if block when no main page is specified
  default = @files.first
  return default unless @options.main_page
  if file = @files.find { |f| f.full_name == @options.main_page }
    file
  else
    default
  end
end

def index_path
  main_page = @options.main_page
  # Transform class name to file path
  if main_page && main_page.include?("::")
    slashed = main_page.sub(/^::/, "").gsub("::", "/")
    "%s/%s.html" % [ class_dir, slashed ]
  else
    index.path
  end
end

def initialize(store, options)
  @store   = store
  @options = options
  if @options.respond_to?('diagram=')
    @options.diagram = false
  end
  @options.pipe = true
  @github_url_cache = {}
  @template_dir = Pathname.new(options.template_dir)
  @base_dir = Pathname.pwd.expand_path
  @json_index = RDoc::Generator::JsonIndex.new self, options
end