module Serega::ClassMethods

# File lib/serega.rb, line 241
def attribute(name, **opts, &block)
  check_unlocked
  location = caller_locations.find { |caller_location| !caller_location.path.start_with?(LIB_PATH) }
  attribute = SeregaAttribute.new(self, name: name, opts: opts, block: block, location: location && "#{location.path}:#{location.lineno}")
  attributes[attribute.name] = attribute
end

# File lib/serega.rb, line 160
def attributes
  @attributes
end

# File lib/serega.rb, line 262
def batch(name, value = nil, &block)
  check_unlocked
  raise SeregaError, "Batch loader must be defined with a callable value or block" if !value == !block

  batch_loader = SeregaBatchLoader.new(name: name, block: value || block)
  batch_loaders[batch_loader.name] = batch_loader
end

# File lib/serega.rb, line 402
def call(object, only: nil, with: nil, except: nil, check_initiate_params: nil, context: nil, many: nil)
  # The serialization methods list each keyword instead of taking
  # `**opts`: a `**opts` Hash allocates on every call, even when empty.
  new(only: only, with: with, except: except, check_initiate_params: check_initiate_params)
    .to_h(object, context: context, many: many)
end

# File lib/serega.rb, line 287
def formatter(name, value = nil, allow_nil: false, &block)
  check_unlocked
  raise SeregaError, "Formatter name must be a Symbol" unless name.is_a?(Symbol)
  raise SeregaError, "Formatter must be defined with a value or a block" if !value == !block
  raise SeregaError, "Invalid option :allow_nil => #{allow_nil.inspect}. Must have a boolean value" unless allow_nil == true || allow_nil == false

  value ||= block
  SeregaValidations::CheckFormatter.call(name, value)
  formatters[name] = SeregaFormatters.build({use: value, allow_nil: allow_nil})
end

# File lib/serega.rb, line 487
def make_shareable!
  return self if @shareable

  lock
  attributes.each_value { |attribute| attribute.serializer.make_shareable! if attribute.initials[:block] }
  @shareable = true
  # :nocov:
  if defined?(Ractor)
    require_relative "serega/shareable"
    require_relative "serega/plan/per_ractor_cache"
    # Other Ractors can not define methods in the presenter, thus each
    # Ractor wraps objects in its own subclass of it
    if @presenter_class
      @presenter_class::Delegators.freeze
      @presenter_key = SeregaUtils::RactorLocal.key(self, :presenter)
    end
    @unshareable_reason = SeregaShareable.call(self)
    @plan_cache = SeregaPlan::PerRactorCache.new(self, SeregaPlan::ModifiersPlanner) unless @unshareable_reason
  end
  # :nocov:
  self
end

# File lib/serega.rb, line 137
def plugin(name, **opts)
  check_unlocked
  raise SeregaError, "This plugin is already loaded" if plugin_used?(name)

  plugin = SeregaPlugins.find(name)
  plugin.apply(self, **opts)
  config.plugins << name

  plugin
end

# File lib/serega.rb, line 338
def preload_with(value = nil, &block)
  return @preload_with if value.nil? && block.nil?

  check_unlocked
  handler = checked_handler(:preload_with, value, block)
  signature = SeregaUtils::MethodSignature.call(handler, pos_limit: 2)
  raise SeregaError, "preload_with handler must accept two positional arguments: (objects, preloads)" unless signature == "2"

  @preload_with = handler
end

# File lib/serega.rb, line 364
def prepare_initial_objects(value = nil, &block)
  return @prepare_initial_objects if value.nil? && block.nil?

  check_unlocked
  handler = checked_handler(:prepare_initial_objects, value, block)
  signature = SeregaUtils::MethodSignature.call(handler, pos_limit: 2, keyword_args: [:ctx])
  raise SeregaError, prepare_initial_objects_signature_error unless %w[1 2 1_ctx].include?(signature)

  @prepare_initial_objects_signature = signature
  @prepare_initial_objects = handler
end

# File lib/serega.rb, line 315
def presenter(&block)
  return @presenter_class unless block

  check_unlocked
  @presenter_class ||= Class.new(SeregaPresenter)
  @presenter_class.class_exec(&block)
  presenter_blocks << block
  @presenter_class
end

# File lib/serega.rb, line 419
def to_data(object, only: nil, with: nil, except: nil, check_initiate_params: nil, context: nil, many: nil)
  new(only: only, with: with, except: except, check_initiate_params: check_initiate_params)
    .to_data(object, context: context, many: many)
end

# File lib/serega.rb, line 450
def to_json(object, only: nil, with: nil, except: nil, check_initiate_params: nil, context: nil, many: nil)
  new(only: only, with: with, except: except, check_initiate_params: check_initiate_params)
    .to_json(object, context: context, many: many)
end

# File lib/serega.rb, line 434
def to_struct(object, only: nil, with: nil, except: nil, check_initiate_params: nil, context: nil, many: nil)
  new(only: only, with: with, except: except, check_initiate_params: check_initiate_params)
    .to_struct(object, context: context, many: many)
end