class Rexle

# File lib/rexle.rb, line 231
def initialize(x=nil, rexle: self, debug: false)

  @rexle, @debug = rexle, debug
  $debug = @debug

  puts 'inside Rexle'.debug if debug

  super()

  @instructions = [["xml", "version='1.0' encoding='UTF-8'"]]
  @doctype = :xml

  # what type of input is it? Is it a string, array
  if x then
    procs = {
      String: proc {|x| parse_string(x)},
      Array: proc {|x| x},
      RexleParser: ->(x){ parse_rexle(x)}
    }

    doc_node = ['doc', Attributes.new]

    @a = procs[x.class.to_s.to_sym].call(x)

    @doc = scan_element(*(doc_node << @a))

    # fetch the namespaces
    @prefixes = []

    if @doc.root.attributes then

      xmlns = @doc.root.attributes.select {|k,v| k[/^xmlns:/]}
      @prefixes = xmlns.keys.map{|x| x[/\w+$/]}
    end

  end

end

# File lib/rexle.rb, line 1460
def add_attribute(x) @doc.attribute(x) end

# File lib/rexle.rb, line 1464
def add_element(element)

  if @doc then
    raise 'attempted adding second root element to document' if @doc.root
    @doc.root.add_element(element)
  else
    doc_node = ['doc', Attributes.new, element.to_a]
    @doc = scan_element(*doc_node)
  end
  element
end

# File lib/rexle.rb, line 1476
def add_text(s) end

# File lib/rexle.rb, line 274
def at_css(selector)
  @doc.root.element RexleCSS.new(selector).to_xpath
end

# File lib/rexle.rb, line 1461
def attribute(key) @doc.attribute(key) end

# File lib/rexle.rb, line 1462
def attributes() @doc.attributes end

# File lib/rexle.rb, line 270
def clone()
  Rexle.new self.to_a
end

# File lib/rexle.rb, line 1526
def content(options={})
  CGI.unescapeHTML(xml(options))
end

# File lib/rexle.rb, line 278
def css(selector)

  a = selector.split(',').flat_map do |x|
    @doc.root.xpath RexleCSS.new(x).to_xpath
  end

  return a
end

# File lib/rexle.rb, line 1480
def delete(xpath)

  @doc.xpath(xpath).each {|e| e.delete; e = nil }

end

# File lib/rexle.rb, line 1488
def element(xpath) self.xpath(xpath).first end

# File lib/rexle.rb, line 1489
def elements(s=nil) @doc.elements(s) end

# File lib/rexle.rb, line 1490
def name() @doc.root.name end

# File lib/rexle.rb, line 1439
def parse(x=nil)

  a = []

  if x then
    procs = {
      String: proc {|x| parse_string(x)},
      Array: proc {|x| x}
    }
    a = procs[x.class.to_s.to_sym].call(x)
  else
    a = yield
  end

  doc_node = ['doc',Attributes.new]
  @a = procs[x.class.to_s.to_sym].call(x)
  @doc = scan_element(*(doc_node << @a))

  self
end

# File lib/rexle.rb, line 1499
def root()
  @doc.elements.first
end

# File lib/rexle.rb, line 1498
def text(xpath) @doc.text(xpath) end

# File lib/rexle.rb, line 1491
def to_a() @a end

# File lib/rexle.rb, line 1493
def to_s(options={})
  return '<UNDEFINED/>' unless @doc
  self.xml options
end

# File lib/rexle.rb, line 1503
def write(f)
  f.write xml
end

# File lib/rexle.rb, line 1507
def xml(options={})

  return '' unless @doc
  o = {pretty: false, declaration: true}.merge(options)
  msg = o[:pretty] == false ? :doc_print : :doc_pretty_print

  r = ''

  if o[:declaration] == true then

    unless @instructions and @instructions.assoc 'xml' then
      @instructions.unshift ["xml","version='1.0' encoding='UTF-8'"]
    end
  end

  r << method(msg).call(self.root.children, o[:declaration]).strip
  r
end

# File lib/rexle.rb, line 287
def xpath(path,  &blk)
  @doc.xpath(path,  &blk)
end

# File lib/rexle.rb, line 1532
def parse_rexle(x)

  rp = RexleParser.new(x)
  a = rp.to_a

  @instructions = rp.instructions
  return a
end

# File lib/rexle.rb, line 1541
def parse_string(x)

  # check if the XML string is a dynarex document
  if x[/<summary>/] then

    recordx_type = x[/<recordx_type>(\w+)/m,1]

    if recordx_type then
      procs = {
        #'dynarex' => proc {|x| DynarexParser.new(x).to_a},
        'dynarex' => proc {|x| parse_rexle(x)},
        #'polyrex' => proc {|x| PolyrexParser.new(x).to_a},
        'polyrex' => proc {|x| parse_rexle(x)}
      }
      other_parser = procs[recordx_type]

      if other_parser then

        begin
          other_parser.call(x)
        rescue
          parse_rexle x
        end

      else

        parse_rexle x

      end

    else

      parse_rexle x

    end
  else

    parse_rexle x

  end

end

# File lib/rexle.rb, line 1626
def scan_doc(node)
  children = node.elements.map {|child| scan_doc child}
  attributes = node.attributes.inject({}){|r,x| r.merge(Hash[*x])}
  [node.name, node.text.to_s, attributes, *children]
end

# File lib/rexle.rb, line 1584
def scan_element(name=nil, attributes=nil, *children)

  return unless name

  return Rexle::CData.new(children.first) if name == '!['
  return Rexle::Comment.new(children.first) if name == '!-'

  element = Rexle::Element.new(name, attributes: attributes, rexle: @rexle)

  if children then

    children.each do |x4|


      if x4.is_a? Array then
        element.add_element scan_element(*x4)
      elsif x4.is_a? String then

        e = if x4.is_a? String then

          x4
        elsif x4.name == '![' then

          Rexle::CData.new(x4)

        elsif x4.name == '!-' then

          Rexle::Comment.new(x4)

        end

        element.add_element e
      end
    end
  end

  return element
end