require 'optparse'

module Raykit
    # Parses the command line arguments for the Raykit console application

    class Parser
        def self.parse(options)
            hash=Hash.new
            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 [PATTERN]','rake [PATTERN]') do |pattern|
                    hash[:verb]="rake"
                    if(pattern.nil?)
                        hash[:pattern] = ''
                    else
                        hash[:pattern]=pattern
                    end
                    return hash
                end

                opts.on('-w','--work [PATTERN]','work [PATTERN]') do |pattern|
                    hash[:verb]="work"
                    if(pattern.nil?)
                        hash[:pattern] = ''
                    else
                        hash[:pattern]=pattern
                    end
                    return hash
                end

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

            opt_parser.parse!(options)
            hash
        end
    end

    # The implementation for the raykit console application

    class Console
        def self.run
            if(ARGV.length == 0)
                Parser.parse %w[--help]
                0
            else
                hash = Parser.parse ARGV
                if(hash.include?(:verb))
                    verb = hash[:verb]
                    case verb
                    when 'list'
                        list(hash)
                    when 'import'
                        import(hash)
                    when 'rake'
                        rake(hash)
                    when 'work'
                        work(hash)
                    end
                end
            end
        end

        def self.list(hash)
            pattern=''
            if(hash.include?(:pattern))
                pattern=hash["pattern"]
            end
            pattern='' if(pattern.nil?)

            REPOSITORIES.each{|url|
                if(url.include?(pattern))
                    puts Rainbow(url).yellow.bright
                end
            }
        end

        def self.import(hash)
            pattern=''
            pattern=hash["pattern"] if(hash.include?("pattern"))
            puts 'scanning...'
            count=REPOSITORIES.length
            REPOSITORIES.import(pattern)
            new_count=REPOSITORIES.length-count
            puts "imported #{new_count} git repositories"
        end

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

        def self.work(hash)
            REPOSITORIES.each{|remote|
                if(remote.include?(hash[:pattern]))
                    puts "remote: #{remote}"
                    repo=Raykit::Git::Repository.new(remote)
                    work=Raykit::Git::Directory.new(repo.get_dev_dir('work'))
                    if(!Dir.exist?(work.directory))
                        Raykit::run("git clone #{remote} #{work.directory}")
                    end
                    work.rake('default')
                end
            }
        end
    end
end