module ActiveRecord::Enum

def self.extended(base) # :nodoc:
  base.class_attribute(:defined_enums, instance_writer: false)
  base.defined_enums = {}
end

def _enum_methods_module
  @_enum_methods_module ||= begin
    mod = Module.new
    include mod
    mod
  end
end

def detect_enum_conflict!(enum_name, method_name, klass_method = false)
  if klass_method && dangerous_class_method?(method_name)
    raise_conflict_error(enum_name, method_name, type: 'class')
  elsif !klass_method && dangerous_attribute_method?(method_name)
    raise_conflict_error(enum_name, method_name)
  elsif !klass_method && method_defined_within?(method_name, _enum_methods_module, Module)
    raise_conflict_error(enum_name, method_name, source: 'another enum')
  end
end

def enum(definitions)
  klass = self
  enum_prefix = definitions.delete(:_prefix)
  enum_suffix = definitions.delete(:_suffix)
  definitions.each do |name, values|
    # statuses = { }
    enum_values = ActiveSupport::HashWithIndifferentAccess.new
    name        = name.to_sym
    # def self.statuses() statuses end
    detect_enum_conflict!(name, name.to_s.pluralize, true)
    klass.singleton_class.send(:define_method, name.to_s.pluralize) { enum_values }
    detect_enum_conflict!(name, name)
    detect_enum_conflict!(name, "#{name}=")
    decorate_attribute_type(name, :enum) do |subtype|
      EnumType.new(name, enum_values, subtype)
    end
    _enum_methods_module.module_eval do
      pairs = values.respond_to?(:each_pair) ? values.each_pair : values.each_with_index
      pairs.each do |value, i|
        if enum_prefix == true
          prefix = "#{name}_"
        elsif enum_prefix
          prefix = "#{enum_prefix}_"
        end
        if enum_suffix == true
          suffix = "_#{name}"
        elsif enum_suffix
          suffix = "_#{enum_suffix}"
        end
        value_method_name = "#{prefix}#{value}#{suffix}"
        enum_values[value] = i
        # def active?() status == 0 end
        klass.send(:detect_enum_conflict!, name, "#{value_method_name}?")
        define_method("#{value_method_name}?") { self[name] == value.to_s }
        # def active!() update! status: :active end
        klass.send(:detect_enum_conflict!, name, "#{value_method_name}!")
        define_method("#{value_method_name}!") { update! name => value }
        # scope :active, -> { where status: 0 }
        klass.send(:detect_enum_conflict!, name, value_method_name, true)
        klass.scope value_method_name, -> { where(name => value) }
      end
    end
    defined_enums[name.to_s] = enum_values
  end
end

def inherited(base) # :nodoc:
  base.defined_enums = defined_enums.deep_dup
  super
end

def raise_conflict_error(enum_name, method_name, type: 'instance', source: 'Active Record')
  raise ArgumentError, ENUM_CONFLICT_MESSAGE % {
    enum: enum_name,
    klass: self.name,
    type: type,
    method: method_name,
    source: source
  }
end