module Psych

def self.add_builtin_type type_tag, &block
  domain = 'yaml.org,2002'
  key = ['tag', domain, type_tag].join ':'
  domain_types[key] = [key, block]
end

def self.add_domain_type domain, type_tag, &block
  key = ['tag', domain, type_tag].join ':'
  domain_types[key] = [key, block]
  domain_types["tag:#{type_tag}"] = [key, block]
end

def self.add_tag tag, klass
  load_tags[tag] = klass.name
  dump_tags[klass] = tag
end

def self.dump o, io = nil, options = {}
  if Hash === io
    options = io
    io      = nil
  end
  visitor = Psych::Visitors::YAMLTree.create options
  visitor << o
  visitor.tree.yaml io, options
end

def self.dump_stream *objects
  visitor = Psych::Visitors::YAMLTree.create({})
  objects.each do |o|
    visitor << o
  end
  visitor.tree.yaml
end

def self.load: (File yaml, permitted_classes: Class | Class | Class | Class | Class | Class, permitted_symbols: , aliases: true, filename: String, fallback: nil, symbolize_names: false, freeze: false, strict_integer: false) -> Gem::Specification

def self.load yaml, permitted_classes: [Symbol], permitted_symbols: [], aliases: false, filename: nil, fallback: nil, symbolize_names: false, freeze: false, strict_integer: false
  safe_load yaml, permitted_classes: permitted_classes,
                  permitted_symbols: permitted_symbols,
                  aliases: aliases,
                  filename: filename,
                  fallback: fallback,
                  symbolize_names: symbolize_names,
                  freeze: freeze,
                  strict_integer: strict_integer
end

def self.load_file: (String filename, **aliases | TrueClass | permitted_classes | Class | Class | Class | Class | Class | Class kwargs) -> Gem::Specification

def self.load_file filename, **kwargs
  File.open(filename, 'r:bom|utf-8') { |f|
    self.load f, filename: filename, **kwargs
  }
end

def self.load_stream yaml, filename: nil, fallback: [], **kwargs
  result = if block_given?
             parse_stream(yaml, filename: filename) do |node|
               yield node.to_ruby(**kwargs)
             end
           else
             parse_stream(yaml, filename: filename).children.map { |node| node.to_ruby(**kwargs) }
           end
  return fallback if result.is_a?(Array) && result.empty?
  result
end

def self.parse: (File yaml, filename: String) -> Psych::Nodes::Document

def self.parse yaml, filename: nil
  parse_stream(yaml, filename: filename) do |node|
    return node
  end
  false
end

def self.parse_caller(at)
  if /^(.+?):(\d+)(?::in `.*')?/ =~ at
    file = $1
    line = $2.to_i
    [file, line]
  end
end

def self.parse_file filename, fallback: false
  result = File.open filename, 'r:bom|utf-8' do |f|
    parse f, filename: filename
  end
  result || fallback
end

def self.parse_stream: (File yaml, filename: String, ) -> nil

def self.parse_stream yaml, filename: nil, &block
  if block_given?
    parser = Psych::Parser.new(Handlers::DocumentStream.new(&block))
    parser.parse yaml, filename
  else
    parser = self.parser
    parser.parse yaml, filename
    parser.handler.root
  end
end

def self.parser
  Psych::Parser.new(TreeBuilder.new)
end

def self.remove_type type_tag
  domain_types.delete type_tag
end

def self.safe_dump o, io = nil, options = {}
  if Hash === io
    options = io
    io      = nil
  end
  visitor = Psych::Visitors::RestrictedYAMLTree.create options
  visitor << o
  visitor.tree.yaml io, options
end

def self.safe_load: (File yaml, permitted_classes: Class | Class | Class | Class | Class | Class, permitted_symbols: , aliases: true, filename: String, fallback: nil, symbolize_names: false, freeze: false, strict_integer: false) -> Gem::Specification

def self.safe_load yaml, permitted_classes: [], permitted_symbols: [], aliases: false, filename: nil, fallback: nil, symbolize_names: false, freeze: false, strict_integer: false
  result = parse(yaml, filename: filename)
  return fallback unless result
  class_loader = ClassLoader::Restricted.new(permitted_classes.map(&:to_s),
                                             permitted_symbols.map(&:to_s))
  scanner      = ScalarScanner.new class_loader, strict_integer: strict_integer
  visitor = if aliases
              Visitors::ToRuby.new scanner, class_loader, symbolize_names: symbolize_names, freeze: freeze
            else
              Visitors::NoAliasRuby.new scanner, class_loader, symbolize_names: symbolize_names, freeze: freeze
            end
  result = visitor.accept result
  result
end

def self.safe_load_file filename, **kwargs
  File.open(filename, 'r:bom|utf-8') { |f|
    self.safe_load f, filename: filename, **kwargs
  }
end

def self.to_json object
  visitor = Psych::Visitors::JSONTree.create
  visitor << object
  visitor.tree.yaml
end

def self.unsafe_load yaml, filename: nil, fallback: false, symbolize_names: false, freeze: false, strict_integer: false
  result = parse(yaml, filename: filename)
  return fallback unless result
  result.to_ruby(symbolize_names: symbolize_names, freeze: freeze, strict_integer: strict_integer)
end

def self.unsafe_load_file filename, **kwargs
  File.open(filename, 'r:bom|utf-8') { |f|
    self.unsafe_load f, filename: filename, **kwargs
  }
end

def self.warn_with_uplevel(message, uplevel: 1)
  at = parse_caller(caller[uplevel]).join(':')
  warn "#{at}: #{message}"
end

type Psych_config_return_value = #<Class:0x0000000110e59758>::Config | #<Class:0x000000010d7de390>::Config | #<Class:0x000000010b25e390>::Config | #<Class:0x000000010494e3a0>::Config | #<Class:0x0000000104413fc0>::Config | #<Class:0x000000010b1a46c0>::Config | #<Class:0x00000001099d41a8>::Config

def config: () -> Psych_config_return_value

def config
  Ractor.current[:PsychConfig] ||= Config.new
end