module T::Props::Serializable::DecoratorMethods

def add_prop_definition(prop, rules)
  rules[:serialized_form] = rules.fetch(:name, prop.to_s)
  res = super
  prop_by_serialized_forms[rules[: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 inspect_instance_components(instance, multiline:, indent:)
tra_props = extra_props(instance)) && !extra_props.empty?
ty_kvs = extra_props.map {|k, v| [k.to_sym, v.inspect]}
a = join_props_with_pretty_values(pretty_kvs, multiline: false)
r + ["@_extra_props=<#{extra}>"]
r

def message_with_generated_source_context(error, generated_method, generate_source_method)
  line_label = error.backtrace.find {|l| l.end_with?("in `#{generated_method}'")}
  return unless line_label
  line_num = line_label.split(':')[1]&.to_i
  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 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