require 'build-tool/vcs/git'
require 'build-tool/vcs/git-svn'
require 'build-tool/vcs/svn'
require 'build-tool/vcs/archive'
require 'build-tool/vcs/mercurial'

require 'build-tool/build-system/cmake'
require 'build-tool/build-system/qt'
require 'build-tool/build-system/autoconf'
require 'build-tool/build-system/custom'
require 'build-tool/build-system/none'
require 'build-tool/build-system/kdel10n'
require 'build-tool/build-system/qmake'


module BuildTool

    class Configuration

        attr_reader :recipe
        attr_reader :modules
        attr_reader :environments
        attr_reader :features
        attr_accessor :active_feature

        def log_directory
            return @log_directory if @log_directory
            raise BuildTool::ConfigurationError, "No log directory configured"
        end
        def log_directory=( path )
            path = Pathname.new( path.sub( /\$HOME/, '~' ) )
            if path.to_s[0] != '~' and path.relative?
                raise ConfigurationError, "Log directory '#{path}' is relative!"
            end
            @log_directory = path.expand_path
        end

        def environment( name )
            @environments[name]
        end

        def add_environment( env)
            @environments[env.name] = env
        end

        def feature( name )
            @features[name]
        end

        def add_feature( feature )
            @features[feature.path] = feature
        end

        def module( name )
            @module[name]
        end

        def add_module( mod )
            @module[mod.name] = mod
            @modules << mod
        end

        def repository( name )
            @repository[name]
        end

        def add_repository( repo )
            @repository[repo.name] = repo
        end

        def server( name )
            @server[name]
        end

        def add_server( server )
            @server[ server.name ] = server
        end

        def sshkey( name )
            @sshkey[name]
        end

        def add_sshkey( key )
            @sshkey[key.name] = key
        end

        def initialize( recipe = nil )
            @recipe = recipe
            @server = {}
            @log_directory = nil
            @environments = {}
            @module = {}
            @modules = []
            @build_system = {}
            @repository = {}
            @sshkey = {}
            @active_feature = nil
            @features = {}
        end

        def vcs( name )
            case name
            when "git-svn"
                return BuildTool::VCS::GitSvnConfiguration.new
            when "git"
                return BuildTool::VCS::GitConfiguration.new
            when "svn"
                return BuildTool::VCS::SvnConfiguration.new
            when "archive"
                return BuildTool::VCS::ArchiveConfiguration.new
            when "mercurial"
                return BuildTool::VCS::MercurialConfiguration.new
            else
                raise StandardError, "Unknown Version Control System #{name}"
            end
        end

        def create_build_system( name, parent = nil, *args )
            return case name
                when "none"
                    BuildTool::BuildSystem::None.new( parent, *args )
                when "cmake"
                    BuildTool::BuildSystem::CMake.new( parent, *args )
                when "kdel10n"
                    BuildTool::BuildSystem::KdeL10n.new( parent, *args )
                when "qt"
                    BuildTool::BuildSystem::Qt.new( parent, *args )
                when "qmake"
                    BuildTool::BuildSystem::QMake.new( parent, *args )
                when "custom"
                    BuildTool::BuildSystem::Custom.new( parent, *args )
                when "autoconf"
                    BuildTool::BuildSystem::AutoConf.new( parent, *args )
                else
                    raise StandardError, "Unknown Version Control System #{name}"
                end
        end

        def build_system_adjust( name, parent = nil, *args )
            bs = create_build_system( name, parent )
            bs.defaults = build_system_defaults( name )
            return bs
        end

        def build_system_defaults( name, *args )
            return @build_system[name] if @build_system[name]
            add_build_system( create_build_system( name ) )
        end

        def add_build_system( bs )
            return @build_system[bs.name] = bs
        end

    end # Configuration

end # module BuildTool