class RDoc::Generator::Darkfish

def self::for( options )
	new( options )
end

def class_dir
	CLASS_DIR
end

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

def file_dir
	FILE_DIR
end

def gen_sub_directories
	@outputdir.mkpath
end

def generate( top_levels )
	@outputdir = Pathname.new( @options.op_dir ).expand_path( @basedir )
	@files = top_levels.sort
	@classes = RDoc::TopLevel.all_classes_and_modules.sort
	@methods = @classes.map { |m| m.method_list }.flatten.sort
	@modsort = get_sorted_module_list( @classes )
	# Now actually write the output
	write_style_sheet
	generate_index
	generate_class_files
	generate_file_files
rescue StandardError => err
	debug_msg "%s: %s\n  %s" % [ err.class.name, err.message, err.backtrace.join("\n  ") ]
	raise
end

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

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

def generate_index
	template_file = @template_dir + 'index.rhtml'
	return unless template_file.exist?
	debug_msg "Rendering the index page..."
	template_src = template_file.read
	template = ERB.new( template_src, nil, '<>' )
	template.filename = template_file.to_s
	context = binding()
	output = nil
	begin
		output = template.result( context )
	rescue NoMethodError => err
		raise RDoc::Error, "Error while evaluating %s: %s (at %p)" % [
			template_file,
			err.message,
			eval( "_erbout[-50,50]", context )
		], err.backtrace
	end
	outfile = @basedir + @options.op_dir + 'index.html'
	unless $DARKFISH_DRYRUN
		debug_msg "Outputting to %s" % [outfile.expand_path]
		outfile.open( 'w', 0644 ) do |fh|
			fh.print( output )
		end
	else
		debug_msg "Would have output to %s" % [outfile.expand_path]
	end
end

def get_sorted_module_list( classes )
	nscounts = classes.inject({}) do |counthash, klass|
		top_level = klass.full_name.gsub( /::.*/, '' )
		counthash[top_level] ||= 0
		counthash[top_level] += 1
		counthash
	end
	# Sort based on how often the top level namespace occurs, and then on the
	# name of the module -- this works for projects that put their stuff into
	# a namespace, of course, but doesn't hurt if they don't.
	classes.sort_by do |klass|
		top_level = klass.full_name.gsub( /::.*/, '' )
		[
			nscounts[ top_level ] * -1,
			klass.full_name
		]
	end.select do |klass|
		klass.document_self
	end
end

def get_svninfo( klass )
	constants = klass.constants or return {}
	constants.find {|c| c.value =~ SVNID_PATTERN } or return {}
	filename, rev, date, time, committer = $~.captures
	commitdate = Time.parse( date + ' ' + time )
	return {
		:filename    => filename,
		:rev         => Integer( rev ),
		:commitdate  => commitdate,
		:commitdelta => time_delta_string( Time.now.to_i - commitdate.to_i ),
		:committer   => committer,
	}
end

def initialize( options )
	@options = options
	template = @options.template || 'darkfish'
	template_dir = $LOAD_PATH.map do |path|
		File.join File.expand_path(path), GENERATOR_DIR, 'template', template
	end.find do |dir|
		File.directory? dir
	end
	raise RDoc::Error, "could not find template #{template.inspect}" unless
		template_dir
	@template_dir = Pathname.new File.expand_path(template_dir)
	@files      = nil
	@classes    = nil
	@basedir = Pathname.pwd.expand_path
end

def render_template( template_file, context, outfile )
	template_src = template_file.read
	template = ERB.new( template_src, nil, '<>' )
	template.filename = template_file.to_s
	output = begin
						 template.result( context )
					 rescue NoMethodError => err
						 raise RDoc::Error, "Error while evaluating %s: %s (at %p)" % [
							 template_file.to_s,
							 err.message,
							 eval( "_erbout[-50,50]", context )
						 ], err.backtrace
					 end
	unless $DARKFISH_DRYRUN
		outfile.dirname.mkpath
		outfile.open( 'w', 0644 ) do |ofh|
			ofh.print( output )
		end
	else
		debug_msg "  would have written %d bytes to %s" %
		[ output.length, outfile ]
	end
end

def time_delta_string( seconds )
	return 'less than a minute' if seconds < 1.minute
	return (seconds / 1.minute).to_s + ' minute' + (seconds/60 == 1 ? '' : 's') if seconds < 50.minutes
	return 'about one hour' if seconds < 90.minutes
	return (seconds / 1.hour).to_s + ' hours' if seconds < 18.hours
	return 'one day' if seconds < 1.day
	return 'about one day' if seconds < 2.days
	return (seconds / 1.day).to_s + ' days' if seconds < 1.week
	return 'about one week' if seconds < 2.week
	return (seconds / 1.week).to_s + ' weeks' if seconds < 3.months
	return (seconds / 1.month).to_s + ' months' if seconds < 1.year
	return (seconds / 1.year).to_s + ' years'
end

def write_style_sheet
	debug_msg "Copying static files"
	options = { :verbose => $DEBUG_RDOC, :noop => $DARKFISH_DRYRUN }
	FileUtils.cp @template_dir + 'rdoc.css', '.', options
	Dir[(@template_dir + "{js,images}/**/*").to_s].each do |path|
		next if File.directory? path
		next if path =~ /#{File::SEPARATOR}\./
		dst = Pathname.new(path).relative_path_from @template_dir
		# I suck at glob
		dst_dir = dst.dirname
		FileUtils.mkdir_p dst_dir, options unless File.exist? dst_dir
		FileUtils.cp @template_dir + path, dst, options
	end
end