# coding=UTF-8

# Copyright (c) 2008 Geoffrey Sneddon

#

# Permission is hereby granted, free of charge, to any person obtaining a copy

# of this software and associated documentation files (the "Software"), to deal

# in the Software without restriction, including without limitation the rights

# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

# copies of the Software, and to permit persons to whom the Software is

# furnished to do so, subject to the following conditions:

#

# The above copyright notice and this permission notice shall be included in

# all copies or substantial portions of the Software.

#

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

# THE SOFTWARE.

from lxml import etree

from anolislib import utils

# Rank of heading elements (these are negative so h1 > h6)

rank = {u"h1": -1, u"h2": -2, u"h3": -3, u"h4": -4, u"h5": -5, u"h6": -6,

        u"header": -1}

class section(list):

    """Represents the section of a document."""

    header = None

    def __repr__(self):

        return "<section %s>" % (repr(self.header))

    def append(self, child):

        list.append(self, child)

        child.parent = self

    def extend(self, children):

        list.extend(self, children)

        for child in children:

            child.parent = self

class Outliner:

    """Build the outline of an HTML document."""

    def __init__(self, ElementTree, **kwargs):

        self.ElementTree = ElementTree

        self.stack = []

        self.outlines = {}

        self.current_outlinee = None

        self.current_section = None

    def build(self, **kwargs):

        for action, element in etree.iterwalk(self.ElementTree,

                                              events=("start", "end")):

            # If the top of the stack is an element, and you are exiting that

            # element

            if action == "end" and self.stack and self.stack[-1] == element:

                # Note: The element being exited is a heading content element.

                assert element.tag in utils.heading_content

                # Pop that element from the stack.

                self.stack.pop()

            # If the top of the stack is a heading content element

            elif self.stack and self.stack[-1].tag in utils.heading_content:

                # Do nothing.

                pass

            # When entering a sectioning content element or a sectioning root

            # element

            elif action == "start" and \

                 (element.tag in utils.sectioning_content or \

                  element.tag in utils.sectioning_root):

                # If current outlinee is not null, push current outlinee onto

                # the stack.

                if self.current_outlinee is not None:

                    self.stack.append(self.current_outlinee)

                # Let current outlinee be the element that is being entered.

                self.current_outlinee = element

                # Let current section be a newly created section for the

                # current outlinee element.

                self.current_section = section()

                # Let there be a new outline for the new current outlinee,

                # initialized with just the new current section as the only

                # section in the outline.

                self.outlines[self.current_outlinee] = [self.current_section]

            # When exiting a sectioning content element, if the stack is not

            # empty

            elif action == "end" and \

                 element.tag in utils.sectioning_content and self.stack:

                # Pop the top element from the stack, and let the current

                # outlinee be that element.

                self.current_outlinee = self.stack.pop()

                # Let current section be the last section in the outline of the

                # current outlinee element.

                self.current_section = self.outlines[self.current_outlinee][-1]

                # Append the outline of the sectioning content element being

                # exited to the current section. (This does not change which

                # section is the last section in the outline.)

                self.current_section += self.outlines[element]

            # When exiting a sectioning root element, if the stack is not empty

            elif action == "end" and element.tag in utils.sectioning_root and \

                 self.stack:

                # Pop the top element from the stack, and let the current

                # outlinee be that element.

                self.current_outlinee = self.stack.pop()

                # Let current section be the last section in the outline of the

                # current outlinee element.

                self.current_section = self.outlines[self.current_outlinee][-1]

                # Loop: If current section has no child sections, stop these

                # steps.

                while self.current_section:

                    # Let current section be the last child section of the

                    # current current section.

                    assert self.current_section != self.current_section[-1]

                    self.current_section = self.current_section[-1]

                    # Go back to the substep labeled Loop.

            # When exiting a sectioning content element or a sectioning root

            # element

            elif action == "end" and \

                 (element.tag in utils.sectioning_content or \

                  element.tag in utils.sectioning_root):

                # Note: The current outlinee is the element being exited.

                assert self.current_outlinee == element

                # Let current section be the first section in the outline of

                # the current outlinee element.

                self.current_section = self.outlines[self.current_outlinee][0]

                # Skip to the next step in the overall set of steps. (The walk

                # is over.)

                break

            # If the current outlinee is null.

            elif self.current_outlinee is None:

                # Do nothing.

                pass

            # When entering a heading content element

            elif action == "start" and element.tag in utils.heading_content:

                # If the current section has no heading, let the element being

                # entered be the heading for the current section.

                if self.current_section.header is None:

                    self.current_section.header = element

                # Otherwise, if the element being entered has a rank equal to

                # or greater than the heading of the last section of the

                # outline of the current outlinee, then create a new section

                # and append it to the outline of the current outlinee element,

                # so that this new section is the new last section of that

                # outline. Let current section be that new section. Let the

                # element being entered be the new heading for the current

                # section.

                elif rank[element.tag] >= \

                     rank[self.outlines[self.current_outlinee][-1].header.tag]:

                    self.current_section = section()

                    self.outlines[self.current_outlinee] \

                        .append(self.current_section)

                    self.current_section.header = element

                # Otherwise, run these substeps:

                else:

                    # Let candidate section be current section.

                    candidate_section = self.current_section

                    while True:

                        # If the element being entered has a rank lower than

                        # the rank of the heading of the candidate section,

                        # then create a new section, and append it to candidate

                        # section. (This does not change which section is the

                        # last section in the outline.) Let current section be

                        # this new section. Let the element being entered be

                        # the new heading for the current section. Abort these

                        # substeps.

                        if rank[element.tag] < \

                           rank[candidate_section.header.tag]:

                            self.current_section = section()

                            candidate_section.append(self.current_section)

                            self.current_section.header = element

                            break

                        # Let new candidate section be the section that

                        # contains candidate section in the outline of current

                        # outlinee.

                        # Let candidate section be new candidate section.

                        candidate_section = candidate_section.parent

                        # Return to step 2.

                # Push the element being entered onto the stack. (This causes

                # the algorithm to skip any descendants of the element.)

                self.stack.append(element)

        # If the current outlinee is null, then there was no sectioning content

        # element or sectioning root element in the DOM. There is no outline.

        try:

            return self.outlines[self.current_outlinee]

        except KeyError:

            return None