module T::Props::Serializable::DecoratorMethods

def add_prop_definition(prop, rules)
  serialized_form = rules.fetch(:name, prop.to_s)
  rules[:serialized_form] = serialized_form
  res = super
  prop_by_serialized_forms[serialized_form] = prop
  if T::Configuration.use_vm_prop_serde?
    enqueue_lazy_vm_method_definition!(:__t_props_generated_serialize) {generate_serialize2}
    enqueue_lazy_vm_method_definition!(:__t_props_generated_deserialize) {generate_deserialize2}
  else
    enqueue_lazy_method_definition!(:__t_props_generated_serialize) {generate_serialize_source}
    enqueue_lazy_method_definition!(:__t_props_generated_deserialize) {generate_deserialize_source}
  end
  res
end

def extra_props(instance)
  if instance.instance_variable_defined?(:@_extra_props)
    instance.instance_variable_get(:@_extra_props) || EMPTY_EXTRA_PROPS
  else
    EMPTY_EXTRA_PROPS
  end
end

def from_hash(hash, strict=false)
  raise ArgumentError.new("#{hash.inspect} provided to from_hash") if !(hash && hash.is_a?(Hash))
  i = @class.allocate
  i.deserialize(hash, strict)
  i
end

def generate_deserialize2
ps::Private::DeserializerGenerator.generate2(
rated_class,
s,
s_with_defaults || {},

def generate_deserialize_source
ps::Private::DeserializerGenerator.generate(
s,
s_with_defaults || {},

def generate_serialize2
ps::Private::SerializerGenerator.generate2(decorated_class, props)

def generate_serialize_source
ps::Private::SerializerGenerator.generate(props)

def get_id(instance)
  prop = prop_by_serialized_forms['_id']
  if prop
    get(instance, prop)
  else
    nil
  end
end

def message_with_generated_source_context(error, generated_method, generate_source_method)
  generated_method = generated_method.to_s
  if error.backtrace_locations
    line_loc = error.backtrace_locations.find {|l| l.base_label == generated_method}
    return unless line_loc
    line_num = line_loc.lineno
  else
    label = if RUBY_VERSION >= "3.4"
      # in 'ClassName#__t_props_generated_serialize'"
      "##{generated_method}'"
    else
      # in `__t_props_generated_serialize'"
      "in `#{generated_method}'"
    end
    line_label = error.backtrace.find {|l| l.end_with?(label)}
    return unless line_label
    line_num = if line_label.start_with?("(eval)")
      # (eval):13:in ...
      line_label.split(':')[1]&.to_i
    else
      # (eval at /Users/jez/stripe/sorbet/gems/sorbet-runtime/lib/types/props/has_lazily_specialized_methods.rb:65):13:in ...
      line_label.split(':')[2]&.to_i
    end
  end
  return unless line_num
  source_lines = self.send(generate_source_method).split("\n")
  previous_blank = source_lines[0...line_num].rindex(&:empty?) || 0
  next_blank = line_num + (source_lines[line_num..-1]&.find_index(&:empty?) || 0)
  context = "  #{source_lines[(previous_blank + 1)...next_blank].join("\n  ")}"
  <<~MSG
    Error in #{decorated_class.name}##{generated_method}: #{error.message}
    at line #{line_num - previous_blank - 1} in:
    #{context}
  MSG
end

def pretty_print_extra(instance, pp)
  # This is to maintain backwards compatibility with Stripe's codebase, where only the single line (through `inspect`)
  # version is expected to add anything extra
  return if !pp.is_a?(PP::SingleLine)
  if (extra_props = extra_props(instance)) && !extra_props.empty?
    pp.breakable
    pp.text("@_extra_props=")
    pp.group(1, "<", ">") do
      extra_props.each_with_index do |(prop, value), i|
        pp.breakable unless i.zero?
        pp.text("#{prop}=")
        value.pretty_print(pp)
      end
    end
  end
end

def prop_by_serialized_forms
  @class.prop_by_serialized_forms
end

def prop_dont_store?(prop)
  prop_rules(prop)[:dont_store]
end

def prop_serialized_form(prop)
  prop_rules(prop)[:serialized_form]
end

def prop_validate_definition!(name, cls, rules, type)
  result = super
  if (rules_name = rules[:name])
    unless rules_name.is_a?(String)
      raise ArgumentError.new("Invalid name in prop #{@class.name}.#{name}: #{rules_name.inspect}")
    end
    validate_prop_name(rules_name)
  end
  if !rules[:raise_on_nil_write].nil? && rules[:raise_on_nil_write] != true
    raise ArgumentError.new("The value of `raise_on_nil_write` if specified must be `true` (given: #{rules[:raise_on_nil_write]}).")
  end
  result
end

def raise_nil_deserialize_error(hkey)
  msg = "Tried to deserialize a required prop from a nil value. It's "\
    "possible that a nil value exists in the database, so you should "\
    "provide a `default: or factory:` for this prop (see go/optional "\
    "for more details). If this is already the case, you probably "\
    "omitted a required prop from the `fields:` option when doing a "\
    "partial load."
  storytime = {prop: hkey, klass: decorated_class.name}
  # Notify the model owner if it exists, and always notify the API owner.
  begin
    if T::Configuration.class_owner_finder && (owner = T::Configuration.class_owner_finder.call(decorated_class))
      T::Configuration.hard_assert_handler(
        msg,
        storytime: storytime,
        project: owner
      )
    end
  ensure
    T::Configuration.hard_assert_handler(msg, storytime: storytime)
  end
end

def required_props
  @class.props.select {|_, v| T::Props::Utils.required_prop?(v)}.keys
end

def serialized_form_prop(serialized_form)
  prop_by_serialized_forms[serialized_form.to_s] || raise("No such serialized form: #{serialized_form.inspect}")
end

def valid_rule_key?(key)
  super || VALID_RULE_KEYS[key]
end