class ChefConfig::PathHelper

def self.all_homes(*args, windows: ChefUtils.windows?)
  paths = []
  paths << ENV[@@per_tool_home_environment] if defined?(@@per_tool_home_environment) && @@per_tool_home_environment && ENV[@@per_tool_home_environment]
  paths << ENV["CHEF_HOME"] if ENV["CHEF_HOME"]
  if windows
    # By default, Ruby uses the following environment variables to determine Dir.home:
    # HOME
    # HOMEDRIVE HOMEPATH
    # USERPROFILE
    # Ruby only checks to see if the variable is specified - not if the directory actually exists.
    # On Windows, HOMEDRIVE HOMEPATH can point to a different location (such as an unavailable network mounted drive)
    # while USERPROFILE points to the location where the user application settings and profile are stored.  HOME
    # is not defined as an environment variable (usually).  If the home path actually uses UNC, then the prefix is
    # HOMESHARE instead of HOMEDRIVE.
    #
    # We instead walk down the following and only include paths that actually exist.
    # HOME
    # HOMEDRIVE HOMEPATH
    # HOMESHARE HOMEPATH
    # USERPROFILE
    paths << ENV["HOME"]
    paths << ENV["HOMEDRIVE"] + ENV["HOMEPATH"] if ENV["HOMEDRIVE"] && ENV["HOMEPATH"]
    paths << ENV["HOMESHARE"] + ENV["HOMEPATH"] if ENV["HOMESHARE"] && ENV["HOMEPATH"]
    paths << ENV["USERPROFILE"]
  end
  paths << Dir.home if ENV["HOME"]
  # Depending on what environment variables we're using, the slashes can go in any which way.
  # Just change them all to / to keep things consistent.
  # Note: Maybe this is a bad idea on some unixy systems where \ might be a valid character depending on
  # the particular brand of kool-aid you consume.  This code assumes that \ and / are both
  # path separators on any system being used.
  paths = paths.map { |home_path| home_path.gsub(path_separator(windows: windows), ::File::SEPARATOR) if home_path }
  # Filter out duplicate paths and paths that don't exist.
  valid_paths = paths.select { |home_path| home_path && Dir.exist?(home_path.force_encoding("utf-8")) }
  valid_paths = valid_paths.uniq
  # Join all optional path elements at the end.
  # If a block is provided, invoke it - otherwise just return what we've got.
  joined_paths = valid_paths.map { |home_path| File.join(home_path, *args) }
  if block_given?
    joined_paths.each { |p| yield p }
  else
    joined_paths
  end
end

def self.canonical_path(path, add_prefix = true, windows: ChefUtils.windows?)
  # First remove extra separators and resolve any relative paths
  abs_path = File.absolute_path(path)
  if windows
    # Add the \\?\ API prefix on Windows unless add_prefix is false
    # Downcase on Windows where paths are still case-insensitive
    abs_path.gsub!(::File::SEPARATOR, path_separator(windows: windows))
    if add_prefix && abs_path !~ /^\\\\?\\/
      abs_path.insert(0, "\\\\?\\")
    end
    abs_path.downcase!
  end
  abs_path
end

def self.cleanpath(path, windows: ChefUtils.windows?)
  path = Pathname.new(path).cleanpath.to_s
  if windows
    # ensure all forward slashes are backslashes
    path.gsub(File::SEPARATOR, path_separator(windows: windows))
  else
    # ensure all backslashes are forward slashes
    path.gsub(BACKSLASH, File::SEPARATOR)
  end
end

def self.dirname(path, windows: ChefUtils.windows?)
  if windows
    # Find the first slash, not counting trailing slashes
    end_slash = path.size
    loop do
      slash = path.rindex(/[#{Regexp.escape(File::SEPARATOR)}#{Regexp.escape(path_separator(windows: windows))}]/, end_slash - 1)
      if !slash
        return end_slash == path.size ? "." : path_separator(windows: windows)
      elsif slash == end_slash - 1
        end_slash = slash
      else
        return path[0..slash - 1]
      end
    end
  else
    ::File.dirname(path)
  end
end

def self.escape_glob(*parts, windows: ChefUtils.windows?)
  path = cleanpath(join(*parts, windows: windows), windows: windows)
  path.gsub(/[\\\{\}\[\]\*\?]/) { |x| "\\" + x }
end

def self.escape_glob_dir(*parts)
  path = Pathname.new(join(*parts)).cleanpath.to_s
  path.gsub(/[\\\{\}\[\]\*\?]/) { |x| "\\" + x }
end

def self.escapepath(path)
  path.gsub(BACKSLASH, BACKSLASH * 4)
end

def self.home(*args)
  @@home_dir ||= all_homes { |p| break p }
  if @@home_dir
    path = File.join(@@home_dir, *args)
    block_given? ? (yield path) : path
  end
end

def self.is_sip_path?(path, node)
  if ChefUtils.macos?
    # @todo: parse rootless.conf for this?
    sip_paths = [
      "/System", "/bin", "/sbin", "/usr"
    ]
    sip_paths.each do |sip_path|
      ChefConfig.logger.info("#{sip_path} is a SIP path, checking if it is in the exceptions list.")
      return true if path.start_with?(sip_path)
    end
    false
  else
    false
  end
end

def self.join(*args, windows: ChefUtils.windows?)
  path_separator_regex = Regexp.escape(windows ? "#{File::SEPARATOR}#{BACKSLASH}" : File::SEPARATOR)
  trailing_slashes_regex = /[#{path_separator_regex}]+$/.freeze
  leading_slashes_regex = /^[#{path_separator_regex}]+/.freeze
  separator = path_separator(windows: windows)
  args.flatten!
  args.inject do |joined_path, component|
    joined_path = joined_path.sub(trailing_slashes_regex, "")
    component = component.sub(leading_slashes_regex, "")
    joined_path << "#{separator}#{component}"
    joined_path
  end
end

def self.path_separator(windows: ChefUtils.windows?)
  if windows
    BACKSLASH
  else
    File::SEPARATOR
  end
end

def self.paths_eql?(path1, path2, windows: ChefUtils.windows?)
  canonical_path(path1, windows: windows) == canonical_path(path2, windows: windows)
end

def self.per_tool_home_environment=(env_var)
  @@per_tool_home_environment = env_var
  # Reset this in case .home was already called.
  @@home_dir = nil
end

def self.printable?(string)
  # returns true if string is free of non-printable characters (escape sequences)
  # this returns false for whitespace escape sequences as well, e.g. \n\t
  if /[^[:print:]]/.match?(string)
    false
  else
    true
  end
end

def self.relative_path_from(from, to, windows: ChefUtils.windows?)
  Pathname.new(cleanpath(to, windows: windows)).relative_path_from(Pathname.new(cleanpath(from, windows: windows)))
end

def self.split_args(line)
  cmd_args = []
  field = ""
  line.scan(/\s*(?>([^\s\\"]+|"([^"]*)"|'([^']*)')|(\S))(\s|\z)?/m) do |word, within_dq, within_sq, esc, sep|
    # Append the string with Word & Escape Character
    field << (word || esc.gsub(/\\(.)/, "\\1"))
    # Re-build the field when any whitespace character or
    # End of string is encountered
    if sep
      cmd_args << field
      field = ""
    end
  end
  cmd_args
end

def self.validate_path(path, windows: ChefUtils.windows?)
  if windows
    unless printable?(path)
      msg = "Path '#{path}' contains non-printable characters. Check that backslashes are escaped with another backslash (e.g. C:\\\\Windows) in double-quoted strings."
      ChefConfig.logger.error(msg)
      raise ChefConfig::InvalidPath, msg
    end
    if windows_max_length_exceeded?(path)
      ChefConfig.logger.trace("Path '#{path}' is longer than #{WIN_MAX_PATH}, prefixing with'\\\\?\\'")
      path.insert(0, "\\\\?\\")
    end
  end
  path
end

def self.windows_max_length_exceeded?(path)
  # Check to see if paths without the \\?\ prefix are over the maximum allowed length for the Windows API
  # http://msdn.microsoft.com/en-us/library/windows/desktop/aa365247%28v=vs.85%29.aspx
  unless /^\\\\?\\/.match?(path)
    if path.length > WIN_MAX_PATH
      return true
    end
  end
  false
end

def self.writable_sip_path?(path)
  # todo: parse rootless.conf for this?
  sip_exceptions = [
    "/System/Library/Caches", "/System/Library/Extensions",
    "/System/Library/Speech", "/System/Library/User Template",
    "/usr/libexec/cups", "/usr/local", "/usr/share/man"
  ]
  sip_exceptions.each do |exception_path|
    return true if path.start_with?(exception_path)
  end
  ChefConfig.logger.error("Cannot write to a SIP path #{path} on macOS!")
  false
end