class Mixlib::ShellOut

def error!
  invalid!("Expected process to exit with #{valid_exit_codes.inspect}, but received '#{exitstatus}'") if error?
end

def error?
  !Array(valid_exit_codes).include?(exitstatus)
end

def exitstatus
  @status && @status.exitstatus
end

def format_for_exception
  msg = ""
  msg << "#{@terminate_reason}\n" if @terminate_reason
  msg << "---- Begin output of #{command} ----\n"
  msg << "STDOUT: #{stdout.strip}\n"
  msg << "STDERR: #{stderr.strip}\n"
  msg << "---- End output of #{command} ----\n"
  msg << "Ran #{command} returned #{status.exitstatus}" if status
  msg
end

def gid
  return nil unless group
  group.kind_of?(Integer) ? group : Etc.getgrnam(group.to_s).gid
end

def initialize(*command_args)
  @stdout, @stderr = '', ''
  @live_stdout = @live_stderr = nil
  @input = nil
  @log_level = :debug
  @log_tag = nil
  @environment = {}
  @cwd = nil
  @valid_exit_codes = [0]
  @terminate_reason = nil
  if command_args.last.is_a?(Hash)
    parse_options(command_args.pop)
  end
  @command = command_args.size == 1 ? command_args.first : command_args
end

def inspect
  "<#{self.class.name}##{object_id}: command: '#@command' process_status: #{@status.inspect} " +
  "stdout: '#{stdout.strip}' stderr: '#{stderr.strip}' child_pid: #{@child_pid.inspect} " +
  "environment: #{@environment.inspect} timeout: #{timeout} user: #@user group: #@group working_dir: #@cwd >"
end

def invalid!(msg=nil)
  msg ||= "Command produced unexpected results"
  raise ShellCommandFailed, msg + "\n" + format_for_exception
end

def live_stream
  live_stdout == live_stderr ? live_stdout : nil
end

def live_stream=(stream)
  @live_stdout = @live_stderr = stream
end

def parse_options(opts)
  opts.each do |option, setting|
    case option.to_s
    when 'cwd'
      self.cwd = setting
    when 'domain'
      self.domain = setting
    when 'password'
      self.password = setting
    when 'user'
      self.user = setting
      self.with_logon = setting
    when 'group'
      self.group = setting
    when 'umask'
      self.umask = setting
    when 'timeout'
      self.timeout = setting
    when 'returns'
      self.valid_exit_codes = Array(setting)
    when 'live_stream'
      self.live_stdout = self.live_stderr = setting
    when 'live_stdout'
      self.live_stdout = setting
    when 'live_stderr'
      self.live_stderr = setting
    when 'input'
      self.input = setting
    when 'logger'
      self.logger = setting
    when 'log_level'
      self.log_level = setting
    when 'log_tag'
      self.log_tag = setting
    when 'environment', 'env'
      self.environment = setting || {}
    else
      raise InvalidCommandOption, "option '#{option.inspect}' is not a valid option for #{self.class.name}"
    end
  end
  validate_options(opts)
end

def run_command
  if logger
    log_message = (log_tag.nil? ? "" : "#@log_tag ") << "sh(#@command)"
    logger.send(log_level, log_message)
  end
  super
end

def timeout
  @timeout || DEFAULT_READ_TIMEOUT
end

def uid
  return nil unless user
  user.kind_of?(Integer) ? user : Etc.getpwnam(user.to_s).uid
end

def umask=(new_umask)
  @umask = (new_umask.respond_to?(:oct) ? new_umask.oct : new_umask.to_i) & 007777
end

def validate_options(opts)
  super
end