require "rubygems"
require "term/ansicolor"
include Term::ANSIColor
require "net/ssh"
require "net/scp"
require "net/sftp"

class CommandResult
  attr_reader :pid, :stdin, :stdout, :stderr, :status
  
  def initialize(pid, stdin, stdout, stderr, status)
    @pid=pid
    @stdin=stdin
    @stdout=stdout
    @stderr=stderr
    @status=status
  end
end

class Command

  def self.patch(src, dest, options ={})
    #channel.exec 
    defaults= { :port => "22", :exitcode => "0", :user => "root"}
    options=defaults.merge(options) 
    filename=File.basename("#{src}")
    Command.transfer("#{src}","/tmp/#{filename}", options)
    Command.execute("cat /tmp/#{filename}| patch -i - -u #{dest}", options)    
  end
  
   def self.transfer(src, dest, options = {})
    defaults= { :port => "22", :exitcode => "0", :user => "root"}
    options=defaults.merge(options) 
    configfile="#{ENV['VM_STATE']}/.ssh/ssh_config.systr"
 
    Command.comment("copying #{src} to #{dest}")
    Command.execute("scp -F '#{configfile}' -P #{options[:port]} #{src} #{options[:user]}@#{options[:machine]}:#{dest}")
  end
  
  def self.rsync(src, dest, options = {})
    defaults= { :port => "22", :exitcode => "0", :user => "root"}
    options=defaults.merge(options) 
    configfile="#{ENV['VM_STATE']}/.ssh/ssh_config.systr"
    system("rsync -avz -e 'ssh -F #{configfile} -p #{options[:port]}' #{src} #{options[:user]}@#{options[:machine]}:#{dest}")
  end
  
  def self.comment(text, options= {})
    print bold
    puts text.indent(2)
    print reset
    system "say #{text}"
  end
  
  def self.show(command, options= {} )
      defaults= { :exitcode => "*" }
      options=defaults.merge(options) 
      result=self.execute(command,  options).status
  end
  
  def self.test(command, options= {} )
    defaults= { :exitcode => "0" }
      options=defaults.merge(options) 
      #TODO: ERROR we need to pass options to execute!
    result=self.execute(command,  { :exitcode => "*" }).status
    if (result.to_s != options[:exitcode])
      return false
    else
      return true
    end
  end
  
  def self.execute(command, options = {} )
    defaults= { :port => "22", :exitcode => "0", :user => "root"}
      options=defaults.merge(options) 
      @pid=""
      @stdin=command
      @stdout=""
      @stderr=""
      @status=-99999
  
      print blue
      puts "Command: "+command
      print reset
            
    if options[:machine]
      #this is a remote machine so we should ssh into the box
      configfile="#{ENV['VM_STATE']}/.ssh/ssh_config.systr"
      
      Net::SSH.start(options[:machine], options[:user], :password => "pipopo", :paranoid => false,  :config => configfile ) do |ssh|
      
        # open a new channel and configure a minimal set of callbacks, then run
        # the event loop until the channel finishes (closes)
        channel = ssh.open_channel do |ch|
          ch.exec "#{command}" do |ch, success|
            raise "could not execute command" unless success

            # "on_data" is called when the process writes something to stdout
            ch.on_data do |c, data|
              @stdout+=data
              puts data
            end

            # "on_extended_data" is called when the process writes something to stderr
            ch.on_extended_data do |c, type, data|
              @stderr+=data
              puts data
            end

            #exit code 
            #http://groups.google.com/group/comp.lang.ruby/browse_thread/thread/a806b0f5dae4e1e2
            channel.on_request("exit-status") do |ch, data|
              exit_code = data.read_long
              @status=exit_code
              if exit_code > 0                
                puts "ERROR: exit code #{exit_code}"
              else
                puts "success"
              end
            end

            channel.on_request("exit-signal") do |ch, data|
              puts "SIGNAL: #{data.read_long}"
            end
            
            ch.on_close { puts "done!" }
            #status=ch.exec "echo $?"
          end
        end

        channel.wait
      end
    else
      status = Open4::popen4(command) do |pid, stdin, stdout, stderr|
        @pid=pid
        @stdin=command
        @stdout=""
        @stderr=""
      
        while(line=stdout.gets) 
          @stdout+=line
          puts line

        end
      
        while(line=stderr.gets) 
          @stderr+=line
          puts line
        end

        unless @stdout.nil? 
          @stdout=@stdout.strip
        end
        unless @stderr.nil? 
          @stderr=@stderr.strip
        end

      end
      @status=status.to_i
    end

    result=CommandResult.new(@pid,@stdin,@stdout,@stderr,@status)

  #coloring http://www.ruby-forum.com/topic/141589
    if (@status!=0)
      print red
    else
      print green
    end
    puts result.stdout.indent(2)  
    puts result.stderr.indent(2)
    print reset
     80.times { print "-"}
    puts ""
    
    if (@status.to_s != options[:exitcode] )
      if (options[:exitcode]=="*")
        #its a test so we don't need to worry
      else
        raise "Exitcode was not what we expected"
      end
      
    end
    
    return result
  end

end

def execute_when_ssh_available(ip="localhost", options = {  } , &block)

    defaults={ :port => 22, :timeout => 2 , :gw_machine => '' , :gw_port => '22' , :gw_user => 'root' , :user => 'root', :password => ''}

    options=defaults.merge(options)
    configfile="#{ENV['VM_STATE']}/.ssh/ssh_config.systr"
    pp options
  begin
    Timeout::timeout(options[:timeout]) do
      connected=false
      while !connected do
        begin
          puts "trying connection"
          Net::SSH.start(ip, :user => options[:user], :port => options[:port] ,:password => options[:password], :paranoid => false,:timeout => options[:timeout], :config => configfile) do |ssh|
            block.call(ip);
            return true

          end
        rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ECONNABORTED, Errno::ECONNRESET, Errno::ENETUNREACH
          sleep 5
        end
      end
    end
  rescue Timeout::Error
    raise 'ssh timeout'
  end

  return false
end


#after the machine boots
def execute_when_tcp_available(ip="localhost", options = { } , &block)

    defaults={ :port => 22, :timeout => 2 , :pollrate => 5}

    options=defaults.merge(options)

  begin
    Timeout::timeout(options[:timeout]) do
      connected=false
      while !connected do
        begin
          puts "trying connection"
          s = TCPSocket.new(ip, options[:port])
          s.close
          block.call(ip);
          return true
        rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
          sleep options[:pollrate]
        end
      end
    end
  rescue Timeout::Error
    raise 'timeout connecting to port'
  end

  return false
end