module JSON

def self.create_id
  Thread.current[:"JSON.create_id"] || 'json_class'
end

def self.create_id=(new_value)
  Thread.current[:"JSON.create_id"] = new_value.dup.freeze
end

def [](object, opts = nil)
  if object.is_a?(String)
    return JSON.parse(object, opts)
  elsif object.respond_to?(:to_str)
    str = object.to_str
    if str.is_a?(String)
      return JSON.parse(str, opts)
    end
  end
  JSON.generate(object, opts)
end

def const_missing(const_name)
  case const_name
  when :PRETTY_STATE_PROTOTYPE
    if RUBY_VERSION >= "3.0"
      warn "JSON::PRETTY_STATE_PROTOTYPE is deprecated and will be removed in json 3.0.0, just use JSON.pretty_generate", uplevel: 1, category: :deprecated
    else
      warn "JSON::PRETTY_STATE_PROTOTYPE is deprecated and will be removed in json 3.0.0, just use JSON.pretty_generate", uplevel: 1
    end
    state.new(PRETTY_GENERATE_OPTIONS)
  else
    super
  end
end

def deep_const_get(path) # :nodoc:
  Object.const_get(path)
rescue NameError => e
  raise ArgumentError, "can't get const #{path}: #{e}"
end

def deprecated_singleton_attr_accessor(*attrs)
  args = RUBY_VERSION >= "3.0" ? ", category: :deprecated" : ""
  attrs.each do |attr|
    singleton_class.class_eval <<~RUBY
      def #{attr}
        warn "JSON.#{attr} is deprecated and will be removed in json 3.0.0", uplevel: 1 #{args}
        @#{attr}
      end
      def #{attr}=(val)
        warn "JSON.#{attr}= is deprecated and will be removed in json 3.0.0", uplevel: 1 #{args}
        @#{attr} = val
      end
      def _#{attr}
        @#{attr}
      end
    RUBY
  end
end

def dump(obj, anIO = nil, limit = nil, kwargs = nil)
  if kwargs.nil?
    if limit.nil?
      if anIO.is_a?(Hash)
        kwargs = anIO
        anIO = nil
      end
    elsif limit.is_a?(Hash)
      kwargs = limit
      limit = nil
    end
  end
  unless anIO.nil?
    if anIO.respond_to?(:to_io)
      anIO = anIO.to_io
    elsif limit.nil? && !anIO.respond_to?(:write)
      anIO, limit = nil, anIO
    end
  end
  opts = JSON._dump_default_options
  opts = opts.merge(:max_nesting => limit) if limit
  opts = opts.merge(kwargs) if kwargs
  begin
    State.generate(obj, opts, anIO)
  rescue JSON::NestingError
    raise ArgumentError, "exceed depth limit"
  end
end

def fast_generate(obj, opts = nil)
  if RUBY_VERSION >= "3.0"
    warn "JSON.fast_generate is deprecated and will be removed in json 3.0.0, just use JSON.generate", uplevel: 1, category: :deprecated
  else
    warn "JSON.fast_generate is deprecated and will be removed in json 3.0.0, just use JSON.generate", uplevel: 1
  end
  generate(obj, opts)
end

def fast_unparse(...)
  if RUBY_VERSION >= "3.0"
    warn "JSON.fast_unparse is deprecated and will be removed in json 3.0.0, just use JSON.generate", uplevel: 1, category: :deprecated
  else
    warn "JSON.fast_unparse is deprecated and will be removed in json 3.0.0, just use JSON.generate", uplevel: 1
  end
  generate(...)
end

def generate(obj, opts = nil)
  if State === opts
    opts.generate(obj)
  else
    State.generate(obj, opts, nil)
  end
end

def generator=(generator) # :nodoc:
  old, $VERBOSE = $VERBOSE, nil
  @generator = generator
  generator_methods = generator::GeneratorMethods
  for const in generator_methods.constants
    klass = const_get(const)
    modul = generator_methods.const_get(const)
    klass.class_eval do
      instance_methods(false).each do |m|
        m.to_s == 'to_json' and remove_method m
      end
      include modul
    end
  end
  self.state = generator::State
  const_set :State, self.state
ensure
  $VERBOSE = old
end

def load(source, proc = nil, options = nil)
  opts = if options.nil?
    _load_default_options
  else
    _load_default_options.merge(options)
  end
  unless source.is_a?(String)
    if source.respond_to? :to_str
      source = source.to_str
    elsif source.respond_to? :to_io
      source = source.to_io.read
    elsif source.respond_to?(:read)
      source = source.read
    end
  end
  if opts[:allow_blank] && (source.nil? || source.empty?)
    source = 'null'
  end
  if proc
    opts = opts.dup
    opts[:on_load] = proc.to_proc
  end
  parse(source, opts)
end

def load_file(filespec, opts = nil)
  parse(File.read(filespec, encoding: Encoding::UTF_8), opts)
end

def load_file!(filespec, opts = nil)
  parse!(File.read(filespec, encoding: Encoding::UTF_8), opts)
end

def parse(source, opts = nil)
  opts = ParserOptions.prepare(opts) unless opts.nil?
  Parser.parse(source, opts)
end

def parse!(source, opts = nil)
  if opts.nil?
    parse(source, PARSE_L_OPTIONS)
  else
    parse(source, PARSE_L_OPTIONS.merge(opts))
  end
end

def parser=(parser) # :nodoc:
  @parser = parser
  remove_const :Parser if const_defined?(:Parser, false)
  const_set :Parser, parser
end

def pretty_generate(obj, opts = nil)
  return state.generate(obj) if State === opts
  options = PRETTY_GENERATE_OPTIONS
  if opts
    unless opts.is_a?(Hash)
      if opts.respond_to? :to_hash
        opts = opts.to_hash
      elsif opts.respond_to? :to_h
        opts = opts.to_h
      else
        raise TypeError, "can't convert #{opts.class} into Hash"
      end
    end
    options = options.merge(opts)
  end
  State.generate(obj, options, nil)
end

def pretty_unparse(...)
  if RUBY_VERSION >= "3.0"
    warn "JSON.pretty_unparse is deprecated and will be removed in json 3.0.0, just use JSON.pretty_generate", uplevel: 1, category: :deprecated
  else
    warn "JSON.pretty_unparse is deprecated and will be removed in json 3.0.0, just use JSON.pretty_generate", uplevel: 1
  end
  pretty_generate(...)
end

def restore(...)
  if RUBY_VERSION >= "3.0"
    warn "JSON.restore is deprecated and will be removed in json 3.0.0, just use JSON.load", uplevel: 1, category: :deprecated
  else
    warn "JSON.restore is deprecated and will be removed in json 3.0.0, just use JSON.load", uplevel: 1
  end
  load(...)
end

def unparse(...)
  if RUBY_VERSION >= "3.0"
    warn "JSON.unparse is deprecated and will be removed in json 3.0.0, just use JSON.generate", uplevel: 1, category: :deprecated
  else
    warn "JSON.unparse is deprecated and will be removed in json 3.0.0, just use JSON.generate", uplevel: 1
  end
  generate(...)
end

def unsafe_load(source, proc = nil, options = nil)
  opts = if options.nil?
    _unsafe_load_default_options
  else
    _unsafe_load_default_options.merge(options)
  end
  unless source.is_a?(String)
    if source.respond_to? :to_str
      source = source.to_str
    elsif source.respond_to? :to_io
      source = source.to_io.read
    elsif source.respond_to?(:read)
      source = source.read
    end
  end
  if opts[:allow_blank] && (source.nil? || source.empty?)
    source = 'null'
  end
  result = parse(source, opts)
  recurse_proc(result, &proc) if proc
  result
end