class SystemUniversal

def child_program config
  <<-program
    PIPE = STDOUT.dup
    begin
      require 'yaml'
      config = YAML.load(IO.read('#{ config }'))
      argv = config['argv']
      env = config['env']
      cwd = config['cwd']
      stdin = config['stdin']
      stdout = config['stdout']
      stderr = config['stderr']
      Dir.chdir cwd if cwd
      env.each{|k,v| ENV[k.to_s] = v.to_s} if env
      STDIN.reopen stdin
      STDOUT.reopen stdout
      STDERR.reopen stderr
      PIPE.puts "pid: \#{ Process.pid }"
      PIPE.flush                        ### the process is ready yo! 
      PIPE.close
      exec *argv
    rescue Exception => e
      PIPE.write Marshal.dump(e) rescue nil
      exit 42
    end
  program
end

def child_setup tmp
  stdin = File.expand_path(File.join(tmp, 'stdin'))
  stdout = File.expand_path(File.join(tmp, 'stdout'))
  stderr = File.expand_path(File.join(tmp, 'stderr'))
  program = File.expand_path(File.join(tmp, 'program'))
  config = File.expand_path(File.join(tmp, 'config'))
  if @stdin
    open(stdin, 'w'){|f| relay @stdin => f}
  else
    FileUtils.touch stdin
  end
  FileUtils.touch stdout
  FileUtils.touch stderr
  c = {}
  c['argv'] = @argv
  c['env'] = @env
  c['cwd'] = @cwd
  c['stdin'] = stdin 
  c['stdout'] = stdout 
  c['stderr'] = stderr 
  c['program'] = program 
  open(config, 'w'){|f| YAML.dump c, f}
  open(program, 'w'){|f| f.write child_program(config)}
  c
end

def getopts opts = {}
  lambda do |*args|
    keys, default, ignored = args
    catch(:opt) do
      [keys].flatten.each do |key|
        [key, key.to_s, key.to_s.intern].each do |key|
          throw :opt, opts[key] if opts.has_key?(key)
        end
      end
      default
    end
  end
end

def initialize argv, opts = {}, &block
  getopt = getopts opts
  @argv = argv
  @block = block
  @stdin = getopt[ ['stdin', 'in', '0', 0] ]
  @stdout = getopt[ ['stdout', 'out', '1', 1] ]
  @stderr = getopt[ ['stderr', 'err', '2', 2] ]
  @env = getopt[ 'env' ]
  @cwd = getopt[ 'cwd' ]
  @host = getopt[ 'host', self.class.host ]
  @ppid = getopt[ 'ppid', self.class.ppid ]
  @pid = getopt[ 'pid', self.class.pid ]
  @ruby = getopt[ 'ruby', self.class.ruby ]
end

def new_thread cid, block 
  q = Queue.new
  Thread.new(cid) do |cid| 
    current = Thread.current 
    current.abort_on_exception = true
    q.push current 
    block.call cid
  end
  q.pop
end

def quietly
  v = $VERBOSE
  $VERBOSE = nil
  yield
ensure
  $VERBOSE = v
end

def quote(*words)
  words.map{|word| word.inspect}.join(' ')
end

def quote *args, &block
  SystemUniversal.quote(*args, &block)
end

def relay srcdst
  src, dst, ignored = srcdst.to_a.first
  if src.respond_to? 'read'
    while((buf = src.read(8192))); dst << buf; end
  else
    if src.respond_to?(:each_line)
      src.each_line{|buf| dst << buf}
    else
      src.each{|buf| dst << buf}
    end
  end
end

def systemu
  tmpdir do |tmp|
    c = child_setup tmp
    status = nil
    begin
      thread = nil
      quietly{
        IO.popen "#{ quote(@ruby) } #{ quote(c['program']) }", 'r+' do |pipe|
          line = pipe.gets
          case line
            when %r/^pid: \d+$/
              cid = Integer line[%r/\d+/] 
            else
              begin
                buf = pipe.read
                buf = "#{ line }#{ buf }"
                e = Marshal.load buf
                raise unless Exception === e
                raise e
              rescue
                raise "wtf?\n#{ buf }\n"
              end
          end
          thread = new_thread cid, @block if @block
          pipe.read rescue nil
        end
      }
      status = $?
    ensure
      if thread
        begin
          class << status
            attr 'thread'
          end
          status.instance_eval{ @thread = thread }
        rescue
          42
        end
      end
    end
    if @stdout or @stderr
      open(c['stdout']){|f| relay f => @stdout} if @stdout
      open(c['stderr']){|f| relay f => @stderr} if @stderr
      status
    else
      [status, IO.read(c['stdout']), IO.read(c['stderr'])]
    end
  end
end

def systemu
  split_argv = JRuby::PathHelper.smart_split_command @argv
  process = java.lang.Runtime.runtime.exec split_argv.to_java(:string)
  
  stdout, stderr = [process.input_stream, process.error_stream].map do |stream|
    StreamReader.new(stream)
  end
  exit_code = process.wait_for
  [
    RubyProcess::RubyStatus.new_process_status(JRuby.runtime, exit_code), 
    stdout.join, 
    stderr.join
  ]
end

def tmpdir d = Dir.tmpdir, max = 42, &b
  i = -1 and loop{
    i += 1
    tmp = File.join d, "systemu_#{ @host }_#{ @ppid }_#{ @pid }_#{ rand }_#{ i += 1 }"
    begin
      Dir.mkdir tmp 
    rescue Errno::EEXIST
      raise if i >= max 
      next
    end
    break(
      if b
        begin
          b.call tmp
        ensure
          FileUtils.rm_rf tmp unless SystemU.turd 
        end
      else
        tmp
      end
    )
  }
end

def version() SystemUniversal::VERSION end