require 'optparse'

Options = Struct.new(:name)

module Raykit

    class Parser
        def self.parse(options)
            hash=Hash.new
            #args = Options.new("world")

            opt_parser = OptionParser.new do |opts|
                opts.banner = "Usage: raykit [options]"
                opts.on('-l','--list [PATTERN]','list remotes') do |pattern|
                    hash[:verb]="list"
                    hash[:pattern]=pattern
                    return hash
                end

                opts.on('-i','--import','import remotes') do |import|
                    hash[:verb]="import"
                    return hash
                end

                opts.on('-r','--rake [REMOTE]','rake [REMOTE]') do |remote|
                    hash[:verb]="rake"
                    hash[:remote]=remote
                    return hash
                end

                opts.on('-h','--help','help') do
                    puts opts
                    exit
                end
            end

            opt_parser.parse!(options)
            hash
        end
    end

    class Console
        def self.run
            if(ARGV.length == 0)
                Parser.parse %w[--help]
                0
            else
                hash = Parser.parse ARGV
                #puts "hash: #{hash.to_s}"

                if(hash.include?(:verb))
                    verb = hash[:verb]
                    case verb
                    when 'list'
                        list(hash)
                    when 'import'
                        import(hash)
                    when 'rake'
                        rake(hash)
                    end
                end
            end
        end

        def self.list(hash)
            pattern=nil
            if(hash.include?(:pattern))
                pattern=hash[:pattern]
            end
            Raykit::Git::remote_urls.each{|url| 
                if(pattern.nil? || url.include?(pattern))
                    puts Rainbow(url).yellow.bright
                end
            }
        end

        def self.import(hash)
            puts 'scanning...'
            scanned_remotes = Raykit::Git::scan_remote_urls
            remotes = Raykit::Git::remote_urls
            count = 0
            scanned_remotes.each{|remote|
                if(!remotes.include?(remote))
                    puts "imported " + Rainbow(remote).yellow.bright
                    remotes.insert(0,remote)
                    count = count + 1
                end
            }
            if(count > 0)
                puts 'updating Raykit::Git::remote_urls'
                Raykit::Git::remote_urls = remotes
            end
        end

        def self.rake(hash)
            cmd = Raykit::Rake::run(hash[:remote],'master')
            elapsed_str = Timer.get_elapsed_str(cmd.elapsed)
            if(cmd.exitstatus == 0)
                puts elapsed_str + " " +  Rainbow(cmd.command).yellow.bright + " (#{cmd.directory})"
                return elapsed_str + " " + cmd.command
            else
                puts "\r\n" + cmd.command + "\r\n"
                puts "\r\n" + cmd.output + "\r\n"
                puts "\r\n" + cmd.error + "\r\n"
                puts ''
                abort Rainbow(elapsed_str).red.bright + " " +  Rainbow(cmd.command).white
            end
        end
    end
end