class Google::Cloud::Config

def self.config? obj
  Config.send :===, obj
end

def self.create show_warnings: true
  config = new [], show_warnings: show_warnings
  yield config if block_given?
  config
end

def self.credentials_from_env *vars
  vars.each do |var|
    data = ::ENV[var]
    next unless data
    str = data.strip
    return str if ::File.file? str
    json = begin
      ::JSON.parse str
    rescue ::StandardError
      nil
    end
    return json if json.is_a? ::Hash
  end
  nil
end

def self.deferred &block
  DeferredValue.new(&block)
end

def [] key
  key = resolve_key! key
  unless @validators.key? key
    warn! "Key #{key.inspect} does not exist. Returning nil."
  end
  value = @values[key]
  value = value.call if Config::DeferredValue === value
  value
end

def []= key, value
  key = resolve_key! key
  validate_value! key, @validators[key], value
  @values[key] = value
end

def add_alias! key, to_key
  key = validate_new_key! key
  @values.delete key
  @defaults.delete key
  @validators[key] = to_key.to_sym
  self
end

def add_config! key, config = nil, &block
  key = validate_new_key! key
  if config.nil?
    config = Config.create(&block)
  elsif block
    yield config
  end
  @values[key] = config
  @defaults[key] = config
  @validators[key] = SUBCONFIG
  self
end

def add_field! key, initial = nil, opts = {}, &block
  key = validate_new_key! key
  opts[:validator] = block if block
  validator = resolve_validator! initial, opts
  validate_value! key, validator, initial
  @values[key] = initial
  @defaults[key] = initial
  @validators[key] = validator
  self
end

def add_options legacy_categories
  [legacy_categories].flatten(1).each do |sub_key|
    case sub_key
    when ::Symbol
      add_config! sub_key, Config.new
    when ::Hash
      sub_key.each do |k, v|
        add_config! k, Config.new(v)
      end
    else
      raise ArgumentError "Category must be a Symbol or Hash"
    end
  end
end

def alias? key
  target = @validators[key.to_sym]
  target.is_a?(::Symbol) ? target : nil
end

def aliases!
  @validators.keys.find_all { |key| @validators[key].is_a? ::Symbol }
end

def build_enum_validator! allowed, allow_nil
  allowed = ::Kernel.Array(allowed)
  allowed += [nil] if allow_nil && !allowed.include?(nil)
  ->(val) { allowed.include? val }
end

def build_match_validator! matches, allow_nil
  matches = ::Kernel.Array(matches)
  matches += [nil] if allow_nil && !matches.include?(nil)
  ->(val) { matches.any? { |m| m.send :===, val } }
end

def build_proc_validator! proc, allow_nil
  ->(val) { proc.call(val) || (allow_nil && val.nil?) }
end

def delete! key = nil
  if key.nil?
    @values.clear
    @defaults.clear
    @validators.clear
  else
    @values.delete key
    @defaults.delete key
    @validators.delete key
  end
  self
end

def field? key
  @validators[key.to_sym].is_a? ::Proc
end

def fields!
  @validators.keys.find_all { |key| @validators[key].is_a? ::Proc }
end

def initialize legacy_categories = {}, opts = {}
  @show_warnings = opts.fetch :show_warnings, false
  @values = {}
  @defaults = {}
  @validators = {}
  add_options legacy_categories
end

def method_missing name, *args
  name_str = name.to_s
  super unless name_str =~ /^[a-zA-Z]\w*=?$/
  if name_str.chomp! "="
    self[name_str] = args.first
  else
    self[name]
  end
end

def nil?
  false
end

def reset! key = nil
  if key.nil?
    @values.each_key { |k| reset! k }
  else
    key = key.to_sym
    if @defaults.key? key
      @values[key] = @defaults[key]
      @values[key].reset! if @validators[key] == SUBCONFIG
    elsif @values.key? key
      warn! "Key #{key.inspect} has not been added, but has a value." \
            " Removing the value."
      @values.delete key
    else
      warn! "Key #{key.inspect} does not exist. Nothing to reset."
    end
  end
  self
end

def resolve_key! key
  key = key.to_sym
  alias_target = @validators[key]
  alias_target.is_a?(::Symbol) ? alias_target : key
end

def resolve_validator! initial, opts
  allow_nil = initial.nil? || opts[:allow_nil]
  if opts.key? :validator
    build_proc_validator! opts[:validator], allow_nil
  elsif opts.key? :match
    build_match_validator! opts[:match], allow_nil
  elsif opts.key? :enum
    build_enum_validator! opts[:enum], allow_nil
  elsif [true, false].include? initial
    build_enum_validator! [true, false], allow_nil
  elsif initial.nil?
    OPEN_VALIDATOR
  else
    klass = Config.config?(initial) ? Config : initial.class
    build_match_validator! klass, allow_nil
  end
end

def respond_to_missing? name, include_private
  return true if value_set? name.to_s.chomp("=")
  super
end

def subconfig? key
  @validators[key.to_sym] == SUBCONFIG
end

def subconfigs!
  @validators.keys.find_all { |key| @validators[key] == SUBCONFIG }
end

def to_h!
  h = {}
  @validators.each_key do |k|
    v = @values[k]
    h[k] = Config.config?(v) ? v.to_h! : v.inspect
  end
  h
end

def to_s!
  elems = @validators.keys.map do |k|
    v = @values[k]
    vstr = Config.config?(v) ? v.to_s! : value.inspect
    " #{k}=#{vstr}"
  end
  "<Config:#{elems.join}>"
end

def validate_new_key! key
  key_str = key.to_s
  key = key.to_sym
  if key_str !~ /^[a-zA-Z]\w*$/ || ILLEGAL_KEYS.include?(key)
    warn! "Illegal key name: #{key_str.inspect}. Method dispatch will" \
          " not work for this key."
  end
  if @validators.key? key
    warn! "Key #{key.inspect} already exists. It will be replaced."
  end
  key
end

def validate_value! key, validator, value
  value = value.call if Config::DeferredValue === value
  case validator
  when ::Proc
    unless validator.call value
      warn! "Invalid value #{value.inspect} for key #{key.inspect}." \
            " Setting anyway."
    end
  when Config
    if value != validator
      warn! "Key #{key.inspect} refers to a subconfig and shouldn't" \
            " be changed. Setting anyway."
    end
  else
    warn! "Key #{key.inspect} has not been added. Setting anyway."
  end
end

def value_set? key
  @values.key? resolve_key! key
end

def warn! msg
  return unless @show_warnings
  location = ::Kernel.caller_locations.find do |s|
    !s.to_s.include? "/google/cloud/config.rb:"
  end
  ::Kernel.warn "#{msg} at #{location}"
end