require 'highline'
require 'utilrb/module/attr_predicate'
module Autoproj
    class << self
        attr_accessor :verbose
        attr_reader :console
        attr_predicate :silent?, true
    end
    @silent  = false
    @verbose = false
    @console = HighLine.new

    def self.progress(*args)
        if !silent?
            if args.empty?
                puts
            elsif CmdLine.color?
                STDERR.puts console.color(*args)
            else
                STDERR.puts args.first
            end
        end
    end

    def self.color(*args)
        if CmdLine.color?
            console.color(*args)
        else
            args.first
        end
    end

    # Displays an error message
    def self.error(message)
        Autoproj.progress("  ERROR: #{message}", :red, :bold)
    end

    # Displays a warning message
    def self.warn(message)
        Autoproj.progress("  WARN: #{message}", :magenta)
    end

    module CmdLine
        def self.initialize
            Autobuild::Reporting << Autoproj::Reporter.new
            if mail_config[:to]
                Autobuild::Reporting << Autobuild::MailReporter.new(mail_config)
            end

            # Remove from LOADED_FEATURES everything that is coming from our
            # configuration directory
            Autobuild::Package.clear
            Autoproj.loaded_autobuild_files.clear
            Autoproj.load_config

            if Autoproj.has_config_key?('autobuild')
                params = Autoproj.user_config('autobuild')
                if params.kind_of?(Hash)
                    params.each do |k, v|
                        Autobuild.send("#{k}=", v)
                    end
                end
            end

            if Autoproj.has_config_key?('prefix')
                Autoproj.prefix = Autoproj.user_config('prefix')
            end

            if Autoproj.has_config_key?('randomize_layout')
                @randomize_layout = Autoproj.user_config('randomize_layout')
            end

            # If we are under rubygems, check that the GEM_HOME is right ...
            if $LOADED_FEATURES.any? { |l| l =~ /rubygems/ }
                if ENV['GEM_HOME'] != Autoproj.gem_home
                    raise ConfigError.new, "RubyGems is already loaded with a different GEM_HOME, make sure you are loading the right env.sh script !"
                end
            end

            # Set up some important autobuild parameters
            Autoproj.env_inherit 'PATH', 'PKG_CONFIG_PATH', 'RUBYLIB', 'LD_LIBRARY_PATH'
            Autoproj.env_set 'GEM_HOME', Autoproj.gem_home
            Autoproj.env_add 'PATH', File.join(Autoproj.gem_home, 'bin')
            Autoproj.env_set 'RUBYOPT', "-rubygems"
            Autobuild.prefix  = Autoproj.build_dir
            Autobuild.srcdir  = Autoproj.root_dir
            Autobuild.logdir = File.join(Autobuild.prefix, 'log')

            ruby = RbConfig::CONFIG['RUBY_INSTALL_NAME']
            if ruby != 'ruby'
                bindir = File.join(Autoproj.build_dir, 'bin')
                FileUtils.mkdir_p bindir
                File.open(File.join(bindir, 'ruby'), 'w') do |io|
                    io.puts "#! /bin/sh"
                    io.puts "exec #{ruby} \"$@\""
                end
                FileUtils.chmod 0755, File.join(bindir, 'ruby')

                Autoproj.env_add 'PATH', bindir
            end

            Autoproj.manifest = Manifest.new

            # We load the local init.rb first so that the manifest loading
            # process can use options defined there for the autoproj version
            # control information (for instance)
            local_source = LocalPackageSet.new(Autoproj.manifest)
            Autoproj.load_if_present(local_source, local_source.local_dir, "init.rb")

            manifest_path = File.join(Autoproj.config_dir, 'manifest')
            Autoproj.manifest.load(manifest_path)

            # Once thing left to do: handle the Autoproj.auto_update
            # configuration parameter. This has to be done here as the rest of
            # the configuration update/loading procedure rely on it.
            #
            # Namely, we must check if Autobuild.do_update has been explicitely
            # set to true or false. If that is the case, don't do anything.
            # Otherwise, set it to the value of auto_update (set in the
            # manifest)
            if Autobuild.do_update.nil?
                Autobuild.do_update = manifest.auto_update?
            end
            if @update_os_dependencies.nil?
                @update_os_dependencies = manifest.auto_update?
            end

            # Initialize the Autoproj.osdeps object by loading the default. The
            # rest is loaded later
            Autoproj.osdeps = Autoproj::OSDependencies.load_default
            Autoproj.osdeps.silent = !osdeps?
            Autoproj.osdeps.filter_uptodate_packages = osdeps_filter_uptodate?
            if osdeps_forced_mode
                Autoproj.osdeps.osdeps_mode = osdeps_forced_mode
            end

            # Define the option NOW, as update_os_dependencies? needs to know in
            # what mode we are.
            #
            # It might lead to having multiple operating system detections, but
            # that's the best I can do for now.
	    Autoproj::OSDependencies.define_osdeps_mode_option
            Autoproj.osdeps.osdeps_mode

            # Do that AFTER we have properly setup Autoproj.osdeps as to avoid
            # unnecessarily redetecting the operating system
            if update_os_dependencies? || osdeps?
                Autoproj.change_option('operating_system', Autoproj::OSDependencies.operating_system(:force => true), true)
            end
        end

        def self.update_myself
            return if !Autoproj::CmdLine.update_os_dependencies?

            # This is a guard to avoid infinite recursion in case the user is
            # running autoproj osdeps --force
            if ENV['AUTOPROJ_RESTARTING'] == '1'
                return
            end

            # First things first, see if we need to update ourselves
            if Autoproj.osdeps.install(%w{autobuild autoproj})
                puts
                Autoproj.progress 'autoproj and/or autobuild has been updated, restarting autoproj'
                puts

                # We updated autobuild or autoproj themselves ... Restart !
                #
                # ...But first save the configuration (!)
                Autoproj.save_config
                ENV['AUTOPROJ_RESTARTING'] = '1'
                require 'rbconfig'
                ruby = RbConfig::CONFIG['RUBY_INSTALL_NAME']
                if defined?(ORIGINAL_ARGV)
                    exec(ruby, $0, *ORIGINAL_ARGV)
                else
                    exec(ruby, $0, *ARGV)
                end
            end
        end

        def self.load_configuration(silent = false)
            manifest = Autoproj.manifest
            manifest.cache_package_sets

            manifest.each_package_set(false) do |pkg_set|
                if Gem::Version.new(pkg_set.required_autoproj_version) > Gem::Version.new(Autoproj::VERSION)
                    raise ConfigError.new(pkg_set.source_file), "the #{pkg_set.name} package set requires autoproj v#{pkg_set.required_autoproj_version} but this is v#{Autoproj::VERSION}"
                end
            end

            # Load init.rb files. each_source must not load the source.yml file, as
            # init.rb may define configuration options that are used there
            manifest.each_package_set(false) do |source|
                Autoproj.load_if_present(source, source.local_dir, "init.rb")
            end

            # Load the required autobuild definitions
            if !silent
                Autoproj.progress("autoproj: loading ...", :bold)
                if !Autoproj.reconfigure?
                    Autoproj.progress("run 'autoproj reconfigure' to change configuration options", :bold)
                    Autoproj.progress("and use 'autoproj switch-config' to change the remote source for", :bold)
                    Autoproj.progress("autoproj's main build configuration", :bold)
                end
            end
            manifest.each_autobuild_file do |source, name|
                Autoproj.import_autobuild_file source, name
            end

            # Now, load the package's importer configurations (from the various
            # source.yml files)
            manifest.load_importers

            # Auto-add packages that are
            #  * present on disk
            #  * listed in the layout part of the manifest
            #  * but have no definition
            explicit = manifest.normalized_layout
            explicit.each do |pkg_or_set, layout_level|
                next if Autobuild::Package[pkg_or_set]
                next if manifest.has_package_set?(pkg_or_set)

                # This is not known. Check if we can auto-add it
                full_path = File.expand_path(File.join(Autoproj.root_dir, layout_level, pkg_or_set))
                next if !File.directory?(full_path)

                if handler = Autoproj.package_handler_for(full_path)
                    Autoproj.progress "  auto-adding #{pkg_or_set} #{"in #{layout_level} " if layout_level != "/"}using the #{handler.gsub(/_package/, '')} package handler"
                    Autoproj.in_package_set(manifest.local_package_set, manifest.file) do
                        send(handler, pkg_or_set)
                    end
                else
                    Autoproj.warn "cannot auto-add #{pkg_or_set}: unknown package type"
                end
            end

            # We finished loading the configuration files. Not all configuration
            # is done (since we need to process the package setup blocks), but
            # save the current state of the configuration anyway.
            Autoproj.save_config

            # Loads OS package definitions once and for all
            Autoproj.load_osdeps_from_package_sets
        end

        def self.update_configuration
            manifest = Autoproj.manifest

            # Load the installation's manifest a first time, to check if we should
            # update it ... We assume that the OS dependencies for this VCS is already
            # installed (i.e. that the user did not remove it)
            if manifest.vcs
                manifest.update_yourself
                manifest_path = File.join(Autoproj.config_dir, 'manifest')
                manifest.load(manifest_path)
            end

            source_os_dependencies = manifest.each_remote_source(false).
                inject(Set.new) do |set, source|
                    set << source.vcs.type if !source.local?
                end

            # Update the remote sources if there are any
            if manifest.has_remote_sources?
                if manifest.should_update_remote_sources
                    Autoproj.progress("autoproj: updating remote definitions of package sets", :bold)
                end

                # If we need to install some packages to import our remote sources, do it
                if update_os_dependencies?
                    Autoproj.osdeps.install(source_os_dependencies)
                end

                if manifest.should_update_remote_sources
                    manifest.update_remote_sources
                end
                Autoproj.progress
            end
        end

        def self.setup_package_directories(pkg)
            pkg_name = pkg.name

            layout =
                if randomize_layout?
                    Digest::SHA256.hexdigest(pkg_name)[0, 12]
                else manifest.whereis(pkg_name)
                end

            place =
                if target = manifest.moved_packages[pkg_name]
                    File.join(layout, target)
                else
                    File.join(layout, pkg_name)
                end

            pkg = Autobuild::Package[pkg_name]
            pkg.srcdir = File.join(Autoproj.root_dir, place)
            pkg.prefix = File.join(Autoproj.build_dir, layout)
            pkg.doc_target_dir = File.join(Autoproj.build_dir, 'doc', pkg_name)
            pkg.logdir = File.join(pkg.prefix, "log")
        end


        def self.setup_all_package_directories
            manifest = Autoproj.manifest

            # Now starts a different stage of the whole build. Until now, we were
            # working on the whole package set. Starting from now, we need to build the
            # package sets based on the layout file
            #
            # First, we allow to user to specify packages based on disk paths, so
            # resolve those
            manifest.packages.each_value do |pkg_def|
                pkg = pkg_def.autobuild
                setup_package_directories(pkg)
            end
        end

        def self.finalize_package_setup
            # Now call the blocks that the user defined in the autobuild files. We do it
            # now so that the various package directories are properly setup
            manifest.packages.each_value do |pkg|
                pkg.user_blocks.each do |blk|
                    blk[pkg.autobuild]
                end
                pkg.setup = true
            end

            # Load the package's override files. each_source must not load the
            # source.yml file, as init.rb may define configuration options that are used
            # there
            manifest.each_source(false).to_a.reverse.each do |source|
                Autoproj.load_if_present(source, source.local_dir, "overrides.rb")
            end

            # Resolve optional dependencies
            manifest.resolve_optional_dependencies

            # We now have processed the process setup blocks. All configuration
            # should be done and we can save the configuration data.
            Autoproj.save_config
        end


        def self.display_configuration(manifest, package_list = nil)
            # Load the manifest for packages that are already present on the
            # file system
            manifest.packages.each_value do |pkg|
                if File.directory?(pkg.autobuild.srcdir)
                    manifest.load_package_manifest(pkg.autobuild.name)
                end
            end

            all_packages = Hash.new
            if package_list
                all_selected_packages = Set.new
                package_list.each do |name|
                    all_selected_packages << name
                    Autobuild::Package[name].all_dependencies(all_selected_packages)
                end

                package_sets = Set.new
                all_selected_packages.each do |name|
                    pkg_set = manifest.definition_source(name)
                    package_sets << pkg_set
                    all_packages[name] = [manifest.package(name).autobuild, pkg_set.name]
                end

                metapackages = Set.new
                manifest.metapackages.each_value do |metap|
                    if package_list.any? { |pkg_name| metap.include?(pkg_name) }
                        metapackages << metap
                    end
                end
            else
                package_sets = manifest.each_package_set
                package_sets.each do |pkg_set|
                    pkg_set.each_package.each do |pkg|
                        all_packages[pkg.name] = [pkg, pkg_set.name]
                    end
                end

                metapackages = manifest.metapackages.values
            end

            if package_sets.empty?
                Autoproj.progress("autoproj: no package sets defined in autoproj/manifest", :bold, :red)
                return
            end

            Autoproj.progress
            Autoproj.progress("autoproj: package sets", :bold)
            package_sets.sort_by(&:name).each do |pkg_set|
                next if pkg_set.empty?
                if pkg_set.imported_from
                    Autoproj.progress "#{pkg_set.name} (imported by #{pkg_set.imported_from.name})"
                else
                    Autoproj.progress "#{pkg_set.name} (listed in manifest)"
                end
                if pkg_set.local?
                    Autoproj.progress "  local set in #{pkg_set.local_dir}"
                else
                    Autoproj.progress "  from:  #{pkg_set.vcs}"
                    Autoproj.progress "  local: #{pkg_set.local_dir}"
                end

                imports = pkg_set.each_imported_set.to_a
                if !imports.empty?
                    Autoproj.progress "  imports #{imports.size} package sets"
                    if !pkg_set.auto_imports?
                        Autoproj.progress "    automatic imports are DISABLED for this set"
                    end
                    imports.each do |imported_set|
                        Autoproj.progress "    #{imported_set.name}"
                    end
                end

                set_packages = pkg_set.each_package.sort_by(&:name)
                Autoproj.progress "  defines: #{set_packages.map(&:name).join(", ")}"
            end

            Autoproj.progress
            Autoproj.progress("autoproj: metapackages", :bold)
            metapackages.sort_by(&:name).each do |metap|
                Autoproj.progress "#{metap.name}"
                Autoproj.progress "  includes: #{metap.packages.map(&:name).sort.join(", ")}"
            end

            packages_not_present = []

            Autoproj.progress
            Autoproj.progress("autoproj: packages", :bold)
            all_packages.to_a.sort_by(&:first).map(&:last).each do |pkg, pkg_set|
                if File.exists?(File.join(pkg.srcdir, "manifest.xml"))
                    manifest.load_package_manifest(pkg.name)
                    manifest.resolve_optional_dependencies
                end

                pkg_manifest = pkg.description
                vcs_def = manifest.importer_definition_for(pkg.name)
                Autoproj.progress "#{pkg.name}#{": #{pkg_manifest.short_documentation}" if pkg_manifest && pkg_manifest.short_documentation}", :bold
                tags = pkg.tags.to_a
                if tags.empty?
                    Autoproj.progress "   no tags"
                else
                    Autoproj.progress "   tags: #{pkg.tags.to_a.sort.join(", ")}"
                end
                Autoproj.progress "   defined in package set #{pkg_set}"
                if File.directory?(pkg.srcdir)
                    Autoproj.progress "   checked out in #{pkg.srcdir}"
                else
                    Autoproj.progress "   will be checked out in #{pkg.srcdir}"
                end
                Autoproj.progress "   #{vcs_def.to_s}"

                if !File.directory?(pkg.srcdir)
                    packages_not_present << pkg.name
                    Autoproj.progress "   NOT checked out yet, reported dependencies will be partial"
                end

                optdeps = pkg.optional_dependencies.to_set
                real_deps = pkg.dependencies.to_a
                actual_real_deps = real_deps.find_all { |dep_name| !optdeps.include?(dep_name) }
                if !actual_real_deps.empty?
                    Autoproj.progress "   deps: #{actual_real_deps.join(", ")}"
                end

                selected_opt_deps, opt_deps = optdeps.partition { |dep_name| real_deps.include?(dep_name) }
                if !selected_opt_deps.empty?
                    Autoproj.progress "   enabled opt deps: #{selected_opt_deps.join(", ")}"
                end
                if !opt_deps.empty?
                    Autoproj.progress "   disabled opt deps: #{opt_deps.join(", ")}"
                end
            end

            if !packages_not_present.empty?
                Autoproj.progress
                Autoproj.warn "the following packages are not yet checked out:"
                packages_not_present.each_slice(4) do |*packages|
                    Autoproj.warn "  #{packages.join(", ")}"
                end
                Autoproj.warn "therefore, the package list above and the listed dependencies are probably not complete"
            end
        end

        # Returns the set of packages that are actually selected based on what
        # the user gave on the command line
        def self.resolve_user_selection(selected_packages)
            manifest = Autoproj.manifest

            if selected_packages.empty?
                return manifest.default_packages
            end
            selected_packages = selected_packages.to_set

            selected_packages, nonresolved = manifest.
                expand_package_selection(selected_packages)

            # Try to auto-add stuff if nonresolved
            nonresolved.delete_if do |sel|
                next if !File.directory?(sel)
                while sel != '/'
                    if handler = Autoproj.package_handler_for(sel)
                        Autoproj.progress "  auto-adding #{sel} using the #{handler.gsub(/_package/, '')} package handler"
                        sel = File.expand_path(sel)
                        relative_to_root = Pathname.new(sel).relative_path_from(Pathname.new(Autoproj.root_dir))
                        pkg = Autoproj.in_package_set(manifest.local_package_set, manifest.file) do
                            send(handler, relative_to_root.to_s)
                        end
                        setup_package_directories(pkg)
                        selected_packages << pkg.name
                        break(true)
                    end

                    sel = File.dirname(sel)
                end
            end

            if !nonresolved.empty?
                Autoproj.progress("autoproj: wrong package selection on command line, cannot find a match for #{nonresolved.to_a.join(", ")}", :red)
                exit 1
            elsif Autoproj.verbose
                Autoproj.progress "will install #{selected_packages.to_a.join(", ")}"
            end
            selected_packages
        end

        def self.verify_package_availability(pkg_name)
            if reason = Autoproj.manifest.exclusion_reason(pkg_name)
                raise ConfigError.new, "#{pkg_name} is excluded from the build: #{reason}"
            end
            pkg = Autobuild::Package[pkg_name]
            if !pkg
                raise ConfigError.new, "#{pkg_name} does not seem to exist"
            end

            # Verify that its dependencies are there, and add
            # them to the selected_packages set so that they get
            # imported as well
            pkg.dependencies.each do |dep_name|
                begin
                    verify_package_availability(dep_name)
                rescue ConfigError => e
                    raise e, "#{pkg_name} depends on #{dep_name}, but #{e.message}"
                end
            end
        end

        def self.import_packages(selected_packages)
            selected_packages = selected_packages.dup.
                map do |pkg_name|
                    pkg = Autobuild::Package[pkg_name]
                    if !pkg
                        raise ConfigError.new, "selected package #{pkg_name} does not exist"
                    end
                    pkg
                end.to_set

            # First, import all packages that are already there to make
            # automatic dependency discovery possible
            old_update_flag = Autobuild.do_update
            begin
                Autobuild.do_update = false
                packages = Autobuild::Package.each.
                    find_all { |pkg_name, pkg| File.directory?(pkg.srcdir) }.
                    delete_if { |pkg_name, pkg| Autoproj.manifest.excluded?(pkg_name) || Autoproj.manifest.ignored?(pkg_name) }

                packages.each do |_, pkg|
                    pkg.isolate_errors do
                        pkg.import
                    end
                end

            ensure
                Autobuild.do_update = old_update_flag
            end

            known_available_packages = Set.new
            all_enabled_packages = Set.new

            package_queue = selected_packages.dup
            while !package_queue.empty?
                current_packages, package_queue = package_queue, Set.new
                current_packages = current_packages.sort_by(&:name)

                current_packages.
                    delete_if { |pkg| all_enabled_packages.include?(pkg.name) }.
                    delete_if { |pkg| Autoproj.manifest.ignored?(pkg.name) }
                all_enabled_packages |= current_packages.map(&:name).to_set

                # Recursively check that no package in the selection depend on
                # excluded packages
                current_packages.each do |pkg|
                    verify_package_availability(pkg.name)
                end

                # We import first so that all packages can export the
                # additional targets they provide.
                current_packages.each do |pkg|
                    # If the package has no importer, the source directory must
                    # be there
                    if !pkg.importer && !File.directory?(pkg.srcdir)
                        raise ConfigError.new, "#{pkg.name} has no VCS, but is not checked out in #{pkg.srcdir}"
                    end

                    ## COMPLETELY BYPASS RAKE HERE
                    # The reason is that the ordering of import/prepare between
                    # packages is not important BUT the ordering of import vs.
                    # prepare in one package IS important: prepare is the method
                    # that takes into account dependencies.
                    pkg.import
                    Rake::Task["#{pkg.name}-import"].instance_variable_set(:@already_invoked, true)
                    manifest.load_package_manifest(pkg.name)
                    pkg.resolve_optional_dependencies
                    verify_package_availability(pkg.name)
                end

                current_packages.each do |pkg|
                    verify_package_availability(pkg.name)
                    Autoproj.each_post_import_block(pkg) do |block|
                        block.call(pkg)
                    end

                    pkg.prepare
                    Rake::Task["#{pkg.name}-prepare"].instance_variable_set(:@already_invoked, true)

                    # Verify that its dependencies are there, and add
                    # them to the selected_packages set so that they get
                    # imported as well
                    pkg.dependencies.each do |dep_name|
                        package_queue << Autobuild::Package[dep_name]
                    end
                end
            end

            begin
                Autobuild.do_update = false
                packages = Autobuild::Package.each.
                    find_all { |pkg_name, pkg| File.directory?(pkg.srcdir) }.
                    delete_if { |pkg_name, pkg| all_enabled_packages.include?(pkg_name) || Autoproj.manifest.excluded?(pkg_name) || Autoproj.manifest.ignored?(pkg_name) }

                packages.each do |_, pkg|
                    pkg.isolate_errors do
                        manifest.load_package_manifest(pkg.name)
                        pkg.prepare

                        Autoproj.each_post_import_block(pkg) do |block|
                            block.call(pkg)
                        end
                    end
                end

            ensure
                Autobuild.do_update = old_update_flag
            end

            if Autoproj.verbose
                Autoproj.progress "autoproj: finished importing packages"
            end
            if Autoproj::CmdLine.list_newest?
                fields = []
                Rake::Task.tasks.each do |task|
                    if task.kind_of?(Autobuild::SourceTreeTask)
                        task.timestamp
                        fields << ["#{task.name}:", task.newest_file, task.newest_time.to_s]
                    end
                end

                field_sizes = fields.inject([0, 0, 0]) do |sizes, line|
                    3.times do |i|
                        sizes[i] = [sizes[i], line[i].length].max
                    end
                    sizes
                end
                format = "  %-#{field_sizes[0]}s %-#{field_sizes[1]}s at %-#{field_sizes[2]}s"
                fields.each do |line|
                    Autoproj.progress(format % line)
                end
            end

            return all_enabled_packages
        end

        def self.build_packages(selected_packages, all_enabled_packages)
            if Autoproj::CmdLine.doc?
                Autobuild.only_doc = true
                Autoproj.progress("autoproj: building and installing documentation", :bold)
            else
                Autoproj.progress("autoproj: building and installing packages", :bold)
            end

            if Autoproj::CmdLine.update_os_dependencies?
                manifest.install_os_dependencies(all_enabled_packages)
            end

            if !selected_packages.empty? && !force_re_build_with_depends?
                if Autobuild.do_rebuild
                    selected_packages.each do |pkg_name|
                        Autobuild::Package[pkg_name].prepare_for_rebuild
                    end
                    Autobuild.do_rebuild = false
                elsif Autobuild.do_forced_build
                    selected_packages.each do |pkg_name|
                        Autobuild::Package[pkg_name].prepare_for_forced_build
                    end
                    Autobuild.do_forced_build = false
                end
            end

            Autobuild.apply(all_enabled_packages, "autoproj-build")
        end

        def self.manifest; Autoproj.manifest end
        def self.bootstrap?; !!@bootstrap end
        def self.only_status?; !!@only_status end
        def self.only_local?; !!@only_local end
        def self.check?; !!@check end
        def self.manifest_update?; !!@manifest_update end
        def self.only_config?; !!@only_config end
        def self.randomize_layout?; !!@randomize_layout end
        def self.update_os_dependencies?
            # Check if the mode disables osdeps anyway ...
            if !@update_os_dependencies.nil? && !@update_os_dependencies
                return false
            end

            # Now look for what the user wants
            Autoproj.osdeps.osdeps_mode != 'none' || !Autoproj.osdeps.silent?
        end
        class << self
            attr_accessor :update_os_dependencies
            attr_accessor :snapshot_dir
            attr_writer :list_newest
        end
        def self.display_configuration?; !!@display_configuration end
        def self.force_re_build_with_depends?; !!@force_re_build_with_depends end
        def self.partial_build?; !!@partial_build end
        def self.mail_config; @mail_config || Hash.new end
        def self.update_packages?; @mode == "update" || @mode == "envsh" || build? end
        def self.update_envsh?; @mode == "envsh" || build? || @mode == "update" end
        def self.build?; @mode =~ /build/ end
        def self.doc?; @mode == "doc" end
        def self.snapshot?; @mode == "snapshot" end
        def self.reconfigure?; @mode == "reconfigure" end
        def self.list_unused?; @mode == "list-unused" end

        def self.show_statistics?; !!@show_statistics end
        def self.ignore_dependencies?; @ignore_dependencies end

        def self.color?; @color end

        def self.osdeps?; @mode == "osdeps" end
        def self.show_osdeps?; @mode == "osdeps" && @show_osdeps end
        def self.revshow_osdeps?; @mode == "osdeps" && @revshow_osdeps end
        def self.osdeps_forced_mode; @osdeps_forced_mode end
        def self.osdeps_filter_uptodate?
            if @mode == "osdeps"
                @osdeps_filter_uptodate
            else true
            end
        end
        def self.status_exit_code?
            @status_exit_code
        end
        def self.list_newest?; @list_newest end
        def self.parse_arguments(args, with_mode = true)
            @only_status = false
            @only_local  = false
            @show_osdeps = false
            @status_exit_code = false
            @revshow_osdeps = false
            @osdeps_filter_uptodate = true
            @osdeps_forced_mode = nil
            @check = false
            @manifest_update = false
            @display_configuration = false
            @update_os_dependencies = nil
            @force_re_build_with_depends = false
            force_re_build_with_depends = nil
            @only_config = false
            @partial_build = false
            @color = true
            Autobuild.doc_errors = false
            Autobuild.do_doc = false
            Autobuild.only_doc = false
            Autobuild.do_update = nil
            do_update = nil

            mail_config = Hash.new

            # Parse the configuration options
            parser = OptionParser.new do |opts|
                opts.banner = <<-EOBANNER
autoproj mode [options]
where 'mode' is one of:

-- Build
  build:  import, build and install all packages that need it. A package or package
    set name can be given, in which case only this package and its dependencies
    will be taken into account. Example:

    autoproj build drivers/hokuyo

  fast-build: builds without updating and without considering OS dependencies
  full-build: updates packages and OS dependencies, and then builds 
  force-build: triggers all build commands, i.e. don't be lazy like in "build".
           If packages are selected on the command line, only those packages
           will be affected unless the --with-depends option is used.
  rebuild: clean and then rebuild. If packages are selected on the command line,
           only those packages will be affected unless the --with-depends option
           is used.
  doc:    generate and install documentation for packages that have some

-- Status & Update
  envsh:         update the env.sh script
  osdeps:        install the OS-provided packages
  status:        displays the state of the packages w.r.t. their source VCS
  list-config:   list all available packages
  update:        only import/update packages, do not build them
  update-config: only update the configuration
  reconfigure:   change the configuration options. Additionally, the
                 --reconfigure option can be used in other modes like
                 update or build

-- Experimental Features (USE AT YOUR OWN RISK)
  check:  compares dependencies in manifest.xml with autodetected ones
          (valid only for package types that do autodetection, like
          orogen packages)
  manifest-update: like check, but updates the manifest.xml file
          (CAREFUL: optional dependencies will get added as well!!!)
  snapshot: create a standalone autoproj configuration where all packages
            are pinned to their current version. I.e. building a snapshot
            should give you the exact same result.

-- Autoproj Configuration
  bootstrap: starts a new autoproj installation. Usage:
    autoproj bootstrap [manifest_url|source_vcs source_url opt1=value1 opt2=value2 ...]

    For example:
    autoproj bootstrap git git://gitorious.org/rock/buildconfig.git

  switch-config: change where the configuration should be taken from. Syntax:
    autoproj switch-config source_vcs source_url opt1=value1 opt2=value2 ...

    For example:
    autoproj switch-config git git://gitorious.org/rock/buildconfig.git

    In case only the options need to be changed, the source_vcs and source_url fields can be omitted:

    For example:
    autoproj switch-config branch=next

-- Additional options:
    EOBANNER
                opts.on("--reconfigure", "re-ask all configuration options (build modes only)") do
                    Autoproj.reconfigure = true
                end
                opts.on("--[no-]color", "enable or disable color in status messages (enabled by default)") do |flag|
                    @color = flag
                end
                opts.on("--version", "displays the version and then exits") do
                    puts "autoproj v#{Autoproj::VERSION}"
                    exit(0)
                end
                opts.on("--[no-]update", "[do not] update already checked-out packages (build modes only)") do |value|
                    do_update = value
                end
                opts.on("--keep-going", "-k", "continue building even though one package has an error") do
                    Autobuild.ignore_errors = true
                end
                opts.on("--os-version", "displays the operating system as detected by autoproj") do
                    os_names, os_versions = OSDependencies.operating_system
                    if !os_names
                        puts "no information about that OS"
                    else
                        puts "name(s): #{os_names.join(", ")}"
                        puts "version(s): #{os_versions.join(", ")}"
                    end
                    exit 0
                end
                opts.on('--stats', 'displays statistics about each of the phases in the package building process') do
                    @show_statistics = true
                end

                opts.on("--with-depends", "apply rebuild and force-build to both packages selected on the command line and their dependencies") do
                    force_re_build_with_depends = true
                end
                opts.on("--list-newest", "for each source directory, list what is the newest file used by autoproj for dependency tracking") do
                    Autoproj::CmdLine.list_newest = true
                end
                opts.on('-n', '--no-deps', 'completely ignore dependencies') do |value|
                    @ignore_dependencies = true
                end
                opts.on("--no-osdeps", "in build and update modes, disable osdeps handling") do |value|
                    @osdeps_forced_mode = 'none'
                end
                opts.on("--rshow", "in osdeps mode, shows information for each OS package") do
                    @revshow_osdeps = true
                end
                opts.on("--show", "in osdeps mode, show a per-package listing of the OS dependencies instead of installing them") do
                    @show_osdeps = true
                end
                opts.on("--all", "in osdeps mode, install both OS packages and RubyGem packages, regardless of the otherwise selected mode") do
                    @osdeps_forced_mode = 'all'
                end
                opts.on("--os", "in osdeps mode, install OS packages and display information about the RubyGem packages, regardless of the otherwise selected mode") do
                    if @osdeps_forced_mode == 'ruby'
                        # Make --ruby --os behave like --all
                        @osdeps_forced_mode = 'all'
                    else
                        @osdeps_forced_mode = 'os'
                    end
                end
                opts.on('--force', 'in osdeps mode, do not filter out installed and uptodate packages') do
                    @osdeps_filter_uptodate = false
                end
                opts.on("--ruby", "in osdeps mode, install only RubyGem packages and display information about the OS packages, regardless of the otherwise selected mode") do
                    if @osdeps_forced_mode == 'os'
                        # Make --ruby --os behave like --all
                        @osdeps_forced_mode = 'all'
                    else
                        @osdeps_forced_mode = 'ruby'
                    end
                end
                opts.on("--none", "in osdeps mode, do not install any package but display information about them, regardless of the otherwise selected mode") do
                    @osdeps_forced_mode = 'none'
                end
                opts.on("--local", "for status, do not access the network") do
                    @only_local = true
                end
                opts.on('--exit-code', 'in status mode, exit with a code that reflects the status of the installation (see documentation for details)') do
                    @status_exit_code = true
                end
                opts.on('--randomize-layout', 'in build and full-build, generate a random layout') do
                    @randomize_layout = true
                    Autoproj.change_option('randomize_layout', true)
                end

                opts.on("--verbose", "verbose output") do
                    Autoproj.verbose  = true
                    Autobuild.verbose = true
                    Rake.application.options.trace = false
                end
                opts.on("--debug", "debugging output") do
                    Autoproj.verbose  = true
                    Autobuild.verbose = true
                    Rake.application.options.trace = true
                    Autobuild.debug = true
                end
                opts.on('--nice NICE', Integer, 'nice the subprocesses to the given value') do |value|
                    Autobuild.nice = value
                end
                opts.on("-h", "--help", "Show this message") do
                    puts opts
                    exit
                end
                opts.on("--mail-from EMAIL", String, "From: field of the sent mails") do |from_email|
                    mail_config[:from] = from_email
                end
                opts.on("--mail-to EMAILS", String, "comma-separated list of emails to which the reports should be sent") do |emails| 
                    mail_config[:to] ||= []
                    mail_config[:to] += emails.split(',')
                end
                opts.on("--mail-subject SUBJECT", String, "Subject: field of the sent mails") do |subject_email|
                    mail_config[:subject] = subject_email
                end
                opts.on("--mail-smtp HOSTNAME", String, " address of the mail server written as hostname[:port]") do |smtp|
                    raise "invalid SMTP specification #{smtp}" unless smtp =~ /^([^:]+)(?::(\d+))?$/
                        mail_config[:smtp] = $1
                    mail_config[:port] = Integer($2) if $2 && !$2.empty?
                end
                opts.on("--mail-only-errors", "send mail only on errors") do
                    mail_config[:only_errors] = true
                end
            end

            parser.parse!(args)
            @mail_config = mail_config

            if with_mode
                @mode = args.shift
                unknown_mode = catch(:unknown) do
                    handle_mode(@mode, args)
                    false
                end
                if unknown_mode
                    STDERR.puts "unknown mode #{@mode}"
                    STDERR.puts "run autoproj --help for more documentation"
                    exit(1)
                end
            end

            selection = args.dup
            @partial_build = !selection.empty?
            @force_re_build_with_depends = force_re_build_with_depends if !force_re_build_with_depends.nil?
            Autobuild.do_update = do_update if !do_update.nil?
            selection

        rescue OptionParser::InvalidOption => e
            raise ConfigError, e.message, e.backtrace
        end

        def self.handle_mode(mode, remaining_args)
            case mode
            when "update-sets"
                Autoproj.warn("update-sets is deprecated. Use update-config instead")
                mode = "update-config"
            when "list-sets"
                Autoproj.warn("list-sets is deprecated. Use list-config instead")
                mode = "list-config"
            end

            case mode
            when "bootstrap"
                @bootstrap = true
                bootstrap(*remaining_args)
                remaining_args.clear

                @display_configuration = true
                Autobuild.do_build  = false
                Autobuild.do_update = false
                @update_os_dependencies = false
                @only_config = true

            when "switch-config"
                if Dir.pwd.start_with?(Autoproj.remotes_dir) || Dir.pwd.start_with?(Autoproj.config_dir)
                    raise ConfigError, "you cannot run autoproj switch-config from autoproj's configuration directory or one of its subdirectories"
                end

                # We must switch to the root dir first, as it is required by the
                # configuration switch code. This is acceptable as long as we
                # quit just after the switch
                Dir.chdir(Autoproj.root_dir)
                if switch_config(*remaining_args)
                    Autobuild.do_update = true
                    Autobuild.do_build  = false
                    @update_os_dependencies = false
                    @only_config = true
                    remaining_args.clear
                else
                    exit 0
                end

            when "reconfigure"
                Autoproj.reconfigure = true
                Autobuild.do_update = false
                Autobuild.do_build  = false
                @update_os_dependencies = false

            when "fast-build"
                Autobuild.do_update = false
                Autobuild.do_build  = true
                @update_os_dependencies = false
            when "build"
                Autobuild.do_update = nil
                Autobuild.do_build  = true
                @update_os_dependencies = nil
            when "force-build"
                Autobuild.do_update = nil
                Autobuild.do_build  = true
                @update_os_dependencies = nil
                Autobuild.do_forced_build = true
            when "rebuild"
                Autobuild.do_update = nil
                Autobuild.do_build  = true
                @update_os_dependencies = nil
                Autobuild.do_rebuild = true
            when "full-build"
                Autobuild.do_update = true
                Autobuild.do_build  = true
                @update_os_dependencies = true
            when "snapshot"
                @snapshot_dir = remaining_args.shift
                Autobuild.do_update = false
                Autobuild.do_build  = false
                @update_os_dependencies = false
            when "update"
                Autobuild.do_update = true
                Autobuild.do_build  = false
                @update_os_dependencies = true
            when "check"
                Autobuild.do_update = false
                Autobuild.do_build  = false
                @update_os_dependencies = false
                @check = true
            when "manifest-update"
                Autobuild.do_update = false
                Autobuild.do_build  = false
                @update_os_dependencies = false
                @manifest_update = true
            when "osdeps"
                Autobuild.do_update = false
                Autobuild.do_build  = false
                @update_os_dependencies = true
            when "status"
                Autobuild.do_update = false
                Autobuild.do_build  = false
                @update_os_dependencies = false
                @only_status = true
            when "envsh"
                Autobuild.do_update = false
                Autobuild.do_build  = false
                @update_os_dependencies = false
            when "update-config"
                Autobuild.do_update = true
                Autobuild.do_build  = false
                @update_os_dependencies = false
                @only_config = true
            when "list-config"
                Autobuild.do_update = false
                Autobuild.do_build  = false
                @update_os_dependencies = false
                @only_config = true
                @display_configuration = true
            when "doc"
                Autobuild.do_update = false
                Autobuild.do_build  = false
                @update_os_dependencies = false
                Autobuild.do_doc    = true
                Autobuild.only_doc  = true
            when "list-unused"
                Autobuild.do_update = false
                Autobuild.do_build  = false
                @update_os_dependencies = false
            else
                throw :unknown, true
            end
            nil
        end

        StatusResult = Struct.new :uncommitted, :local, :remote
        def self.display_status(packages)
            last_was_in_sync = false
            result = StatusResult.new

            packages.each do |pkg|
                lines = []

                pkg_name =
                    if pkg.respond_to?(:text_name)
                        pkg.text_name
                    else pkg.autoproj_name
                    end

                if !pkg.importer
                    lines << Autoproj.color("  is a local-only package (no VCS)", :bold, :red)
                elsif !pkg.importer.respond_to?(:status)
                    lines << Autoproj.color("  the #{pkg.importer.class.name.gsub(/.*::/, '')} importer does not support status display", :bold, :red)
                elsif !File.directory?(pkg.srcdir)
                    lines << Autoproj.color("  is not imported yet", :magenta)
                else
                    status = pkg.importer.status(pkg,@only_local)
                    if status.uncommitted_code
                        lines << Autoproj.color("  contains uncommitted modifications", :red)
                        result.uncommitted = true
                    end

                    case status.status
                    when Autobuild::Importer::Status::UP_TO_DATE
                        if !status.uncommitted_code
                            if last_was_in_sync
                                STDERR.print ", #{pkg_name}"
                            else
                                STDERR.print pkg_name
                            end
                            last_was_in_sync = true
                            next
                        else
                            lines << Autoproj.color("  local and remote are in sync", :green)
                        end
                    when Autobuild::Importer::Status::ADVANCED
                        result.local = true
                        lines << Autoproj.color("  local contains #{status.local_commits.size} commit that remote does not have:", :magenta)
                        status.local_commits.each do |line|
                            lines << Autoproj.color("    #{line}", :magenta)
                        end
                    when Autobuild::Importer::Status::SIMPLE_UPDATE
                        result.remote = true
                        lines << Autoproj.color("  remote contains #{status.remote_commits.size} commit that local does not have:", :magenta)
                        status.remote_commits.each do |line|
                            lines << Autoproj.color("    #{line}", :magenta)
                        end
                    when Autobuild::Importer::Status::NEEDS_MERGE
                        result.local  = true
                        result.remote = true
                        lines << Autoproj.color("  local and remote have diverged with respectively #{status.local_commits.size} and #{status.remote_commits.size} commits each", :magenta)
                        lines << "  -- local commits --"
                        status.local_commits.each do |line|
                            lines << Autoproj.color("   #{line}", :magenta)
                        end
                        lines << "  -- remote commits --"
                        status.remote_commits.each do |line|
                            lines << Autoproj.color("   #{line}", :magenta)
                        end
                    end
                end

                if last_was_in_sync
                    Autoproj.progress(": local and remote are in sync", :green)
                end

                last_was_in_sync = false
                STDERR.print "#{pkg_name}:"

                if lines.size == 1
                    Autoproj.progress lines.first
                else
                    Autoproj.progress
                    Autoproj.progress lines.join("\n")
                end
            end
            if last_was_in_sync
                Autoproj.progress(": local and remote are in sync", :green)
            end
            return result
        end

        def self.status(packages)
            console = Autoproj.console
            
            sources = Autoproj.manifest.each_configuration_source.
                map do |vcs, text_name, local_dir|
                    Autoproj::Manifest.create_autobuild_package(vcs, text_name, local_dir)
                end

            if !sources.empty?
                Autoproj.progress("autoproj: displaying status of configuration", :bold)
                display_status(sources)
                STDERR.puts
            end


            Autoproj.progress("autoproj: displaying status of packages", :bold)
            packages = packages.sort.map do |pkg_name|
                Autobuild::Package[pkg_name]
            end
            display_status(packages)
        end

        def self.switch_config(*args)
            Autoproj.load_config
            if Autoproj.has_config_key?('manifest_source')
                vcs = VCSDefinition.from_raw(Autoproj.user_config('manifest_source'))
            end

            if args.first =~ /^(\w+)=/
                # First argument is an option string, we are simply setting the
                # options without changing the type/url
                type, url = vcs.type, vcs.url
            else
                type, url = args.shift, args.shift
            end
            options = args

            url = VCSDefinition.to_absolute_url(url)

            if vcs && (vcs.type == type && vcs.url == url)
                # Don't need to do much: simply change the options and save the config
                # file, the VCS handler will take care of the actual switching
                vcs_def = Autoproj.user_config('manifest_source')
                options.each do |opt|
                    opt_name, opt_value = opt.split('=')
                    vcs_def[opt_name] = opt_value
                end
                # Validate the VCS definition, but save the hash as-is
                VCSDefinition.from_raw(vcs_def)
                Autoproj.change_option "manifest_source", vcs_def.dup, true
                Autoproj.save_config
                true

            else
                # We will have to delete the current autoproj directory. Ask the user.
                opt = Autoproj::BuildOption.new("delete current config", "boolean",
                            Hash[:default => "false",
                                :doc => "delete the current configuration ? (required to switch)"], nil)

                return if !opt.ask(nil)

                Dir.chdir(Autoproj.root_dir) do
                    do_switch_config(true, type, url, *options)
                end
                false
            end
        end

        def self.do_switch_config(delete_current, type, url, *options)
            vcs_def = Hash.new
            vcs_def[:type] = type
            vcs_def[:url]  = VCSDefinition.to_absolute_url(url)
            options.each do |opt|
                name, value = opt.split("=")
                vcs_def[name] = value
            end

            vcs = VCSDefinition.from_raw(vcs_def)

            # Install the OS dependencies required for this VCS
	    Autoproj::OSDependencies.define_osdeps_mode_option
            osdeps = Autoproj::OSDependencies.load_default
            osdeps.osdeps_mode
            osdeps.install([vcs.type])

            # Now check out the actual configuration
            config_dir = File.join(Dir.pwd, "autoproj")
            if delete_current
                # Find a backup name for it
                backup_base_name = backup_name = "#{config_dir}.bak"
                index = 0
                while File.directory?(backup_name)
                    backup_name = "#{backup_base_name}-#{index}.bak"
                    index += 1
                end
                    
                FileUtils.mv config_dir, backup_name
            end
            Autoproj::Manifest.update_package_set(vcs, "autoproj main configuration", config_dir)

            # If the new tree has a configuration file, load it and set
            # manifest_source
            Autoproj.load_config

            # And now save the options: note that we keep the current option set even
            # though we switched configuration. This is not a problem as undefined
            # options will not be reused
            #
            # TODO: cleanup the options to only keep the relevant ones
            vcs_def = Hash['type' => type, 'url' => url]
            options.each do |opt|
                opt_name, opt_val = opt.split '='
                vcs_def[opt_name] = opt_val
            end
            # Validate the option hash, just in case
            VCSDefinition.from_raw(vcs_def)
            # Save the new options
            Autoproj.change_option "manifest_source", vcs_def.dup, true
            Autoproj.save_config

        rescue Exception => e
            Autoproj.error "switching configuration failed: #{e.message}"
            if backup_name
                Autoproj.error "restoring old configuration"
                FileUtils.rm_rf config_dir if config_dir
                FileUtils.mv backup_name, config_dir
            end
            raise
        ensure
            if backup_name
                FileUtils.rm_rf backup_name
            end
        end

        def self.bootstrap(*args)
            if File.exists?(File.join("autoproj", "manifest"))
                raise ConfigError.new, "this installation is already bootstrapped. Remove the autoproj directory if it is not the case"
            end

            require 'set'
            curdir_entries = Dir.entries('.').to_set - [".", "..", "autoproj_bootstrap", ".gems", 'env.sh'].to_set
            if !curdir_entries.empty? && ENV['AUTOPROJ_BOOTSTRAP_IGNORE_NONEMPTY_DIR'] != '1'
                while true
                    print "The current directory is not empty, continue bootstrapping anyway ? [yes] "
                    STDOUT.flush
                    answer = STDIN.readline.chomp
                    if answer == "no"
                        exit
                    elsif answer == "" || answer == "yes"
                        # Set this environment variable since we might restart
                        # autoproj later on.
                        ENV['AUTOPROJ_BOOTSTRAP_IGNORE_NONEMPTY_DIR'] = '1'
                        break
                    else
                        STDOUT.puts "invalid answer. Please answer 'yes' or 'no'"
                        STDOUT.flush
                    end
                end
            end

            Autobuild.logdir = File.join(Autoproj.prefix, 'log')

            # Check if GEM_HOME is set. If it is the case, assume that we are
            # bootstrapping from another installation directory and start by
            # copying the .gems directory
            #
            # We don't use Autoproj.gem_home there as we might not be in an
            # autoproj directory at all
            gem_home = ENV['AUTOPROJ_GEM_HOME'] || File.join(Dir.pwd, ".gems")
            if ENV['GEM_HOME'] && Autoproj.in_autoproj_installation?(ENV['GEM_HOME']) &&
                ENV['GEM_HOME'] != gem_home
                if !File.exists?(gem_home)
                    Autoproj.progress "autoproj: reusing bootstrap from #{File.dirname(ENV['GEM_HOME'])}"
                    FileUtils.cp_r ENV['GEM_HOME'], gem_home
                end
                ENV['GEM_HOME'] = gem_home

                Autoproj.progress "restarting bootstrapping from #{Dir.pwd}"

                require 'rbconfig'
                ruby = RbConfig::CONFIG['RUBY_INSTALL_NAME']
                exec ruby, $0, *ARGV
            end

            # If we are not getting the installation setup from a VCS, copy the template
            # files
            if args.empty? || args.size == 1
                sample_dir = File.expand_path(File.join("..", "..", "samples"), File.dirname(__FILE__))
                FileUtils.cp_r File.join(sample_dir, "autoproj"), "autoproj"
            end

            if args.size == 1 # the user asks us to download a manifest
                manifest_url = args.first
                Autoproj.progress("autoproj: downloading manifest file #{manifest_url}", :bold)
                manifest_data =
                    begin open(manifest_url) { |file| file.read }
                    rescue
                        # Delete the autoproj directory
                        FileUtils.rm_rf 'autoproj'
                        raise ConfigError.new, "cannot read #{manifest_url}, did you mean 'autoproj bootstrap VCSTYPE #{manifest_url}' ?"
                    end

                File.open(File.join(Autoproj.config_dir, "manifest"), "w") do |io|
                    io.write(manifest_data)
                end

            elsif args.size >= 2 # is a VCS definition for the manifest itself ...
                type, url, *options = *args
                url = VCSDefinition.to_absolute_url(url, Dir.pwd)
                do_switch_config(false, type, url, *options)
            end

            Autoproj.save_config

            # Finally, generate an env.sh script
            File.open('env.sh', 'w') do |io|
                io.write <<-EOSHELL
export RUBYOPT=-rubygems
export GEM_HOME=#{Autoproj.gem_home}
export PATH=$GEM_HOME/bin:$PATH
                EOSHELL
            end
        end

        def self.missing_dependencies(pkg)
            manifest = Autoproj.manifest.package_manifests[pkg.name]
            all_deps = pkg.dependencies.map do |dep_name|
                dep_pkg = Autobuild::Package[dep_name]
                if dep_pkg then dep_pkg.name
                else dep_name
                end
            end

            if manifest
                declared_deps = manifest.each_dependency.to_a
                missing = all_deps - declared_deps
            else
                missing = all_deps
            end

            missing.to_set.to_a.sort
        end

        # Verifies that each package's manifest is up-to-date w.r.t. the
        # automatically-detected dependencies
        #
        # Only useful for package types that do some automatic dependency
        # detection
        def self.check(packages)
            packages.sort.each do |pkg_name|
                result = []

                pkg = Autobuild::Package[pkg_name]
                manifest = Autoproj.manifest.package_manifests[pkg.name]

                # Check if the manifest contains rosdep tags
                # if manifest && !manifest.each_os_dependency.to_a.empty?
                #     result << "uses rosdep tags, convert them to normal <depend .../> tags"
                # end

                missing = missing_dependencies(pkg)
                if !missing.empty?
                    result << "missing dependency tags for: #{missing.join(", ")}"
                end

                if !result.empty?
                    Autoproj.progress pkg.name
                    Autoproj.progress "  #{result.join("\n  ")}"
                end
            end
        end

        def self.manifest_update(packages)
            packages.sort.each do |pkg_name|
                pkg = Autobuild::Package[pkg_name]
                manifest = Autoproj.manifest.package_manifests[pkg.name]

                xml = 
                    if !manifest
                        Nokogiri::XML::Document.parse("<package></package>") do |c|
                            c.noblanks
                        end
                    else
                        manifest.xml.dup
                    end

                # Add missing dependencies
                missing = missing_dependencies(pkg)
                if !missing.empty?
                    package_node = xml.xpath('/package').to_a.first
                    missing.each do |pkg_name|
                        node = Nokogiri::XML::Node.new("depend", xml)
                        node['package'] = pkg_name
                        package_node.add_child(node)
                    end
                    modified = true
                end

                # Save the manifest back
                if modified
                    path = File.join(pkg.srcdir, 'manifest.xml')
                    File.open(path, 'w') do |io|
                        io.write xml.to_xml
                    end
                    if !manifest
                        Autoproj.progress "created #{path}"
                    else
                        Autoproj.progress "modified #{path}"
                    end
                end
            end
        end

        def self.snapshot(target_dir, packages)
            # First, copy the configuration directory to create target_dir
            if File.exists?(target_dir)
                raise ArgumentError, "#{target_dir} already exists"
            end
            FileUtils.cp_r Autoproj.config_dir, target_dir

            # Now, create snapshot information for each of the packages
            version_control = []
            packages.each do |package_name|
                package  = Autobuild::Package[package_name]
                importer = package.importer
                if !importer
                    Autoproj.progress "cannot snapshot #{package_name} as it has no importer"
                    next
                elsif !importer.respond_to?(:snapshot)
                    Autoproj.progress "cannot snapshot #{package_name} as the #{importer.class} importer does not support it"
                    next
                end

                vcs_info = importer.snapshot(package, target_dir)
                if vcs_info
                    version_control << Hash[package_name, vcs_info]
                end
            end

            overrides_path = File.join(target_dir, 'overrides.yml')
            if File.exists?(overrides_path)
                overrides = YAML.load(File.read(overrides_path))
            end
            # In Ruby 1.9, an empty file results in YAML.load returning false
            overrides ||= Hash.new

            if overrides['overrides']
                overrides['overrides'].concat(version_control)
            else
                overrides['overrides'] = version_control
            end

            File.open(overrides_path, 'w') do |io|
                io.write YAML.dump(overrides)
            end
        end

        # Displays the reverse OS dependencies (i.e. for each osdeps package,
        # who depends on it and where it is defined)
        def self.revshow_osdeps(packages)
            _, ospkg_to_pkg = Autoproj.manifest.list_os_dependencies(packages)

            # A mapping from a package name to
            #   [is_os_pkg, is_gem_pkg, definitions, used_by]
            #
            # where 
            #
            # +used_by+ is the set of autobuild package names that use this
            # osdeps package
            #
            # +definitions+ is a osdep_name => definition_file mapping
            mapping = Hash.new { |h, k| h[k] = [false, false, Hash.new, Set.new] }

            ospkg_to_pkg.each do |pkg_osdep, pkgs|
                osdeps, gems = Autoproj.osdeps.
                    partition_packages([pkg_osdep])

                gems.each do |gem_name|
                    mapping[gem_name.join(" ")][1] = true
                    mapping[gem_name.join(" ")][2][pkg_osdep] = Autoproj.osdeps.source_of(pkg_osdep)
                    mapping[gem_name.join(" ")][3] |= pkgs
                end

                if Autoproj::OSDependencies.supported_operating_system?
                    osdeps = Autoproj.osdeps.
                        resolve_os_dependencies(osdeps)
                end
                osdeps.each do |ospkg_name|
                    mapping[ospkg_name][0] = true
                    mapping[ospkg_name][2][pkg_osdep] = Autoproj.osdeps.source_of(pkg_osdep)
                    mapping[ospkg_name][3] |= pkgs
                end
            end

            mapping = mapping.sort_by(&:first)
            mapping.each do |pkg_name, (is_os_pkg, is_gem_pkg, definitions, used_by)|
                kind = if is_os_pkg && is_gem_pkg
                           "both a RubyGem and OS package"
                       elsif is_os_pkg
                           "an OS package"
                       else
                           "a RubyGem package"
                       end

                puts "#{pkg_name} is #{kind}"
                definitions.to_a.
                    sort_by(&:first).
                    each do |osdep_name, file_name|
                        puts "  defined as #{osdep_name} in #{file_name}"
                    end

                puts "  depended-upon by #{used_by.sort.join(", ")}"
            end
        end

        # Displays the OS dependencies required by the given packages
        def self.show_osdeps(packages)
            _, ospkg_to_pkg = Autoproj.manifest.list_os_dependencies(packages)

            # ospkg_to_pkg is the reverse mapping to what we want. Invert it
            mapping = Hash.new { |h, k| h[k] = Set.new }
            ospkg_to_pkg.each do |ospkg, pkgs|
                pkgs.each do |pkg_name|
                    mapping[pkg_name] << ospkg
                end
            end
        
            # Now sort it by package name (better for display)
            package_osdeps = mapping.to_a.
                sort_by { |name, _| name }

            package_osdeps.each do |pkg_name, pkg_osdeps|
                if pkg_osdeps.empty?
                    puts "  #{pkg_name}: no OS dependencies"
                    next
                end

                osdeps, gems = Autoproj.osdeps.
                    partition_packages(pkg_osdeps)

                puts "  #{pkg_name}:"
                if !gems.empty?
                    puts "    RubyGem packages: #{gems.to_a.sort.join(", ")}"
                end

                # If we are on a supported OS, convert the osdeps name to plain
                # package name
                if Autoproj::OSDependencies.supported_operating_system?
                    pkg_osdeps = Autoproj.osdeps.
                        resolve_os_dependencies(osdeps)

                    if !pkg_osdeps.empty?
                        puts "    OS packages:      #{pkg_osdeps.to_a.sort.join(", ")}"
                    end
                else
                    if !os_packages.empty?
                        puts "    OS dependencies:  #{os_packages.to_a.sort.join(", ")}"
                    end
                end
            end
        end

        # This method sets up autoproj and loads the configuration available in
        # the current autoproj installation. It is meant as a simple way to
        # initialize an autoproj environment for standalone tools
        #
        # Beware, it changes the current directory to the autoproj root dir
        def self.initialize_and_load(cmdline_arguments = ARGV.dup)
            require 'autoproj/autobuild'
            require 'open-uri'
            require 'autoproj/cmdline'

            remaining_arguments = Autoproj::CmdLine.
                parse_arguments(cmdline_arguments, false)
            Dir.chdir(Autoproj.root_dir)

            Autoproj::CmdLine.update_os_dependencies = false
            Autoproj::CmdLine.initialize
            Autoproj::CmdLine.update_configuration
            Autoproj::CmdLine.load_configuration
            Autoproj::CmdLine.setup_all_package_directories
            Autoproj::CmdLine.finalize_package_setup

            # Load the manifest for packages that are already present on the
            # file system
            manifest.packages.each_value do |pkg|
                if File.directory?(pkg.autobuild.srcdir)
                    manifest.load_package_manifest(pkg.autobuild.name)
                end
            end
            remaining_arguments
        end

        def self.initialize_root_directory
            Autoproj.root_dir
        rescue Autoproj::UserError => error
            if ENV['GEM_HOME']
                Dir.chdir(File.join(ENV['GEM_HOME'], '..'))
                begin Autoproj.root_dir
                rescue Autoproj::UserError
                    raise error
                end
            else
                raise
            end
        end

        def self.list_unused(all_enabled_packages)
            all_enabled_packages = all_enabled_packages.map do |pkg_name|
                Autobuild::Package[pkg_name]
            end
            leaf_dirs = (all_enabled_packages.map(&:srcdir) +
                all_enabled_packages.map(&:prefix)).to_set
            leaf_dirs << Autoproj.config_dir
            leaf_dirs << Autoproj.gem_home
            leaf_dirs << Autoproj.remotes_dir

            root = Autoproj.root_dir
            all_dirs = leaf_dirs.dup
            leaf_dirs.each do |dir|
                dir = File.dirname(dir)
                while dir != root
                    break if all_dirs.include?(dir)
                    all_dirs << dir
                    dir = File.dirname(dir)
                end
            end
            all_dirs << Autoproj.root_dir

            unused = Set.new
            Find.find(Autoproj.root_dir) do |path|
                next if !File.directory?(path)
                if !all_dirs.include?(path)
                    unused << path
                    Find.prune
                elsif leaf_dirs.include?(path)
                    Find.prune
                end
            end


            root = Pathname.new(Autoproj.root_dir)
            Autoproj.progress
            Autoproj.progress "The following directories are not part of a package used in the current autoproj installation", :bold
            unused.to_a.sort.each do |dir|
                puts "  #{Pathname.new(dir).relative_path_from(root)}"
            end
        end
    end
end