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 group.kind_of?(Integer) ? group : Etc.getgrnam(group.to_s).gid if group
  return Etc.getpwuid(uid).gid if using_login?
  nil
end

def initialize(*command_args)
  @stdout, @stderr, @process_status = "", "", ""
  @live_stdout = @live_stderr = nil
  @input = nil
  @log_level = :debug
  @log_tag = nil
  @environment = {}
  @cwd = nil
  @valid_exit_codes = [0]
  @terminate_reason = nil
  @timeout = nil
  @elevated = false
  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"
      if setting
        self.environment = Hash[setting.map { |(k, v)| [k.to_s, v] }]
      else
        self.environment = {}
      end
    when "login"
      self.login = setting
    when "elevated"
      self.elevated = 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)
  if login && !user
    raise InvalidCommandOption, "cannot set login without specifying a user"
  end
  super
end