class HexaPDF::Type::OutlineItem

def action(value = nil)
  if value
    delete(:Dest)
    self[:A] = value
  else
    self[:A]
  end
end

def add_item(title, destination: nil, action: nil, position: :last, open: true,
             text_color: nil, flags: nil) # :yield: item
  if title.kind_of?(HexaPDF::Object) && title.type == :XXOutlineItem
    item = title
    item.delete(:Prev)
    item.delete(:Next)
    item.delete(:First)
    item.delete(:Last)
    if item[:Count] && item[:Count] >= 0
      item[:Count] = 0
    else
      item.delete(:Count)
    end
    item[:Parent] = self
  else
    item = document.add({Parent: self}, type: :XXOutlineItem)
    item.title(title)
    if action
      item.action(action)
    else
      item.destination(destination)
    end
    item.text_color(text_color) if text_color
    item.flag(*flags) if flags
    item[:Count] = 0 if open # Count=0 means open if items are later added
  end
  unless position == :last || position == :first || position.kind_of?(Integer)
    raise ArgumentError, "position must be :first, :last, or an integer"
  end
  if self[:First]
    case position
    when :last, -1
      item[:Prev] = self[:Last]
      self[:Last][:Next] = item
      self[:Last] = item
    when :first, 0
      item[:Next] = self[:First]
      self[:First][:Prev] = item
      self[:First] = item
    when Integer
      temp, direction = if position > 0
                          [self[:First], :Next]
                        else
                          position = -position - 2
                          [self[:Last], :Prev]
                        end
      position.times { temp &&= temp[direction] }
      raise ArgumentError, "position out of bounds" if temp.nil?
      item[:Prev] = temp[:Prev]
      item[:Next] = temp
      temp[:Prev] = item
      item[:Prev][:Next] = item
    end
  else
    self[:First] = self[:Last] = item
  end
  # Re-calculate /Count entries
  temp = self
  while temp
    if !temp.key?(:Count) || temp[:Count] < 0
      temp[:Count] = (temp[:Count] || 0) - 1
      break
    else
      temp[:Count] += 1
    end
    temp = temp[:Parent]
  end
  yield(item) if block_given?
  item
end

def destination(value = nil)
  if value
    delete(:A)
    self[:Dest] = document.destinations.use_or_create(value)
  else
    self[:Dest]
  end
end

def destination_page
  dest = self[:Dest]
  dest = action[:D] if !dest && (action = self[:A]) && action[:S] == :GoTo
  document.destinations.resolve(dest)&.page
end

def each_item(&block)
  return to_enum(__method__) unless block_given?
  return self unless (item = self[:First])
  level = self.level + 1
  while item
    yield(item, level)
    item.each_item(&block)
    item = item[:Next]
  end
  self
end

def level
  count = 0
  temp = self
  count += 1 while (temp = temp[:Parent])
  count
end

def must_be_indirect?
  true
end

def open?
  self[:First] && key?(:Count) && self[:Count] >= 0
end

def perform_validation # :nodoc:
  super
  first = self[:First]
  last = self[:Last]
  if (first && !last) || (!first && last)
    yield('Outline item dictionary is missing an endpoint reference', true)
    node, dir = first ? [first, :Next] : [last, :Prev]
    node = node[dir] while node[dir]
    self[dir == :Next ? :Last : :First] = node
  elsif !first && !last && self[:Count] && self[:Count] != 0
    yield('Outline item dictionary key /Count set but no descendants exist', true)
    delete(:Count)
  end
  prev_item = self[:Prev]
  if prev_item && (prev_item_next = prev_item[:Next]) != self
    if prev_item_next
      yield('Outline item /Prev points to item whose /Next points somewhere else', false)
    else
      yield('Outline item /Prev points to item without /Next', true)
      prev_item[:Next] = self
    end
  end
  next_item = self[:Next]
  if next_item && (next_item_prev = next_item[:Prev]) != self
    if next_item_prev
      yield('Outline item /Next points to item whose /Prev points somewhere else', false)
    else
      yield('Outline item /Next points to item without /Prev', true)
      next_item[:Prev] = self
    end
  end
end

def text_color(color = nil)
  if color
    color = HexaPDF::Content::ColorSpace.device_color_from_specification(color)
    unless color.color_space.family == :DeviceRGB
      raise ArgumentError, "The given argument is not a valid RGB color"
    end
    self[:C] = color.components
  else
    Content::ColorSpace.prenormalized_device_color(self[:C])
  end
end

def title(value = nil)
  if value
    self[:Title] = value
  else
    self[:Title]
  end
end