class Riffer::Params::Param

# File lib/riffer/params/param.rb, line 45
def self.from_json_schema(name, schema, required:)
  ruby_type = json_type_to_ruby(schema[:type])
  item_type, nested = resolve_nesting(ruby_type, schema)

  new(
    name: name,
    type: ruby_type,
    required: required,
    description: schema[:description],
    enum: schema[:enum],
    default: schema[:default],
    item_type: item_type,
    nested_params: nested,
  )
end

# File lib/riffer/params/param.rb, line 85
def initialize(name:, type:, required:, description: nil, enum: nil, default: nil, item_type: nil, nested_params: nil)
  @name = name.to_sym
  @type = type
  @required = required
  @description = description
  @enum = enum
  @default = default
  @item_type = item_type
  @nested_params = nested_params
end

# File lib/riffer/params/param.rb, line 118
def to_json_schema(strict: false)
  validate_strict_shape! if strict
  # Nullable so strict providers can distinguish absent from present.
  nullable = strict && !required

  # Providers like Anthropic reject a nullable type union combined with enum.
  if nullable && enum
    schema = { anyOf: [{ type: type_name, enum: enum }, { type: "null" }] } #: Hash[Symbol, untyped]
    schema[:description] = description if description
    return schema
  end

  type = type_name
  type = [type, "null"] if nullable

  schema = { type: type } #: Hash[Symbol, untyped]
  schema[:description] = description if description
  schema[:enum] = enum if enum
  # Strict providers reject the +default+ keyword; emit it only in
  # non-strict mode, where it makes the schema a lossless round-trip
  # source for +from_json_schema+.
  schema[:default] = default unless strict || default.nil?

  if self.type == Array && nested_params
    schema[:items] = nested_params.to_json_schema(strict: strict)
  elsif self.type == Array && item_type
    schema[:items] = { type: TYPE_MAPPINGS[item_type] }
  elsif self.type == Hash && nested_params
    # The nested schema carries its own type: "object", which would clobber a nullable union.
    schema.merge!(nested_params.to_json_schema(strict: strict).except(:type))
  end

  schema
end

# File lib/riffer/params/param.rb, line 112
def type_name
  TYPE_MAPPINGS[type] || type.to_s.downcase
end

# File lib/riffer/params/param.rb, line 98
def valid_type?(value)
  return true if value.nil? && !required

  if [Riffer::Params::Boolean, TrueClass, FalseClass].include?(type)
    [true, false].include?(value)
  elsif type == Float
    value.is_a?(Numeric)
  else
    value.is_a?(type)
  end
end