class HexaPDF::Object

def self.deep_copy(object)
  case object
  when Hash
    object.transform_values {|value| deep_copy(value) }
  when Array
    object.map {|o| deep_copy(o) }
  when HexaPDF::Object
    (object.indirect? || object.must_be_indirect? ? object : deep_copy(object.value))
  when HexaPDF::Reference
    object
  else
    object.dup
  end
end

def self.field(_name)
  nil
end

def self.make_direct(object, document)
  if object.kind_of?(HexaPDF::Object) && object.indirect?
    raise HexaPDF::Error, "Can't make a stream object a direct object" if object.data.stream
    object_to_delete = object
    object = object.value
    object_to_delete.document.delete(object_to_delete)
  end
  case object
  when HexaPDF::Object
    object.data.value = make_direct(object.data.value, document)
  when Hash
    object.transform_values! {|val| make_direct(val, document) }
  when Array
    object.map! {|val| make_direct(val, document) }
  when Reference
    object = make_direct(document.object(object), document)
  end
  object
end

def <=>(other)
  return nil unless other.respond_to?(:oid) && other.respond_to?(:gen)
  (oid == other.oid ? gen <=> other.gen : oid <=> other.oid)
end

def ==(other)
  (other.kind_of?(Object) && data == other.data) || (other.kind_of?(Reference) && other == self) ||
    (!indirect? && !other.kind_of?(Object) && other == data.value)
end

def after_data_change
end

def cache(key, value = Document::UNSET, update: false, &block)
  document.cache(@data, key, value, update: update, &block)
end

def cached?(key)
  document.cached?(@data, key)
end

def clear_cache
  document.clear_cache(@data)
end

def config
  document.config
end

def deep_copy
  obj = dup
  obj.instance_variable_set(:@data, @data.dup)
  obj.data.oid = 0
  obj.data.gen = 0
  obj.data.stream = @data.stream.dup if @data.stream.kind_of?(String)
  obj.data.value = self.class.deep_copy(@data.value)
  obj
end

def document
  @document || raise(HexaPDF::Error, "No document associated with this object (#{inspect})")
end

def document?
  !@document.nil?
end

def eql?(other)
  other.respond_to?(:oid) && oid == other.oid && other.respond_to?(:gen) && gen == other.gen
end

def gen
  data.gen
end

def gen=(gen)
  data.gen = gen
end

def hash
  oid.hash ^ gen.hash
end

def indirect?
  oid != 0
end

def initialize(value, document: nil, oid: nil, gen: nil, stream: nil)
  @data = case value
          when PDFData then value
          when Object then value.data
          else PDFData.new(value)
          end
  @data.oid = oid if oid
  @data.gen = gen if gen
  @data.stream = stream if stream
  self.document = document
  self.must_be_indirect = false
  after_data_change
end

def inspect #:nodoc:
  "#<#{self.class.name} [#{oid}, #{gen}] value=#{value.inspect}>"
end

def must_be_indirect?
  @must_be_indirect
end

def null?
  value.nil?
end

def oid
  data.oid
end

def oid=(oid)
  data.oid = oid
end

def perform_validation(&block)
  # Validate that the object is indirect if #must_be_indirect? is +true+.
  if must_be_indirect? && !indirect?
    yield("Object must be an indirect object", true)
    document.add(self)
  end
  validate_nested(value, &block)
end

def type
  :Unknown
end

def validate(auto_correct: true)
  result = true
  perform_validation do |msg, correctable, object|
    yield(msg, correctable, object || self) if block_given?
    result = false unless correctable
    return false unless auto_correct
  end
  result
end

def validate_nested(obj, &block)
  if obj.kind_of?(HexaPDF::Object) && !obj.indirect?
    obj.validate(&block)
  elsif obj.kind_of?(Hash)
    obj.each_value {|val| validate_nested(val, &block) }
  elsif obj.kind_of?(Array)
    obj.each {|val| validate_nested(val, &block) }
  end
end

def value
  data.value
end

def value=(val)
  data.value = val
  after_data_change
end