class Git::CommandLine

def build_git_cmd(args)
  raise ArgumentError.new('The args array can not contain an array') if args.any? { |a| a.is_a?(Array) }
  [binary_path, *global_opts, *args].map { |e| e.to_s }
end

def initialize(env, binary_path, global_opts, logger)
  @env = env
  @binary_path = binary_path
  @global_opts = global_opts
  @logger = logger
end

def post_process(raw_output, normalize, chomp)
  if raw_output.respond_to?(:string)
    output = raw_output.string.dup
    output = output.lines.map { |l| Git::EncodingUtils.normalize_encoding(l) }.join if normalize
    output.chomp! if chomp
    output
  else
    nil
  end
end

def post_process_all(raw_outputs, normalize, chomp)
  Array.new.tap do |result|
    raw_outputs.each { |raw_output| result << post_process(raw_output, normalize, chomp) }
  end
end

def process_result(result, normalize, chomp, timeout)
  command = result.command
  processed_out, processed_err = post_process_all([result.stdout, result.stderr], normalize, chomp)
  logger.info { "#{command} exited with status #{result}" }
  logger.debug { "stdout:\n#{processed_out.inspect}\nstderr:\n#{processed_err.inspect}" }
  Git::CommandLineResult.new(command, result, processed_out, processed_err).tap do |processed_result|
    raise Git::TimeoutError.new(processed_result, timeout) if result.timeout?
    raise Git::SignaledError.new(processed_result) if result.signaled?
    raise Git::FailedError.new(processed_result) unless result.success?
  end
end

def run(*args, out: nil, err: nil, normalize:, chomp:, merge:, chdir: nil, timeout: nil)
  git_cmd = build_git_cmd(args)
  begin
    result = ProcessExecuter.run(env, *git_cmd, out: out, err: err, merge:, chdir: (chdir || :not_set), timeout: timeout, raise_errors: false)
  rescue ProcessExecuter::Command::ProcessIOError => e
    raise Git::ProcessIOError.new(e.message), cause: e.exception.cause
  end
  process_result(result, normalize, chomp, timeout)
end