class BSON::Binary

def self.from_bson(buffer, **_options)
  length = buffer.get_int32
  type_byte = buffer.get_byte
  if type_byte.bytes.first < USER_SUBTYPE
    type = TYPES[type_byte]
    if type.nil?
      raise Error::UnsupportedBinarySubtype,
            "BSON data contains unsupported binary subtype #{'0x%02x' % type_byte.ord}"
    end
  else
    type = type_byte
  end
  length = buffer.get_int32 if type == :old
  data = buffer.get_bytes(length)
  new(data, type)
end

def self.from_csharp_legacy_uuid(uuid_binary)
  uuid_binary.sub!(/\A(.)(.)(.)(.)(.)(.)(.)(.)(.{8})\z/, '\4\3\2\1\6\5\8\7\9')
  new(uuid_binary, :uuid_old)
end

def self.from_java_legacy_uuid(uuid_binary)
  uuid_binary.sub!(/\A(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)\z/) do
    (::Regexp.last_match[1..8].reverse + ::Regexp.last_match[9..16].reverse).join
  end
  new(uuid_binary, :uuid_old)
end

def self.from_python_legacy_uuid(uuid_binary)
  new(uuid_binary, :uuid_old)
end

def self.from_standard_uuid(uuid_binary)
  new(uuid_binary, :uuid)
end

def self.from_uuid(uuid, representation = nil)
  raise ArgumentError, "Representation must be given as a symbol: #{representation}" if representation.is_a?(String)
  uuid_binary = uuid.delete('-').scan(/../).map(&:hex).map(&:chr).join
  representation ||= :standard
  handler = :"from_#{representation}_uuid"
  raise ArgumentError, "Invalid representation: #{representation}" unless respond_to?(handler)
  send(handler, uuid_binary)
end

def ==(other)
  return false unless other.is_a?(Binary)
  type == other.type && data == other.data
end

def as_extended_json(**options)
  subtype = @raw_type.each_byte.map { |c| c.to_s(16) }.join
  subtype = "0#{subtype}" if subtype.length == 1
  value = Base64.encode64(data).strip
  if options[:mode] == :legacy
    { '$binary' => value, '$type' => subtype }
  else
    { '$binary' => { 'base64' => value, 'subType' => subtype } }
  end
end

def as_json(*_args)
  as_extended_json
end

def from_uuid_old_to_csharp_legacy_uuid(hex)
  hex.sub(/\A(..)(..)(..)(..)(..)(..)(..)(..)(.{16})\z/, '\4\3\2\1\6\5\8\7\9')
end

def from_uuid_old_to_java_legacy_uuid(hex)
  hex.sub(/\A(..)(..)(..)(..)(..)(..)(..)(..)(..)(..)(..)(..)(..)(..)(..)(..)\z/) do
    (::Regexp.last_match[1..8].reverse + ::Regexp.last_match[9..16].reverse).join
  end
end

def from_uuid_old_to_python_legacy_uuid(hex)
  hex
end

def from_uuid_old_to_standard_uuid(_hex)
  raise ArgumentError, 'BSON::Binary objects of type :uuid_old cannot be stringified to :standard representation'
end

def from_uuid_old_to_uuid(representation)
  if representation.nil?
    raise ArgumentError, 'Representation must be specified for BSON::Binary objects of type :uuid_old'
  end
  hex = data.chars.map { |n| '%02x' % n.ord }.join
  handler = :"from_uuid_old_to_#{representation}_uuid"
  raise ArgumentError, "Invalid representation: #{representation}" unless respond_to?(handler, true)
  send(handler, hex)
    .sub(/\A(.{8})(.{4})(.{4})(.{4})(.{12})\z/, '\1-\2-\3-\4-\5')
end

def from_uuid_to_uuid(representation)
  if representation != :standard
    raise ArgumentError,
          'Binary of type :uuid can only be stringified to :standard representation, ' \
          "requested: #{representation.inspect}"
  end
  data
    .chars
    .map { |n| '%02x' % n.ord }
    .join
    .sub(/\A(.{8})(.{4})(.{4})(.{4})(.{12})\z/, '\1-\2-\3-\4-\5')
end

def hash
  [ data, type ].hash
end

def init_with(coder)
  initialize_instance(coder['data'], coder['type'])
end

def initialize(data = '', type = :generic)
  initialize_instance(data, type)
end

def initialize_instance(data, type)
  @type = validate_type!(type)
  # The Binary class used to force encoding to BINARY when serializing to
  # BSON. Instead of doing that during serialization, perform this
  # operation during Binary construction to make it clear that once
  # the string is given to the Binary, the data is treated as a binary
  # string and not a text string in any encoding.
  data = data.dup.force_encoding('BINARY') unless data.encoding == Encoding.find('BINARY')
  @data = data
end

def inspect
  "<BSON::Binary:0x#{object_id} type=#{type} data=0x#{data[0, 8].unpack1('H*')}...>"
end

def to_bson(buffer = ByteBuffer.new)
  position = buffer.length
  buffer.put_int32(0)
  buffer.put_byte(@raw_type)
  buffer.put_int32(data.bytesize) if type == :old
  buffer.put_bytes(data)
  buffer.replace_int32(position, buffer.length - position - 5)
end

def to_uuid(representation = nil)
  if representation.is_a?(String)
    raise ArgumentError,
          "Representation must be given as a symbol: #{representation.inspect}"
  end
  case type
  when :uuid
    from_uuid_to_uuid(representation || :standard)
  when :uuid_old
    from_uuid_old_to_uuid(representation)
  else
    raise TypeError, "The type of Binary must be :uuid or :uuid_old, this object is: #{type.inspect}"
  end
end

def validate_integer_type!(type)
  @raw_type = type.chr.force_encoding('BINARY').freeze
  if type < USER_SUBTYPE
    raise BSON::Error::InvalidBinaryType, type unless TYPES.key?(@raw_type)
    return TYPES[@raw_type]
  end
  :user
end

def validate_symbol_type!(type)
  raise BSON::Error::InvalidBinaryType, type unless SUBTYPES.key?(type)
  @raw_type = SUBTYPES[type]
  type
end

def validate_type!(type)
  case type
  when Integer then validate_integer_type!(type)
  when String
    if type.length > 1
      validate_symbol_type!(type.to_sym)
    else
      validate_integer_type!(type.bytes.first)
    end
  when Symbol then validate_symbol_type!(type)
  else raise BSON::Error::InvalidBinaryType, type
  end
end