require 'html5/constants'

#XXX - TODO; make the default interface more ElementTree-like rather than DOM-like

module HTML5

  # The scope markers are inserted when entering buttons, object elements,
  # marquees, table cells, and table captions, and are used to prevent formatting
  # from "leaking" into tables, buttons, object elements, and marquees.
  Marker = nil

  module TreeBuilders
    module Base

      class Node
        # The parent of the current node (or nil for the document node)
        attr_accessor :parent

        # a list of child nodes of the current node. This must 
        # include all elements but not necessarily other node types
        attr_accessor :childNodes

        # A list of miscellaneous flags that can be set on the node
        attr_accessor :_flags

        def initialize(name)
          @parent = nil
          @childNodes = []
          @_flags = []
        end

        # Insert node as a child of the current node
        def appendChild(node)
          raise NotImplementedError
        end

        # Insert data as text in the current node, positioned before the 
        # start of node insertBefore or to the end of the node's text.
        def insertText(data, insertBefore=nil)
          raise NotImplementedError
        end

        # Insert node as a child of the current node, before refNode in the 
        # list of child nodes. Raises ValueError if refNode is not a child of 
        # the current node
        def insertBefore(node, refNode)
          raise NotImplementedError
        end

        # Remove node from the children of the current node
        def removeChild(node)
          raise NotImplementedError
        end

        # Move all the children of the current node to newParent. 
        # This is needed so that trees that don't store text as nodes move the 
        # text in the correct way
        def reparentChildren(newParent)
          #XXX - should this method be made more general?
          @childNodes.each { |child| newParent.appendChild(child) }
          @childNodes = []
        end

        # Return a shallow copy of the current node i.e. a node with the same
        # name and attributes but with no parent or child nodes
        def cloneNode
          raise NotImplementedError
        end

        # Return true if the node has children or text, false otherwise
        def hasContent
          raise NotImplementedError
        end
      end

      # Base treebuilder implementation
      class TreeBuilder

        attr_accessor :openElements

        attr_accessor :activeFormattingElements

        attr_accessor :document

        attr_accessor :headPointer

        attr_accessor :formPointer

        # Class to use for document root
        documentClass = nil

        # Class to use for HTML elements
        elementClass = nil

        # Class to use for comments
        commentClass = nil

        # Class to use for doctypes
        doctypeClass = nil

        # Fragment class
        fragmentClass = nil

        def initialize
          reset
        end

        def reset
          @openElements = []
          @activeFormattingElements = []

          #XXX - rename these to headElement, formElement
          @headPointer = nil
          @formPointer = nil

          self.insertFromTable = false

          @document = @documentClass.new
        end

        def elementInScope(target, tableVariant=false)
          # Exit early when possible.
          return true if @openElements[-1].name == target

          # AT How about while true and simply set node to [-1] and set it to
          # [-2] at the end...
          @openElements.reverse.each do |element|
            if element.name == target
              return true
            elsif element.name == 'table'
              return false
            elsif not tableVariant and SCOPING_ELEMENTS.include?(element.name)
              return false
            elsif element.name == 'html'
              return false
            end
          end
          assert false # We should never reach this point
        end

        def reconstructActiveFormattingElements
          # Within this algorithm the order of steps described in the
          # specification is not quite the same as the order of steps in the
          # code. It should still do the same though.

          # Step 1: stop the algorithm when there's nothing to do.
          return if @activeFormattingElements.empty?

          # Step 2 and step 3: we start with the last element. So i is -1.
          i = -1
          entry = @activeFormattingElements[i]
          return if entry == Marker or @openElements.include?(entry)

          # Step 6
          until entry == Marker or @openElements.include?(entry)
            # Step 5: let entry be one earlier in the list.
            i -= 1
            begin
              entry = @activeFormattingElements[i]
            rescue
              # Step 4: at this point we need to jump to step 8. By not doing
              # i += 1 which is also done in step 7 we achieve that.
              break
            end
          end
          while true
            # Step 7
            i += 1

            # Step 8
            clone = @activeFormattingElements[i].cloneNode

            # Step 9
            element = insertElement(clone.name, clone.attributes)

            # Step 10
            @activeFormattingElements[i] = element

            # Step 11
            break if element == @activeFormattingElements[-1]
          end
        end

        def clearActiveFormattingElements
          {} until @activeFormattingElements.empty? || @activeFormattingElements.pop == Marker
        end

        # Check if an element exists between the end of the active
        # formatting elements and the last marker. If it does, return it, else
        # return false
        def elementInActiveFormattingElements(name)
          @activeFormattingElements.reverse.each do |element|
            # Check for Marker first because if it's a Marker it doesn't have a
            # name attribute.
            break if element == Marker
            return element if element.name == name
          end
          return false
        end

        def insertDoctype(name)
          @document.appendChild(@doctypeClass.new(name))
        end

        def insertComment(data, parent=nil)
          parent = @openElements[-1] if parent.nil?
          parent.appendChild(@commentClass.new(data))
        end
               
        # Create an element but don't insert it anywhere
        def createElement(name, attributes)
          element = @elementClass.new(name)
          element.attributes = attributes
          return element
        end

        # Switch the function used to insert an element from the
        # normal one to the misnested table one and back again
        def insertFromTable=(value)
          @insertFromTable = value
          @insertElement = value ? :insertElementTable : :insertElementNormal
        end

        def insertElement(name, attributes)
          send(@insertElement, name, attributes)
        end

        def insertElementNormal(name, attributes)
          element = @elementClass.new(name)
          element.attributes = attributes
          @openElements[-1].appendChild(element)
          @openElements.push(element)
          return element
        end

        # Create an element and insert it into the tree
        def insertElementTable(name, attributes)
          element = @elementClass.new(name)
          element.attributes = attributes
          if TABLE_INSERT_MODE_ELEMENTS.include?(@openElements[-1].name)
            #We should be in the InTable mode. This means we want to do
            #special magic element rearranging
            parent, insertBefore = getTableMisnestedNodePosition
            if insertBefore.nil?
              parent.appendChild(element)
            else
              parent.insertBefore(element, insertBefore)
            end
            @openElements.push(element)
          else
            return insertElementNormal(name, attributes)
          end
          return element
        end

        def insertText(data, parent=nil)
          parent = @openElements[-1] if parent.nil?

          if (not(@insertFromTable) or (@insertFromTable and not TABLE_INSERT_MODE_ELEMENTS.include?(@openElements[-1].name)))
            parent.insertText(data)
          else
            #We should be in the InTable mode. This means we want to do
            #special magic element rearranging
            parent, insertBefore = getTableMisnestedNodePosition
            parent.insertText(data, insertBefore)
          end
        end
      
        # Get the foster parent element, and sibling to insert before
        # (or nil) when inserting a misnested table node
        def getTableMisnestedNodePosition
          #The foster parent element is the one which comes before the most
          #recently opened table element
          #XXX - this is really inelegant
          lastTable = nil
          fosterParent = nil
          insertBefore = nil
          @openElements.reverse.each do |element|
            if element.name == "table"
              lastTable = element
              break
            end
          end
          if lastTable
            #XXX - we should really check that this parent is actually a
            #node here
            if lastTable.parent
              fosterParent = lastTable.parent
              insertBefore = lastTable
            else
              fosterParent = @openElements[@openElements.index(lastTable) - 1]
            end
          else
            fosterParent = @openElements[0]
          end
          return fosterParent, insertBefore
        end

        def generateImpliedEndTags(exclude=nil)
          name = @openElements[-1].name

          if (['dd', 'dt', 'li', 'p', 'td', 'th', 'tr'].include?(name) and name != exclude)
            @openElements.pop
            # XXX This is not entirely what the specification says. We should
            # investigate it more closely.
            generateImpliedEndTags(exclude)
          end
        end

        def getDocument
          @document
        end
  
        def getFragment
          #assert @innerHTML
          fragment = @fragmentClass.new
          @openElements[0].reparentChildren(fragment)
          return fragment
        end

        # Serialize the subtree of node in the format required by unit tests
        # node - the node from which to start serializing
        def testSerializer(node)
          raise NotImplementedError
        end

      end
    end
  end
end