module XmlTreeViewer

# File lib/xml_tree_viewer.rb, line 24
def self.generate( xml, mode )

  if validate( xml, mode )
    self.draw_xml( xml, mode )
  end
  
  return true
end

# File lib/xml_tree_viewer.rb, line 9
  def self.helper()
    result = <<-EOXML
<employees>
  <employee status="active">
    <fullname>John Doe</fullname>
  </employee>
  <employee status="inactive">
    <fullname>Max Mustermann</fullname>
  </employee>
</employees>
EOXML
    return result
  end

# File lib/xml_tree_viewer.rb, line 118
def self.draw_hash_line( name, mode, offset, key )
    lines = []
    if !mode.eql?( :silent )
        level = name[ 1, name.length ].to_i
        
        str = ''
        edge = self.draw_hash_line_edge( level, :edge, offset )
        str = "#{edge} #{key.name}"
        lines.push( str )

        case mode
        when :short
        when :detail
            empty = self.draw_hash_line_edge( level, :empty, offset )
            str = "#{empty} doc.css('#{key.css_path}')"
            lines.push( str )
        end
    end

    return lines
end

# File lib/xml_tree_viewer.rb, line 94
def self.draw_hash_line_edge( l, type, offset )
    str = ''

    for i in 1..( ( l - 1 ) * offset )
        str += ' '
    end

    case type
    when :edge
        if l > 1
            str += "┗"
            str += "━"
            str += " "
        else
            str += '   '
        end
    when :empty
        str += '   '
    end

    return str
end

# File lib/xml_tree_viewer.rb, line 93
def self.draw_xml( xml, mode )
  def self.draw_hash_line_edge( l, type, offset )
      str = ''

      for i in 1..( ( l - 1 ) * offset )
          str += ' '
      end

      case type
      when :edge
          if l > 1
              str += "┗"
              str += "━"
              str += " "
          else
              str += '   '
          end
      when :empty
          str += '   '
      end

      return str
  end


  def self.draw_hash_line( name, mode, offset, key )
      lines = []
      if !mode.eql?( :silent )
          level = name[ 1, name.length ].to_i
          
          str = ''
          edge = self.draw_hash_line_edge( level, :edge, offset )
          str = "#{edge} #{key.name}"
          lines.push( str )

          case mode
          when :short
          when :detail
              empty = self.draw_hash_line_edge( level, :empty, offset )
              str = "#{empty} doc.css('#{key.css_path}')"
              lines.push( str )
          end
      end

      return lines
  end
      

  struct = Nokogiri::XML( xml )
  types =  [ Hash, ActiveSupport::HashWithIndifferentAccess ]
  offset = 4
  
  lines = []
  !mode.eql?( :silent ) ? lines += [ 'TREE OVERVIEW' ] : ''

  struct.element_children.each do | l1 |
      lines += self.draw_hash_line( 'l1', mode, offset, l1 )
      l1.element_children.each do | l2 |
          lines += self.draw_hash_line( 'l2', mode, offset, l2 )
          l2.element_children.each do | l3 |
              lines += self.draw_hash_line( 'l3', mode, offset, l3 )
              l3.element_children.each do | l4 |
                  lines += self.draw_hash_line( 'l4', mode, offset, l4 )
                  l4.element_children.each do | l5 |
                      lines += self.draw_hash_line( 'l5', mode, offset, l5 )
                      l5.element_children.each do | l6 |
                          lines += self.draw_hash_line( 'l6', mode, offset, l6 )
                          l6.element_children.each do | l7 |
                              lines += self.draw_hash_line( 'l7', mode, offset, l7 )
                              l7.element_children.each do | l8 |
                                  lines += self.draw_hash_line( 'l8', mode, offset, l8 )
                                  l8.element_children.each do | l9 |
                                      lines += self.draw_hash_line( 'l9', mode, offset, l9 )
                                      l9.element_children.each do | l10 |
                                          lines += self.draw_hash_line( 'l10', mode, offset, l10 )
                                          l10.element_children.each do | l11 |
                                              lines += self.draw_hash_line( 'l11', mode, offset, l11 )
                                              l11.element_children.each do | l12 |
                                                  lines += self.draw_hash_line( 'l12', mode, offset, l12 )
                                                  l12.element_children.each do | l13 |
                                                      lines += self.draw_hash_line( 'l13', mode, offset, l13 )
                                                      l13.element_children.each do | l14 |
                                                          lines += self.draw_hash_line( 'l14', mode, offset, l14 )
                                                          l14.element_children.each do | l15 |
                                                              lines += self.draw_hash_line( 'l15', mode, offset, l15 )
                                                              '...'
                                                          end
                                                      end
                                                  end
                                              end
                                          end
                                      end
                                  end
                              end
                          end
                      end
                  end
              end
          end
      end
  end

  if !mode.eql?( :silent )
      lines.each { | line | puts( line ) }
  end

  return true
end

# File lib/xml_tree_viewer.rb, line 83
def self.is_url?( str )
  begin
    uri = URI.parse str
    uri.kind_of? URI::HTTP
  rescue URI::InvalidURIError
      false
  end
end

# File lib/xml_tree_viewer.rb, line 37
def self.validate( xml, mode )
  messages = {
    xml: [],
    mode: []
  }

  if xml.class.to_s.eql?( 'String' )
    doc = Nokogiri::XML( xml )
    if doc.errors.length == 0 
      
    else
      messages[:xml].push( 'XML is not valid')
    end
  else
    messages[:xml].push( 'Is not Type "String"' )
  end


  if mode.class.to_s.eql?( 'Symbol' )
    if [ :silent, :short, :detail].include?( mode )

    else
      messages[:mode].push( "\":#{mode}\" is not authorized, please use :silent, :short or :detail instead.")
    end
  else
    messages[:mode].push( 'Is not Type "Symbol"')
  end

  valid = messages.keys.map { | key | messages[ key ].length }.sum == 0

  if !valid
    puts 'Following errors occured:'
    messages.keys.each do | key |
      if messages[ key ].length != 0
        puts "  #{key[ 0, 1 ].upcase}#{key[ 1, key.length ]}"
        messages[ key ].each do | m |
          puts "  - #{m}"
        end
      end
    end
  end

  return valid
end