module AsProject

  #######################################
  # ProjectArguments
  class ProjectArguments < Hash
    attr_accessor :path_finder, :selected_templates, :execution_dir, 
                  :default_templates, :default_home_templates, :project_templates, 
                  :copy_to_home, :copy_to_project, :project_name, :verbose,
                  :should_create

    def initialize
      self[:project_name]              = ''
      self[:copy_to_project]           = false
      self[:copy_to_home]              = false
      self[:default_templates]         = false
      self[:default_home_templates]    = false
      self[:force]                     = false
      self[:should_create]             = true
      self[:verbose]                   = true
      self[:selected_templates]        = []
    end
    
    def parse!(args)
      if(@path_finder.nil?)
        raise ProjectError.new('ProjectArguments needs a path_finder in order to work properly')
      end
    
      opts = OptionParser.new do |opts|
        opts.banner = <<EOF

Usage: #$0 [options] ProjectName

Project templates are easily modified and extended, if the files and directories created aren't exactly what you want, use the -c or -C option and edit the templates in your current project or your home path.

Using -c will place templates in:
#{Dir.pwd}/(ProjectName)/config/templates 

Using -C will place templates in:
#{@path_finder.user_asproject_home}
(Changes will impact all projects that don't have local templates)

Using -t requires one or more project templates. These values are passed in as a comma-delimited string.
Available choices for this particular installation are: #{@project_templates.join(', ')}

Templates will be used when found in the first folder of the following list:
1) ./{ProjectName}/config/templates
2) #{@path_finder.user_asproject_home}/templates
3) #{@path_finder.gem_asproject_home}/templates

Options:
EOF
        opts.on('-c', '--copy-templates', "Copy templates to {ProjectName}/config/templates") do
          self[:copy_to_project] = true
        end

        opts.on('-C', '--copy-templates-to-home', "Copy templates to this user account") do
          self[:copy_to_home] = true
        end

#        opts.on('-d', '--default-templates', "Set default templates for this project eg: 'mxml,fb2mxml,asunit'") do
#          self[:default_templates] = true
#        end
#
#        opts.on('-D', '--default-templates-to-home', "Set the default templates for this user account") do
#          self[:default_home_templates] = true
#        end

        opts.on('-f', '--force', "Force creation - overwrite if necessary") do
          self[:force] = true
        end

        opts.on('-q', '--quiet', "Do not display created file names") do
          self[:verbose] = false
        end

        opts.on('-t', '--template(s) [STRING]', "Define which project template(s) to use.") do |str|
          # Handle space-delimited vs comma-delimited? Do I need to do this?
          self[:selected_templates] = process_templates(str)
        end

        opts.on_tail('-h', '--help', 'display this help and exit') do
          puts opts
          exit
        end
      
        if(args.length == 0)
          puts ''
          puts "[WARNING] Please enter a name for your new project, or use the 'c', 'C', 'd' or 'D' options"
          puts opts
          exit
        end
      end
      opts.parse!(args)
      
      if(self[:should_create])
        while(args.size > 1)
          self[:selected_templates] << args.shift
        end
        self[:project_name] = clean_name(args.shift.to_s)
      else
        while(args.size > 0)
          self[:selected_templates] << args.shift
        end
      end
      if(self[:selected_templates].size == 0)
        self[:selected_templates] = @default_templates
      end
      verify_templates(self[:selected_templates])
    end
  
    def process_templates(str)
      str = str.split(', ').join(',')
      if(!str.index(' ').nil? && str.index(',').nil?)
        templates = str.split(' ')
      else
        templates = str.split(',')
      end
    end
    
    def verify_templates(templates)
      templates.each do |template|
        if(!@project_templates.index template)
          msg = <<EOF

Template [#{template}] was not found! 

Please try again with one of the following available templates:
#{@project_templates.join(', ')}
EOF
          raise ProjectError.new(msg)
        end
      end
    end
    
    def clean_name(name)
      if(name.index("/") || name.index("."))
        raise ProjectError.new('Project Name must not contain slashes or dots')
      end
      return name
    end
                      
    def project_name
      return self[:project_name]
    end
    
    def selected_templates
      return self[:selected_templates]
    end
    
    def default_templates
      return self[:default_templates]
    end
    
    def default_home_templates
      return self[:default_home_templates]
    end
    
    def copy_to_home
      return self[:copy_to_home]
    end
    
    def copy_to_project
      return self[:copy_to_project]
    end
    
    def verbose
      return self[:verbose]
    end
    
    def force?
      return self[:force]
    end
  end
end