module Airake #:nodoc

  #
  # Project for AIR application
  #
  class Project
  
    attr_reader :base_dir, :bin_dir, :src_dir, :lib_dir, :test_dir
    attr_reader :mxml_path, :appxml_path, :air_path, :swf_path
    attr_reader :debug, :assets, :certificate
    attr_reader :build_env
    
    # Options to override defaults
    Options = [ :bin_dir, :src_dir, :lib_dir, :test_dir, 
      :appxml_path, :air_path, :swf_path, :debug, :certificate, :assets,
      :amxmlc_path, :adl_path, :adt_path, :asdoc_path, :amxmlc_extra_opts, :adl_extra_opts, :adt_extra_opts, :asdoc_extra_opts ]

    # Build project:
    #
    #   base_dir: Base (project) directory
    #   mxml_path: Path to the ProjectName.mxml (relative)
    #   options: 
    #     bin_dir: Path to generated output, defaults to 'bin'
    #     src_dir: Path to source, defaults to 'src'
    #     lib_dir: Path to lib directory, defaults to 'lib'
    #     test_dir: Path to test directory, defaults to 'test'
    #     appxml_path: Path to application descriptor, defaults to '<mxml_dir>/<ProjectName>-app.xml'. Default assumes the app xml is in same directory as the root mxml.
    #     air_path: Path to AIR file, defaults to '<bin_dir>/<ProjectName>.air'
    #     swf_path: Path to SWF file, defaults to '<bin_dir>/<ProjectName.swf'
    #     debug: "true" or "false"
    #     assets: Path to assets
    #     certificate: Path to certificate
    #     
    # Other options:
    #   :amxmlc_path, :adt_path, :adl_path, :asdoc_path, :amxmlc_extra_opts, :adt_extra_opts, :adl_extra_opts, :asdoc_extra_opts
    #     
    def initialize(base_dir, mxml_path, options = {}, build_env = :normal)
      raise ArgumentError, "Invalid MXML path: #{mxml_path}" if mxml_path.blank?
      
      mxml_dir = File.expand_path(File.dirname(mxml_path))
      project_name = File.basename(mxml_path, ".mxml")
      
      @base_dir = base_dir
      @mxml_path = File.join(mxml_dir, "#{project_name}.mxml")
      @build_env = build_env
      
      @bin_dir = options[:bin_dir] || File.join(base_dir, "bin")
      @src_dir = options[:src_dir] || File.join(base_dir, "src")
      @lib_dir = options[:lib_dir] || File.join(base_dir, "lib")
      @test_dir = options[:test_dir] || File.join(base_dir, "test")                  
      
      @appxml_path = options[:appxml_path] || File.join(mxml_dir, "#{project_name}-app.xml")
      
      # Dest package files
      @air_path = options[:air_path] || File.join(@bin_dir, "#{project_name}.air")
      @swf_path = options[:swf_path] || File.join(@bin_dir, "#{project_name}.swf")
    
      # Debug options
      @debug = options[:debug].is_a?(TrueClass) || options[:debug] == "true"                  
      
      with_keyed_options([ :assets, :certificate, :amxmlc_path, :adt_path, :adl_path, :asdoc_path, 
        :amxmlc_extra_opts, :adt_extra_opts, :adl_extra_opts, :asdoc_extra_opts ], options)
    end
    
    # Flex compiler command for this project
    def amxmlc
      src_dirs = case build_env
        when :normal then [ @src_dir ]
        when :test then [ @src_dir, @test_dir ]
        else raise "Invalid build_env setting: #{build_env}"
        end

      options = { :swf_path => @swf_path, :mxml_path => @mxml_path, :lib_dir => @lib_dir, 
        :src_dirs => src_dirs, :debug => @debug, :amxmlc_extra_opts => @amxmlc_extra_opts, 
        :amxmlc_path => @amxmlc_path }
        
      Airake::Commands::Amxmlc.new(options)
    end
    
    # ADL command for this project
    def adl
      options = { :appxml_path => @appxml_path, :base_dir => @base_dir, :adl_extra_opts => @adl_extra_opts,
        :adl_path => @adl_path }
      Airake::Commands::Adl.new(options)
    end
    
    # ADT command for this project
    def adt
      options = { :air_path => @air_path, :appxml_path => @appxml_path, :swf_path => @swf_path, 
        :base_dir => @base_dir, :assets => @assets, :certificate => @certificate, :adt_extra_opts => @adt_extra_opts,
        :adt_path => @adt_path }
      Airake::Commands::Adt.new(options)
    end
    
    # AS docs
    def asdoc
      src_dirs = [ @src_dir ]
      options = { :lib_dir => @lib_dir, :src_dirs => src_dirs, :asdoc_extra_opts => @asdoc_extra_opts,
        :asdoc_path => @asdoc_path }        
      Airake::Commands::Asdoc.new(options)
    end
    
    # List of files to remove on clean
    def to_clean
      case build_env
      when :normal then [ swf_path, air_path ]
      when :test then [ swf_path ]
      end
    end
        
    #
    # Create project using parameters from rake ENV:
    #
    #   BASE_DIR: Path to project base
    #   MXML: Path to mxml file
    #   MXML_TEST: In test environment, path to test mxml file
    # 
    # You can override any of the project options via ENV; just upcase it. <tt>:foo_bar => ENV["FOO_BAR"]</tt>
    #
    # This shouldn't really be here, but a Rakefile is a bad place to be :O
    #
    # Booleans must be "true" for true
    #
    def self.new_from_rake(env, build_env = :normal)
      base_dir = env["BASE_DIR"]
      mxml = case build_env
        when :test then env["MXML_TEST"]
        when :normal then env["MXML"]
        else raise "Invalid build env: #{build_env}"
        end
      
      # For any option check to see if its in the ENV      
      options = {}
      Options.each do |option_key|
        env_key = option_key.to_s.upcase      
        options[option_key] = env[env_key] if env.has_key?(env_key)
      end
      #puts "Using options: #{options.inspect}" unless options.empty?
      self.new(base_dir, mxml, options, build_env)
    end
    
    # Load options into instance vars
    def with_keyed_options(keys, options) 
      keys.each do |key|        
        value = options[key]
        instance_variable_set("@#{key}", value) if value
      end
    end
    
  end
  
end