require 'optparse'
require 'cucumber'
require 'ostruct'

module Cucumber
  class YmlLoadError < StandardError; end

  class CLI
    class << self
      attr_writer :step_mother, :executor, :features

      def execute(args)
        @execute_called = true
        parse(args).execute!(@step_mother, @executor, @features)
      end

      def execute_called?
        @execute_called
      end

      def parse(args)
        cli = new
        cli.parse_options!(args)
        cli
      end
    end

    attr_reader :options, :paths
    FORMATS = %w{pretty profile progress html autotest}
    DEFAULT_FORMAT = 'pretty'

    def initialize(out_stream = STDOUT, error_stream = STDERR)
      @out_stream = out_stream
      @error_stream = error_stream
      @paths = []
      @options = {
        :require => nil,
        :lang    => 'en',
        :dry_run => false,
        :source  => true,
        :snippets => true,
        :formats => {},
        :excludes => [],
        :scenario_names => nil
      }
      @active_format = DEFAULT_FORMAT
    end

    def parse_options!(args)
      @args = args
      return parse_args_from_profile('default') if args.empty?
      args.extend(OptionParser::Arguable)

      args.options do |opts|
        opts.banner = ["Usage: cucumber [options] [[FILE[:LINE[:LINE]*]] | [FILES|DIRS]]", "",
          "Examples:",
          "cucumber examples/i18n/en/features",
          "cucumber --language it examples/i18n/it/features/somma.feature:6:98:113", "", ""
        ].join("\n")
        opts.on("-r LIBRARY|DIR", "--require LIBRARY|DIR", "Require files before executing the features.",
          "If this option is not specified, all *.rb files that",
          "are siblings or below the features will be autorequired",
          "This option can be specified multiple times.") do |v|
          @options[:require] ||= []
          @options[:require] << v
        end
        opts.on("-s SCENARIO", "--scenario SCENARIO", "Only execute the scenario with the given name.",
                                                      "If this option is given more than once, run all",
                                                      "the specified scenarios.") do |v|
          @options[:scenario_names] ||= []
          @options[:scenario_names] << v
        end
        opts.on("-l LANG", "--language LANG", "Specify language for features (Default: #{@options[:lang]})",
          "Available languages: #{Cucumber.languages.join(", ")}",
          "Look at #{Cucumber::LANGUAGE_FILE} for keywords") do |v|
          @options[:lang] = v
        end
        opts.on("-f FORMAT", "--format FORMAT", "How to format features (Default: #{DEFAULT_FORMAT})",
          "Available formats: #{FORMATS.join(", ")}",
          "You can also provide your own formatter classes as long as they have been",
          "previously required using --require or if they are in the folder",
          "structure such that cucumber will require them automatically.",
          "This option can be specified multiple times.") do |v|
  
          @options[:formats][v] ||= []
          @options[:formats][v] << @out_stream
          @active_format = v
        end
        opts.on("-o", "--out FILE", "Write output to a file instead of @out_stream.",
          "This option can be specified multiple times, and applies to the previously",
          "specified --format.") do |v|
          @options[:formats][@active_format] ||= []
          if @options[:formats][@active_format].last == @out_stream
            @options[:formats][@active_format][-1] = File.open(v, 'w')
          else
            @options[:formats][@active_format] << File.open(v, 'w')
          end
        end
        opts.on("-c", "--[no-]color", "Use ANSI color in the output, if formatters use it.  If",
                                      "these options are given multiple times, the last one is",
                                      "used.  If neither --color or --no-color is given cucumber",
                                      "decides based on your platform and the output destination") do |v|
          @options[:color] = v
        end
        opts.on("-e", "--exclude PATTERN", "Don't run features matching a pattern") do |v|
          @options[:excludes] << v
        end
        opts.on("-p", "--profile PROFILE", "Pull commandline arguments from cucumber.yml.") do |v|
          parse_args_from_profile(v)
        end
        opts.on("-d", "--dry-run", "Invokes formatters without executing the steps.") do
          @options[:dry_run] = true
        end
        opts.on("-n", "--no-source", "Don't show the file and line of the step definition with the steps.") do
          @options[:source] = false
        end
        opts.on("-i", "--no-snippets", "Don't show the snippets for pending steps") do
          @options[:snippets] = false
        end
        opts.on("-q", "--quiet", "Don't show any development aid information") do
          @options[:snippets] = false
          @options[:source] = false
        end
        opts.on("-b", "--backtrace", "Show full backtrace for all errors") do
          Exception.cucumber_full_backtrace = true
        end
        opts.on("-v", "--verbose", "Show the files and features loaded") do
          @options[:verbose] = true
        end
        opts.on_tail("--version", "Show version") do
          @out_stream.puts VERSION::STRING
          Kernel.exit
        end
        opts.on_tail("--help", "You're looking at it") do
          @out_stream.puts opts.help
          Kernel.exit
        end
      end.parse!

      if @options[:formats].empty?
        @options[:formats][DEFAULT_FORMAT] = [@out_stream]
      end
      
      # Whatever is left after option parsing is the FILE arguments
      args = extract_and_store_line_numbers(args)
      @paths += args
    end


    def execute!(step_mother, executor, features)
      Term::ANSIColor.coloring = @options[:color] unless @options[:color].nil?
      Cucumber.load_language(@options[:lang])
      require_files
      enable_diffing
      executor.formatters = build_formatter_broadcaster(step_mother)
      load_plain_text_features(features)
      executor.lines_for_features = @options[:lines_for_features]
      executor.scenario_names = @options[:scenario_names] if @options[:scenario_names]
      executor.visit_features(features)
      exit 1 if executor.failed
    end

    private

    def extract_and_store_line_numbers(file_arguments)
      @options[:lines_for_features] = Hash.new{|k,v| k[v] = []}
      file_arguments.map do |arg|
        _, file, lines = */^([\w\W]*?):([\d:]+)$/.match(arg)
        unless file.nil?
          @options[:lines_for_features][file] += lines.split(':').map { |line| line.to_i }
          arg = file          
        end
        arg
      end
    end
   
    def cucumber_yml
      return @cucumber_yml if @cucumber_yml
      unless File.exist?('cucumber.yml')
        raise(YmlLoadError,"cucumber.yml was not found.  Please refer to cucumber's documentaion on defining profiles in cucumber.yml.  You must define a 'default' profile to use the cucumber command without any arguments.\nType 'cucumber --help' for usage.\n")
      end
      
      require 'yaml'
      begin
        @cucumber_yml = YAML::load(IO.read('cucumber.yml'))
      rescue Exception => e
        raise(YmlLoadError,"cucumber.yml was found, but could not be parsed. Please refer to cucumber's documentaion on correct profile usage.\n")
       end
     
      if @cucumber_yml.nil? || !@cucumber_yml.is_a?(Hash)
        raise(YmlLoadError,"cucumber.yml was found, but was blank or malformed. Please refer to cucumber's documentaion on correct profile usage.\n")
      end

      return @cucumber_yml
    end 

    def parse_args_from_profile(profile)
      unless cucumber_yml.has_key?(profile)
        return(exit_with_error <<-END_OF_ERROR)
Could not find profile: '#{profile}'

Defined profiles in cucumber.yml:
  * #{cucumber_yml.keys.join("\n  * ")}
        END_OF_ERROR
      end

      args_from_yml = cucumber_yml[profile] || ''

      if !args_from_yml.is_a?(String)
        exit_with_error "Profiles must be defined as a String.  The '#{profile}' profile was #{args_from_yml.inspect} (#{args_from_yml.class}).\n"
      elsif args_from_yml =~ /^\s*$/
        exit_with_error "The 'foo' profile in cucumber.yml was blank.  Please define the command line arguments for the 'foo' profile in cucumber.yml.\n"
      else
        parse_options!(args_from_yml.split(' '))
      end
      
    rescue YmlLoadError => e
      exit_with_error(e.message)
    end


    # Requires files - typically step files and ruby feature files.
    def require_files
      @args.clear # Shut up RSpec
      require "cucumber/treetop_parser/feature_#{@options[:lang]}"
      require "cucumber/treetop_parser/feature_parser"

      verbose_log("Ruby files required:")
      files_to_require.each do |lib|
        begin
          require lib
          verbose_log("  * #{lib}")
        rescue LoadError => e
          e.message << "\nFailed to load #{lib}"
          raise e
        end
      end
      verbose_log("\n")
    end
    
    def files_to_require
      requires = @options[:require] || feature_dirs
      files = requires.map do |path|
        path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
        File.directory?(path) ? Dir["#{path}/**/*.rb"] : path
      end.flatten.uniq
      files.sort { |a,b| (b =~ %r{/support/} || -1) <=>  (a =~ %r{/support/} || -1) }
    end

    def feature_files
      potential_feature_files = @paths.map do |path|
        path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
        path = path.chomp('/')
        File.directory?(path) ? Dir["#{path}/**/*.feature"] : path
      end.flatten.uniq

      @options[:excludes].each do |exclude|
        potential_feature_files.reject! do |path|
          path =~ /#{Regexp.escape(exclude)}/
        end
      end

      potential_feature_files
    end

    def feature_dirs
      feature_files.map{|f| File.directory?(f) ? f : File.dirname(f)}.uniq
    end

    def load_plain_text_features(features)
      parser = TreetopParser::FeatureParser.new

      verbose_log("Features:")
      feature_files.each do |f|
        features << parser.parse_feature(f)
        verbose_log("  * #{f}")
      end
      verbose_log("\n"*2)
    end

    def build_formatter_broadcaster(step_mother)
      formatter_broadcaster = Broadcaster.new
      @options[:formats].each do |format, output_list|
        output_broadcaster = build_output_broadcaster(output_list)
        case format
        when 'pretty'
          formatter_broadcaster.register(Formatters::PrettyFormatter.new(output_broadcaster, step_mother, @options))
        when 'progress'
          formatter_broadcaster.register(Formatters::ProgressFormatter.new(output_broadcaster))
        when 'profile'
          formatter_broadcaster.register(Formatters::ProfileFormatter.new(output_broadcaster, step_mother))
        when 'html'
          formatter_broadcaster.register(Formatters::HtmlFormatter.new(output_broadcaster, step_mother))
        when 'autotest'
          formatter_broadcaster.register(Formatters::AutotestFormatter.new(output_broadcaster))
        else
          begin
            formatter_class = constantize(format)
            formatter_broadcaster.register(formatter_class.new(output_broadcaster, step_mother, @options))
          rescue NameError => e
            @error_stream.puts "Invalid format: #{format}\n"
            exit_with_help
          rescue Exception => e
            exit_with_error("Error creating formatter: #{format}\n#{e}\n")
          end
        end
      end
      formatter_broadcaster
    end

    def build_output_broadcaster(output_list)
      output_broadcaster = Broadcaster.new
      output_list.each do |output|
        output_broadcaster.register(output)
      end
      output_broadcaster
    end
    
  private

    def constantize(camel_cased_word)
      names = camel_cased_word.split('::')
      names.shift if names.empty? || names.first.empty?

      constant = Object
      names.each do |name|
        constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
      end
      constant
    end
    
    def verbose_log(string)
      @out_stream.puts(string) if @options[:verbose]
    end

    def exit_with_help
      parse_options!(%w{--help})
    end

    def exit_with_error(error_message)
      @error_stream << error_message
      Kernel.exit 1
    end

    def enable_diffing
      if defined?(::Spec)
        require 'spec/expectations/differs/default'
        options = OpenStruct.new(:diff_format => :unified, :context_lines => 3)
        ::Spec::Expectations.differ = ::Spec::Expectations::Differs::Default.new(options)
      end
    end
  end
end

extend Cucumber::StepMethods
Cucumber::CLI.step_mother = step_mother
Cucumber::CLI.executor = executor

extend Cucumber::Tree
Cucumber::CLI.features = features