class HexaPDF::Type::AcroForm::Field

def self.inherited_value(field, name)
  while field.value[name].nil? && (parent = field[:Parent])
    field = parent
  end
  field.value[name].nil? ? nil : field[name]
end

def self.wrap(document, field)
  document.wrap(field, type: :XXAcroFormField, subtype: inherited_value(field, :FT))
end

def [](name)
  if value[name].nil? && self.class::INHERITABLE_FIELDS.include?(name)
    self.class.inherited_value(self, name) || super
  else
    super
  end
end

def alternate_field_name
  self[:TU]
end

def alternate_field_name=(value)
  self[:TU] = value
end

def concrete_field_type
  case self[:FT]
  when :Btn then :button_field
  when :Tx  then :text_field
  when :Ch  then :choice_field
  when :Sig then :signature_field
  else nil
  end
end

def create_widget(page, allow_embedded: true, **values)
  unless terminal_field?
    raise HexaPDF::Error, "Widgets can only be added to terminal fields"
  end
  widget_data = {Type: :Annot, Subtype: :Widget, Rect: [0, 0, 0, 0], **values}
  if !allow_embedded || embedded_widget? || (key?(:Kids) && !self[:Kids].empty?)
    kids = self[:Kids] ||= []
    kids << extract_widget if embedded_widget?
    widget = document.add(widget_data)
    widget[:Parent] = self
    self[:Kids] << widget
  else
    value.update(widget_data)
    widget = document.wrap(self)
  end
  widget.flag(:print)
  widget[:P] = page
  (page[:Annots] ||= []) << widget
  widget
end

def delete_widget(widget)
  widget = if embedded_widget? && self == widget
             widget
           elsif terminal_field?
             (widget_index = self[:Kids]&.index(widget)) && widget
           end
  return unless widget
  document.pages.each do |page|
    break if page[:Annots]&.delete(widget) # See comment in #extract_widget
  end
  if embedded_widget?
    WIDGET_FIELDS.each {|key| delete(key) }
    document.revisions.each {|revision| break if revision.update(self) }
  else
    self[:Kids].delete_at(widget_index)
    document.delete(widget)
  end
end

def each_widget(direct_only: true, &block) # :yields: widget
  return to_enum(__method__, direct_only: direct_only) unless block_given?
  if embedded_widget?
    yield(document.wrap(self))
  elsif terminal_field?
    self[:Kids]&.each {|kid| yield(document.wrap(kid)) }
  end
  unless direct_only
    my_name = full_field_name
    document.acro_form&.each_field do |field|
      next if field.full_field_name != my_name || field == self
      field.each_widget(direct_only: true, &block)
    end
  end
  self
end

def embedded_widget?
  key?(:Subtype)
end

def extract_widget
  return unless embedded_widget?
  data = WIDGET_FIELDS.each_with_object({}) do |key, hash|
    hash[key] = delete(key) if key?(key)
  end
  widget = document.add(data, type: :Annot)
  widget[:Parent] = self
  document.pages.each do |page|
    if page.key?(:Annots) && (index = page[:Annots].index(self))
      page[:Annots][index] = widget
      break # Each annotation dictionary may only appear on one page, see PDF2.0 12.5.2
    end
  end
  document.revisions.current.update(self)
  widget
end

def field_name
  self[:T]
end

def field_type
  self[:FT]
end

def form_field
  self
end

def full_field_name
  if key?(:Parent)
    [self[:Parent].full_field_name, field_name].compact.join('.')
  else
    field_name
  end
end

def must_be_indirect?
  true
end

def perform_validation #:nodoc:
  super
  if terminal_field? && field_type.nil?
    yield("/FT is required for terminal fields")
  end
  if key?(:T) && self[:T].include?('.')
    yield("/T shall not contain a period")
  end
end

def terminal_field?
  kids = self[:Kids]
  # PDF 2.0 s12.7.4.2 clarifies how to do check for fields since PDF 1.7 isn't clear
  kids.nil? || kids.empty? || kids.none? {|kid| kid.key?(:T) }
end