class Xcodeproj::Project::Object::XCBuildConfiguration

def config
  return {} unless base_configuration_reference
  @config ||=
    if base_configuration_reference.real_path.exist?
      Xcodeproj::Config.new(base_configuration_reference.real_path).to_hash.tap do |hash|
        normalize_array_settings(hash)
      end
    else
      {}
    end
end

def debug?
  gcc_preprocessor_definitions = resolve_build_setting('GCC_PREPROCESSOR_DEFINITIONS')
  gcc_preprocessor_definitions && gcc_preprocessor_definitions.include?('DEBUG=1')
end

def expand_build_setting(build_setting_value, config_value)
  if build_setting_value.is_a?(Array) && config_value.is_a?(String)
    config_value = split_build_setting_array_to_string(config_value)
  elsif build_setting_value.is_a?(String) && config_value.is_a?(Array)
    build_setting_value = split_build_setting_array_to_string(build_setting_value)
  end
  default = build_setting_value.is_a?(String) ? '' : []
  inherited = config_value || default
  return build_setting_value.gsub(Regexp.union(Constants::INHERITED_KEYWORDS), inherited) if build_setting_value.is_a? String
  build_setting_value.flat_map { |value| Constants::INHERITED_KEYWORDS.include?(value) ? inherited : value }
end

def normalize_array_settings(settings)
  return unless settings
  array_settings = BuildSettingsArraySettingsByObjectVersion[project.object_version]
  settings.keys.each do |key|
    next unless value = settings[key]
    case value
    when String
      next unless array_settings.include?(key)
      array_value = split_build_setting_array_to_string(value)
      next unless array_value.size > 1
      settings[key] = array_value
    when Array
      next if value.size > 1 && array_settings.include?(key)
      settings[key] = value.join(' ')
    end
  end
end

def pretty_print
  data = {}
  data['Build Settings'] = sorted_build_settings
  if base_configuration_reference
    data['Base Configuration'] = base_configuration_reference.pretty_print
  end
  { name => data }
end

def resolve_build_setting(key, root_target = nil)
  setting = build_settings[key]
  setting = resolve_variable_substitution(key, setting, root_target)
  config_setting = config[key]
  config_setting = resolve_variable_substitution(key, config_setting, root_target)
  project_setting = project.build_configuration_list[name]
  project_setting = nil if equal?(project_setting)
  project_setting &&= project_setting.resolve_build_setting(key, root_target)
  defaults = {
    'CONFIGURATION' => name,
    'SRCROOT' => project.project_dir.to_s,
  }
  [defaults[key], project_setting, config_setting, setting, ENV[key]].compact.reduce(nil) do |inherited, value|
    expand_build_setting(value, inherited)
  end
end

def resolve_variable_substitution(key, value, root_target)
  case value
  when Array
    return value.map { |v| resolve_variable_substitution(key, v, root_target) }
  when nil
    return
  when String
    # we know how to resolve strings!
    nil
  else
    raise ArgumentError, "Settings values can only be nil, string, or array, got #{value.inspect} for #{key}"
  end
  unless variable_match_data = value.match(CAPTURE_VARIABLE_IN_BUILD_CONFIG)
    # no variables left, return the value unchanged
    return value
  end
  variable_reference, variable = *variable_match_data.values_at(0, 1, 2).compact
  case variable
  when 'inherited'
    # this is handled separately, after resolving all other variable references
    value
  when key
    # to prevent infinite recursion
    nil
  else
    configuration_to_resolve_against = root_target ? root_target.build_configuration_list[name] : self
    resolved_value_for_variable = configuration_to_resolve_against.resolve_build_setting(variable, root_target) || ''
    value = value.gsub(variable_reference, resolved_value_for_variable)
    resolve_variable_substitution(key, value, root_target)
  end
end

def sort(_options = nil)
  self.build_settings = sorted_build_settings
end

def sorted_build_settings
  sorted = {}
  build_settings.keys.sort.each do |key|
    sorted[key] = build_settings[key]
  end
  sorted
end

def split_build_setting_array_to_string(string)
  regexp = / *((['"]?).*?[^\\]\2)(?=( |\z))/
  string.scan(regexp).map(&:first)
end

def to_hash_as(method = :to_hash)
  super.tap do |hash|
    normalize_array_settings(hash['buildSettings'])
  end
end

def type
  debug? ? :debug : :release
end