class GraphQL::Schema::Enum

# File lib/graphql/schema/enum.rb, line 157
def all_enum_value_definitions
  all_defns = if superclass.respond_to?(:all_enum_value_definitions)
    superclass.all_enum_value_definitions
  else
    []
  end

  @own_values && @own_values.each do |_key, value|
    if value.is_a?(Array)
      all_defns.concat(value)
    else
      all_defns << value
    end
  end

  all_defns
end

# File lib/graphql/schema/enum.rb, line 277
def coerce_input(value_name, ctx)
  all_values = ctx.types ? ctx.types.enum_values(self) : values.each_value

  # This tries matching by incoming GraphQL string, then checks Ruby-defined values
  if v = (all_values.find { |val| val.graphql_name == value_name } || all_values.find { |val| val.value == value_name })
    if v.authorized?(ctx)
      v.value
    else
      raise GraphQL::UnauthorizedEnumValueError.new(type: self, enum_value: v, context: ctx)
    end
  else
    nil
  end
end

# File lib/graphql/schema/enum.rb, line 248
def coerce_result(value, ctx)
  types = ctx.types
  all_values = types ? types.enum_values(self) : values.each_value
  enum_value = all_values.find { |val| val.value == value }
  if enum_value && (was_authed = enum_value.authorized?(ctx))
    enum_value.graphql_name
  else
    raise const_get(:UnresolvedValueError).new(enum: self, value: value, context: ctx, authorized: was_authed)
  end
end

# File lib/graphql/schema/enum.rb, line 191
def enum_value_class(new_enum_value_class = nil)
  if new_enum_value_class
    @enum_value_class = new_enum_value_class
  elsif defined?(@enum_value_class) && @enum_value_class
    @enum_value_class
  else
    superclass <= GraphQL::Schema::Enum ? superclass.enum_value_class : nil
  end
end

# File lib/graphql/schema/enum.rb, line 115
def enum_values(context = GraphQL::Query::NullContext.instance)
  inherited_values = superclass.respond_to?(:enum_values) ? superclass.enum_values(context) : nil
  visible_values = []
  types = Warden.types_from_context(context)
  own_values.each do |key, values_entry|
    visible_value = nil #: GraphQL::Schema::EnumValue?
    if values_entry.is_a?(Array)
      values_entry.each do |v|
        if types.visible_enum_value?(v, context)
          if visible_value.nil?
            visible_value = v
            visible_values << v
          else
            raise DuplicateNamesError.new(
              duplicated_name: v.path, duplicated_definition_1: visible_value.inspect, duplicated_definition_2: v.inspect
            )
          end
        end
      end
    elsif types.visible_enum_value?(values_entry, context)
      visible_values << values_entry
    end
  end

  if inherited_values
    # Local values take precedence over inherited ones
    inherited_values.each do |i_val|
      if !visible_values.any? { |v| v.graphql_name == i_val.graphql_name }
        visible_values << i_val
      end
    end
  end

  visible_values
end

# File lib/graphql/schema/enum.rb, line 292
def inherited(child_class)
  if child_class.name
    # Don't assign a custom error class to anonymous classes
    # because they would end up with names like `#<Class0x1234>::UnresolvedValueError` which messes up bug trackers
    child_class.const_set(:UnresolvedValueError, Class.new(Schema::Enum::UnresolvedValueError))
  end
  child_class.class_exec { @value_methods = nil }
  super
end

# File lib/graphql/schema/enum.rb, line 213
def kind
  GraphQL::TypeKinds::ENUM
end

# File lib/graphql/schema/enum.rb, line 217
def validate_non_null_input(value_name, ctx, max_errors: nil)
  allowed_values = ctx.types.enum_values(self)
  matching_value = allowed_values.find { |v| v.graphql_name == value_name }

  if matching_value.nil?
    GraphQL::Query::InputValidationResult.from_problem("Expected #{GraphQL::Language.serialize(value_name)} to be one of: #{allowed_values.map(&:graphql_name).join(', ')}")
  else
    nil
  end
# rescue MissingValuesError
#   nil
end

# File lib/graphql/schema/enum.rb, line 86
def value(*args, value_method: nil, **kwargs, &block)
  kwargs[:owner] = self
  value = enum_value_class.new(*args, **kwargs, &block)

  if value_method || (value_methods && value_method != false)
    generate_value_method(value, value_method)
  end

  key = value.graphql_name
  prev_value = own_values[key]
  case prev_value
  when nil
    own_values[key] = value
  when GraphQL::Schema::EnumValue
    own_values[key] = [prev_value, value]
  when Array
    prev_value << value
  else
    raise "Invariant: Unexpected enum value for #{key.inspect}: #{prev_value.inspect}"
  end
  value
end

# File lib/graphql/schema/enum.rb, line 201
def value_methods(new_value = NOT_CONFIGURED)
  if NOT_CONFIGURED.equal?(new_value)
    if @value_methods != nil
      @value_methods
    else
      find_inherited_value(:value_methods, false)
    end
  else
    @value_methods = new_value
  end
end

# File lib/graphql/schema/enum.rb, line 181
def values(context = GraphQL::Query::NullContext.instance)
  enum_values(context).each_with_object({}) { |val, obj| obj[val.graphql_name] = val }
end