class Aws::DefaultsModeConfigResolver

@api private

def application_current_region

def application_current_region
  resolved_region = @@application_region_mutex.synchronize do
    return @@application_region unless @@application_region.nil?
    region = nil
    if ENV['AWS_EXECUTION_ENV']
      region = ENV['AWS_REGION'] || ENV['AWS_DEFAULT_REGION']
    end
    if region.nil? && ENV['AWS_EC2_METADATA_DISABLED']&.downcase != "true"
      begin
        region = @@imds_client.get('/latest/meta-data/placement/region')
      rescue
        # unable to get region, leave it unset
      end
    end
    # required so that we cache the unknown/nil result
    @@application_region = region || :unknown
  end
  resolved_region == :unknown ? nil : resolved_region
end

def env_mobile?

def env_mobile?
  false
end

def initialize(sdk_defaults, cfg)

def initialize(sdk_defaults, cfg)
  @sdk_defaults = sdk_defaults
  @cfg = cfg
  @resolved_mode = nil
  @mutex = Mutex.new
end

def resolve(option_name)

returns the ruby appropriate value or nil if none are resolved
option_name should be the symbolized ruby name to resolve
def resolve(option_name)
  return unless (std_option = CFG_OPTIONS[option_name])
  mode = resolved_mode.downcase
  return nil if mode == 'legacy'
  value = resolve_for_mode(std_option[:name], mode)
  value = value * std_option[:scale] if value && std_option[:scale]
  value
end

def resolve_auto_mode

def resolve_auto_mode
  return "mobile" if env_mobile?
  region = application_current_region
  if region
    @cfg.region == region ? "in-region": "cross-region"
  else
    # We don't seem to be mobile, and we couldn't determine whether we're running within an AWS region. Fall back to standard.
    'standard'
  end
end

def resolve_for_mode(name, mode)

def resolve_for_mode(name, mode)
  base_value = @sdk_defaults['base'][name]
  mode_value = @sdk_defaults['modes'].fetch(mode, {})[name]
  if mode_value.nil?
    return base_value
  end
  return mode_value['override'] unless mode_value['override'].nil?
  return base_value + mode_value['add'] unless mode_value['add'].nil?
  return base_value * mode_value['multiply'] unless mode_value['multiply'].nil?
  return base_value
end

def resolved_mode

def resolved_mode
  @mutex.synchronize do
    return @resolved_mode unless @resolved_mode.nil?
    @resolved_mode = @cfg.defaults_mode == 'auto' ? resolve_auto_mode : @cfg.defaults_mode
  end
end