class Raykit::Console

def 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 initialize
    @opts = Slop.parse do |o|
        o.string '-r', '--remote', 'remote name or substring', default: ''
        o.string '-t','--task','rake task', default: 'default'
        o.string '-l','--level','log level (debug,info,warn,error)', default: 'warn'
        o.bool '-i','--import','import remotes from work directory'
        o.bool '-p','--pull','pull work directory'
        o.bool '-w','--work','rake work directory'
        o.bool '-m','--make','make latest commit'
        o.bool '-q','--quiet','enable quiet mode'
        o.bool '-s','--show','show names'
        o.bool '-c','--clean','clean work directories'
        o.bool '-d','--delete','delete remote name'
    end
    if(opts.verbose?)
        puts "options: " + Rainbow(@opts.to_hash).yellow.bright
    end
end

def 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 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(SECRETS.hide(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 run
    if(ARGV.length == 0)
        puts @opts
        0
    else
        verb = ARGV[0]
        if(verb == "sync_version")
            source = ARGV[1]
            dest = ARGV[2]
            Raykit::Version::sync_file_versions(source,dest)
            version = Raykit::Version::detect(source,false)
            puts "version #{version} detected in #{source}, updating #{dest} to match."
        elsif(verb == "copy")
            source = ARGV[1]
            dest=ARGV[2]
            FileUtils.cp(source,dest)
            puts "copied #{source} to #{dest}"
        else
            # align log level with @opts[:level]

            LOG.set_severity_as_string(@opts[:level])
            if(LOG.severity == Logger::Severity::DEBUG ||
            LOG.severity == Logger::Severity::INFO)
            puts '--remote = ' + @opts[:remote]
            puts '--task   = ' + @opts[:task]
            puts '--level  = ' + @opts[:level] 
            selected_repositories = REPOSITORIES.select{|r| r.include?(@opts[:remote])}
                if(selected_repositories.length == 0)
                    puts "no matching remotes"
                    return
                else
                    puts "matching remotes:"
                    selected_repositories.each{|r| puts r}
                end
            end
            if(@opts.import?)
                puts Rainbow('import').yellow.bright
                if(REPOSITORIES.is_remote_url(@opts[:remote]))
                    puts "importing #{@opts[:remote]}"
                else
                    puts "scanning #{REPOSITORIES.work_dir} for .git directories"
                end
                imported=REPOSITORIES.import(@opts[:remote])
                puts "imported #{imported.length} remotes"
                return 0
            end
            REPOSITORIES.select{|r| r.include?(@opts[:remote])}.each{|remote|
                repo=Raykit::Git::Repository.new(remote)
                work=Raykit::Git::Directory.new(repo.get_dev_dir('work'))
                make=Raykit::Git::Directory.new(repo.get_dev_dir('make'))
                puts Rainbow(remote).green.bright
                if(@opts.pull?)
                    # do not pull if the working directory does not already exist.

                    if(Dir.exists?(repo.get_dev_dir('work')))
                        work.pull
                    end
                end
                if(@opts.work?)
                    if(!Dir.exist?(work.directory))
                        puts "work directory #{work.directory} does not exist, cloning" if(@opts.verbose?)
                        puts `git clone #{remote} #{work.directory}`
                    end
                    puts "rake #{@opts[:task]} in #{work.directory}" if(@opts.verbose?)
                    work.rake(@opts[:task])
                end
                if(@opts.make?)
                    if(!Dir.exist?(make.directory))
                        puts `git clone #{remote} #{make.directory}`
                    end
                    make.rake(@opts[:task])
                end
                if(@opts.clean?)
                    if(Dir.exist?(work.directory))
                        puts 'removing '  + Rainbow(work.directory).yellow
                        FileUtils.remove_dir(work.directory)
                    end
                end
                if(@opts.delete?)
                    if(Dir.exist?(work.directory))
                        puts 'removing '  + Rainbow(work.directory).yellow
                        FileUtils.remove_dir(work.directory)
                    end
                    if(Dir.exist?(make.directory))
                        puts 'removing '  + Rainbow(work.directory).yellow
                        FileUtils.remove_dir(work.directory)
                    end
                    if(REPOSITORIES.include?(remote))
                        puts 'removing remote ' + Rainbow(remote).yellow
                        REPOSITORIES.remove(remote)
                    end
                end
            }
        end
    end
    0
end

def 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