/*
 * @(#)Clean.java   1.11 2000/08/16
 *
 */

package org.w3c.tidy;

/**
 *
 * Clean up misuse of presentation markup
 *
 * (c) 1998-2000 (W3C) MIT, INRIA, Keio University
 * See Tidy.java for the copyright notice.
 * Derived from <a href="http://www.w3.org/People/Raggett/tidy">
 * HTML Tidy Release 4 Aug 2000</a>
 *
 * @author  Dave Raggett <dsr@w3.org>
 * @author  Andy Quick <ac.quick@sympatico.ca> (translation to Java)
 * @version 1.0, 1999/05/22
 * @version 1.0.1, 1999/05/29
 * @version 1.1, 1999/06/18 Java Bean
 * @version 1.2, 1999/07/10 Tidy Release 7 Jul 1999
 * @version 1.3, 1999/07/30 Tidy Release 26 Jul 1999
 * @version 1.4, 1999/09/04 DOM support
 * @version 1.5, 1999/10/23 Tidy Release 27 Sep 1999
 * @version 1.6, 1999/11/01 Tidy Release 22 Oct 1999
 * @version 1.7, 1999/12/06 Tidy Release 30 Nov 1999
 * @version 1.8, 2000/01/22 Tidy Release 13 Jan 2000
 * @version 1.9, 2000/06/03 Tidy Release 30 Apr 2000
 * @version 1.10, 2000/07/22 Tidy Release 8 Jul 2000
 * @version 1.11, 2000/08/16 Tidy Release 4 Aug 2000
 */

/*
  Filters from other formats such as Microsoft Word
  often make excessive use of presentation markup such
  as font tags, B, I, and the align attribute. By applying
  a set of production rules, it is straight forward to
  transform this to use CSS.

  Some rules replace some of the children of an element by
  style properties on the element, e.g.

  <p><b>...</b></p> -> <p style="font-weight: bold">...</p>

  Such rules are applied to the element's content and then
  to the element itself until none of the rules more apply.
  Having applied all the rules to an element, it will have
  a style attribute with one or more properties. 

  Other rules strip the element they apply to, replacing
  it by style properties on the contents, e.g.
  
  <dir><li><p>...</li></dir> -> <p style="margin-left 1em">...
      
  These rules are applied to an element before processing
  its content and replace the current element by the first
  element in the exposed content.

  After applying both sets of rules, you can replace the
  style attribute by a class value and style rule in the
  document head. To support this, an association of styles
  and class names is built.

  A naive approach is to rely on string matching to test
  when two property lists are the same. A better approach
  would be to first sort the properties before matching.
*/

public class Clean {

    private int classNum = 1;

    private TagTable tt;

    public Clean(TagTable tt)
    {
      this.tt = tt;
    }

    private StyleProp insertProperty(StyleProp props, String name,
                                            String value)
    {
        StyleProp first, prev, prop;
        int cmp;

        prev = null;
        first = props;

        while (props != null)
        {
            cmp = props.name.compareTo(name);

            if (cmp == 0)
            {
                /* this property is already defined, ignore new value */
                return first;
            }

            if (cmp > 0) // props.name > name
            {
                /* insert before this */

                prop = new StyleProp(name, value, props);

                if (prev != null)
                    prev.next = prop;
                else
                    first = prop;

                return first;
            }

            prev = props;
            props = props.next;
        }

        prop = new StyleProp(name, value);

        if (prev != null)
            prev.next = prop;
        else
            first = prop;

        return first;
    }

    /*
     Create sorted linked list of properties from style string
     It temporarily places nulls in place of ':' and ';' to
     delimit the strings for the property name and value.
     Some systems don't allow you to null literal strings,
     so to avoid this, a copy is made first.
    */
    private StyleProp createProps(StyleProp prop, String style)
    {
        int name_end;
        int value_end;
        int value_start = 0;
        int name_start = 0;
        boolean more;

        name_start = 0;
        while (name_start < style.length())
        {
            while (name_start < style.length() &&
                       style.charAt(name_start) == ' ')
                ++name_start;

            name_end = name_start;

            while (name_end < style.length())
            {
                if (style.charAt(name_end) == ':')
                {
                    value_start = name_end + 1;
                    break;
                }

                ++name_end;
            }

            if (name_end >= style.length() || style.charAt(name_end) != ':')
                break;

            while (value_start < style.length() &&
                       style.charAt(value_start) == ' ')
                ++value_start;

            value_end = value_start;
            more = false;

            while (value_end < style.length())
            {
                if (style.charAt(value_end) == ';')
                {
                    more = true;
                    break;
                }

                ++value_end;
            }

            prop = insertProperty(prop,
                                  style.substring(name_start, name_end),
                                  style.substring(value_start, value_end));

            if (more)
            {
                name_start = value_end + 1;
                continue;
            }

            break;
        }

        return prop;
    }

    private String createPropString(StyleProp props)
    {
        String style = "";
        int len;
        StyleProp prop;

        /* compute length */

        for (len = 0, prop = props; prop != null; prop = prop.next)
        {
            len += prop.name.length() + 2;
            len += prop.value.length() + 2;
        }

        for (prop = props; prop != null; prop = prop.next)
        {
            style = style.concat(prop.name);
            style = style.concat(": ");

            style = style.concat(prop.value);

            if (prop.next == null)
                break;

            style = style.concat("; ");
        }

        return style;
    }

    /*
      create string with merged properties
    */
    private String addProperty(String style, String property)
    {
        StyleProp prop;

        prop = createProps(null, style);
        prop = createProps(prop, property);
        style = createPropString(prop);
        return style;
    }

    private String gensymClass(String tag)
    {
        String str;

        str = "c" + classNum;
        classNum++;
        return str;
    }

    private String findStyle(Lexer lexer, String tag, String properties)
    {
        Style style;

        for (style = lexer.styles; style != null; style=style.next)
        {
            if (style.tag.equals(tag) &&
                style.properties.equals(properties))
                return style.tagClass;
        }

        style = new Style(tag, gensymClass(tag), properties, lexer.styles);
        lexer.styles = style;
        return style.tagClass;
    }

    /*
     Find style attribute in node, and replace it
     by corresponding class attribute. Search for
     class in style dictionary otherwise gensym
     new class and add to dictionary.

     Assumes that node doesn't have a class attribute
    */
    private void style2Rule(Lexer lexer, Node node)
    {
        AttVal styleattr, classattr;
        String classname;

        styleattr = node.getAttrByName("style");

        if (styleattr != null)
        {
                classname = findStyle(lexer, node.element, styleattr.value);
                classattr = node.getAttrByName("class");

                /*
		 if there already is a class attribute
		 then append class name after a space
		*/
                if (classattr != null)
		{
                        classattr.value = classattr.value + " " + classname;
                        node.removeAttribute(styleattr);
		}
		else /* reuse style attribute for class attribute */
		{
                        styleattr.attribute = "class";
                        styleattr.value = classname;
		}
        }
    }

    private void addColorRule(Lexer lexer, String selector, String color)
    {
        if (color != null)
        {
            lexer.addStringLiteral(selector);
            lexer.addStringLiteral(" { color: ");
            lexer.addStringLiteral(color);
            lexer.addStringLiteral(" }\n");
        }
    }

    /*
     move presentation attribs from body to style element

     background="foo" ->  body { background-image: url(foo) }
     bgcolor="foo"    ->  body { background-color: foo }
     text="foo"       ->  body { color: foo }
     link="foo"       ->  :link { color: foo }
     vlink="foo"      ->  :visited { color: foo }
     alink="foo"      ->  :active { color: foo }
    */
    private void cleanBodyAttrs(Lexer lexer, Node body)
    {
        AttVal attr;
        String bgurl = null;
        String bgcolor = null;
        String color = null;
    
        attr = body.getAttrByName("background");

        if (attr != null)
        {
            bgurl = attr.value;
            attr.value = null;
            body.removeAttribute(attr);
        }

        attr = body.getAttrByName("bgcolor");

        if (attr != null)
        {
            bgcolor = attr.value;
            attr.value = null;
            body.removeAttribute(attr);
        }

        attr = body.getAttrByName("text");

        if (attr != null)
        {
            color = attr.value;
            attr.value = null;
            body.removeAttribute(attr);
        }

        if (bgurl != null || bgcolor != null || color != null)
        {
            lexer.addStringLiteral(" body {\n");

            if (bgurl != null)
            {
                lexer.addStringLiteral("  background-image: url(");
                lexer.addStringLiteral(bgurl);
                lexer.addStringLiteral(");\n");
            }

            if (bgcolor != null)
            {
                lexer.addStringLiteral("  background-color: ");
                lexer.addStringLiteral(bgcolor);
                lexer.addStringLiteral(";\n");
            }

            if (color != null)
            {
                lexer.addStringLiteral("  color: ");
                lexer.addStringLiteral(color);
                lexer.addStringLiteral(";\n");
            }

            lexer.addStringLiteral(" }\n");
        }

        attr = body.getAttrByName("link");

        if (attr != null)
        {
            addColorRule(lexer, " :link", attr.value);
            body.removeAttribute(attr);
        }

        attr = body.getAttrByName("vlink");

        if (attr != null)
        {
            addColorRule(lexer, " :visited", attr.value);
            body.removeAttribute(attr);
        }

        attr = body.getAttrByName("alink");

        if (attr != null)
        {
            addColorRule(lexer, " :active", attr.value);
            body.removeAttribute(attr);
        }
    }

    private boolean niceBody(Lexer lexer, Node doc)
    {
        Node body = doc.findBody(lexer.configuration.tt);

        if (body != null)
        {
            if (
                body.getAttrByName("background") != null ||
                body.getAttrByName("bgcolor") != null ||
                body.getAttrByName("text") != null ||
                body.getAttrByName("link") != null ||
                body.getAttrByName("vlink") != null ||
                body.getAttrByName("alink") != null
               )
            {
                lexer.badLayout |= Report.USING_BODY;
                return false;
            }
        }

        return true;
    }

    /* create style element using rules from dictionary */
    private void createStyleElement(Lexer lexer, Node doc)
    {
        Node node, head, body;
        Style style;
        AttVal av;

        if (lexer.styles == null && niceBody(lexer, doc))
            return;

        node = lexer.newNode(Node.StartTag, null, 0, 0, "style");
        node.implicit = true;

        /* insert type attribute */
        av = new AttVal(null, null, '"', "type", "text/css");
        av.dict = AttributeTable.getDefaultAttributeTable().findAttribute(av);
        node.attributes = av;

        body = doc.findBody(lexer.configuration.tt);

        lexer.txtstart = lexer.lexsize;

        if (body != null)
            cleanBodyAttrs(lexer, body);

        for (style = lexer.styles; style != null; style = style.next)
        {
            lexer.addCharToLexer(' ');
            lexer.addStringLiteral(style.tag);
            lexer.addCharToLexer('.');
            lexer.addStringLiteral(style.tagClass);
            lexer.addCharToLexer(' ');
            lexer.addCharToLexer('{');
            lexer.addStringLiteral(style.properties);
            lexer.addCharToLexer('}');
            lexer.addCharToLexer('\n');
        }

        lexer.txtend = lexer.lexsize;

        Node.insertNodeAtEnd(node,
                             lexer.newNode(Node.TextNode,
                                      lexer.lexbuf,
                                      lexer.txtstart,
                                      lexer.txtend));

        /*
         now insert style element into document head

         doc is root node. search its children for html node
         the head node should be first child of html node
        */

        head = doc.findHEAD(lexer.configuration.tt);
    
        if (head != null)
            Node.insertNodeAtEnd(head, node);
    }

    /* ensure bidirectional links are consistent */
    private void fixNodeLinks(Node node)
    {
        Node child;

        if (node.prev != null)
            node.prev.next = node;
        else
            node.parent.content = node;

        if (node.next != null)
            node.next.prev = node;
        else
            node.parent.last = node;

        for (child = node.content; child != null; child = child.next)
            child.parent = node;
    }

    /*
     used to strip child of node when
     the node has one and only one child
    */
    private void stripOnlyChild(Node node)
    {
        Node child;

        child = node.content;
        node.content = child.content;
        node.last = child.last;
        child.content = null;

        for (child = node.content; child != null; child = child.next)
            child.parent = node;
    }

    /* used to strip font start and end tags */
    private void discardContainer(Node element, MutableObject pnode)
    {
        Node node;
        Node parent = element.parent;

        if (element.content != null)
        {
            element.last.next = element.next;

            if (element.next != null)
            {
                element.next.prev = element.last;
                element.last.next = element.next;
            }
            else
                parent.last = element.last;

            if (element.prev != null)
            {
                element.content.prev = element.prev;
                element.prev.next = element.content;
            }
            else
                parent.content = element.content;

            for (node = element.content; node != null; node = node.next)
                node.parent = parent;

            pnode.setObject(element.content);
        }
        else
        {
            if (element.next != null)
                element.next.prev = element.prev;
            else
                parent.last = element.prev;

            if (element.prev != null)
                element.prev.next = element.next;
            else
                parent.content = element.next;

            pnode.setObject(element.next);
        }

        element.next = null;
        element.content = null;
    }

    /*
     Add style property to element, creating style
     attribute as needed and adding ; delimiter
    */
    private void addStyleProperty(Node node, String property)
    {
        AttVal av;

        for (av = node.attributes; av != null; av = av.next)
        {
            if (av.attribute.equals("style"))
                break;
        }

        /* if style attribute already exists then insert property */

        if (av != null)
        {
            String s;

            s = addProperty(av.value, property);
            av.value = s;
        }
        else /* else create new style attribute */
        {
            av = new AttVal(node.attributes, null, '"', "style", property);
            av.dict = AttributeTable.getDefaultAttributeTable().findAttribute(av);
            node.attributes = av;
        }
    }

    /*
      Create new string that consists of the
      combined style properties in s1 and s2

      To merge property lists, we build a linked
      list of property/values and insert properties
      into the list in order, merging values for
      the same property name.
    */
    private String mergeProperties(String s1, String s2)
    {
        String s;
        StyleProp prop;

        prop = createProps(null, s1);
        prop = createProps(prop, s2);
        s = createPropString(prop);
        return s;
    }

    private void mergeStyles(Node node, Node child)
    {
        AttVal av;
        String s1, s2, style;

        for (s2 = null, av = child.attributes; av != null; av = av.next)
        {
            if (av.attribute.equals("style"))
            {
                s2 = av.value;
                break;
            }
        }

        for (s1 = null, av = node.attributes; av != null; av = av.next)
        {
            if (av.attribute.equals("style"))
            {
                s1 = av.value;
                break;
            }
        }

        if (s1 != null)
        {
            if (s2 != null)  /* merge styles from both */
            {
                style = mergeProperties(s1, s2);
                av.value = style;
            }
        }
        else if (s2 != null)  /* copy style of child */
        {
            av = new AttVal(node.attributes, null, '"', "style", s2);
            av.dict = AttributeTable.getDefaultAttributeTable().findAttribute(av);
            node.attributes = av;
        }
    }

    private String fontSize2Name(String size)
    {
        /*
        String[] sizes =
        {
            "50%",
            "60%",
            "80%",
            null,
            "120%",
            "150%",
            "200%"
        };
        */

        String[] sizes =
        {
            "60%",
            "70%",
            "80%",
            null,
            "120%",
            "150%",
            "200%"
        };
        String buf;

        if (size.length() > 0 &&
            '0' <= size.charAt(0) && size.charAt(0) <= '6')
        {
            int n = size.charAt(0) - '0';
            return sizes[n];
        }

        if (size.length() > 0 && size.charAt(0) == '-')
        {
            if (size.length() > 1 &&
                '0' <= size.charAt(1) && size.charAt(1) <= '6')
            {
                int n = size.charAt(1) - '0';
                double x;

                for (x = 1.0; n > 0; --n)
                    x *= 0.8;

                x *= 100.0;
                buf = "" + (int)x + "%";

                return buf;
            }

            return "smaller"; /*"70%"; */
        }

        if (size.length() > 1 &&
            '0' <= size.charAt(1) && size.charAt(1) <= '6')
        {
            int n = size.charAt(1) - '0';
            double x;

            for (x = 1.0; n > 0; --n)
                x *= 1.2;

            x *= 100.0;
            buf = "" + (int)x + "%";

            return buf;
        }

        return "larger"; /* "140%" */
    }

    private void addFontFace(Node node, String face)
    {
        addStyleProperty(node, "font-family: " + face);
    }

    private void addFontSize(Node node, String size)
    {
        String value;

        if (size.equals("6") && node.tag == tt.tagP)
        {
            node.element = "h1";
            tt.findTag(node);
            return;
        }

        if (size.equals("5") && node.tag == tt.tagP)
        {
            node.element = "h2";
            tt.findTag(node);
            return;
        }

        if (size.equals("4") && node.tag == tt.tagP)
        {
            node.element = "h3";
            tt.findTag(node);
            return;
        }

        value = fontSize2Name(size);

        if (value != null)
        {
            addStyleProperty(node, "font-size: " + value);
        }
    }

    private void addFontColor(Node node, String color)
    {
        addStyleProperty(node, "color: " + color);
    }

    private void addAlign(Node node, String align)
    {
        /* force alignment value to lower case */
        addStyleProperty(node, "text-align: " + align.toLowerCase());
    }

    /*
     add style properties to node corresponding to
     the font face, size and color attributes
    */
    private void addFontStyles(Node node, AttVal av)
    {
        while (av != null)
        {
            if (av.attribute.equals("face"))
                addFontFace(node, av.value);
            else if (av.attribute.equals("size"))
                addFontSize(node, av.value);
            else if (av.attribute.equals("color"))
                addFontColor(node, av.value);

            av = av.next;
        }
    }

    /*
        Symptom: <p align=center>
        Action: <p style="text-align: center">
    */
    private void textAlign(Lexer lexer, Node node)
    {
        AttVal av, prev;

        prev = null;

        for (av = node.attributes; av != null; av = av.next)
        {
            if (av.attribute.equals("align"))
            {
                if (prev != null)
                    prev.next = av.next;
                else
                    node.attributes = av.next;

                if (av.value != null)
                {
                    addAlign(node, av.value);
                }

                break;
            }

            prev = av;
        }
    }

    /*
       The clean up rules use the pnode argument to return the
       next node when the orignal node has been deleted
    */

    /*
        Symptom: <dir> <li> where <li> is only child
        Action: coerce <dir> <li> to <div> with indent.
    */

    private boolean dir2Div(Lexer lexer, Node node, MutableObject pnode)
    {
        Node child;

        if (node.tag == tt.tagDir ||
            node.tag == tt.tagUl ||
            node.tag == tt.tagOl)
        {
            child = node.content;

            if (child == null)
                return false;

            /* check child has no peers */

            if (child.next != null)
                return false;

            if (child.tag != tt.tagLi)
                return false;

            if (!child.implicit)
                return false;

            /* coerce dir to div */

            node.tag = tt.tagDiv;
            node.element = "div";
            addStyleProperty(node, "margin-left: 2em");
            stripOnlyChild(node);
            return true;

//#if 0
            //Node content;
            //Node last;
            //content = child.content;
            //last = child.last;
            //child.content = null;

            /* adjust parent and set margin on contents of <li> */

            //for (child = content; child != null; child = child.next)
            //{
            //    child.parent = node.parent;
            //    addStyleProperty(child, "margin-left: 1em");
            //}

            /* hook first/last into sequence */

            //if (content != null)
            //{
            //    content.prev = node.prev;
            //    last.next = node.next;
            //    fixNodeLinks(content);
            //    fixNodeLinks(last);
            //}

            //node.next = null;

            /* ensure that new node is cleaned */
            //pnode.setObject(cleanNode(lexer, content));
            //return true;
//#endif
        }

        return false;
    }

    /*
        Symptom: <center>
        Action: replace <center> by <div style="text-align: center">
    */

    private boolean center2Div(Lexer lexer, Node node, MutableObject pnode)
    {
        if (node.tag == tt.tagCenter)
        {
            if (lexer.configuration.DropFontTags)
            {
                if (node.content != null)
                {
                    Node last = node.last;
                    Node parent = node.parent;

                    discardContainer(node, pnode);

                    node = lexer.inferredTag("br");

                    if (last.next != null)
                        last.next.prev = node;

                    node.next = last.next;
                    last.next = node;
                    node.prev = last;

                    if (parent.last == last)
                        parent.last = node;

                    node.parent = parent;
                }
                else
                {
                    Node prev = node.prev;
                    Node next = node.next;
                    Node parent = node.parent;
                    discardContainer(node, pnode);

                    node = lexer.inferredTag("br");
                    node.next = next;
                    node.prev = prev;
                    node.parent = parent;

                    if (next != null)
                        next.prev = node;
                    else
                        parent.last = node;

                    if (prev != null)
                        prev.next = node;
                    else
                        parent.content = node;
                }

                return true;
            }
            node.tag = tt.tagDiv;
            node.element = "div";
            addStyleProperty(node, "text-align: center");
            return true;
        }

        return false;
    }

    /*
        Symptom <div><div>...</div></div>
        Action: merge the two divs

      This is useful after nested <dir>s used by Word
      for indenting have been converted to <div>s
    */
    private boolean mergeDivs(Lexer lexer, Node node, MutableObject pnode)
    {
        Node child;

        if (node.tag != tt.tagDiv)
            return false;

        child = node.content;

        if (child == null)
            return false;

        if (child.tag != tt.tagDiv)
            return false;

        if (child.next != null)
            return false;

        mergeStyles(node, child);
        stripOnlyChild(node);
        return true;
    }

    /*
        Symptom: <ul><li><ul>...</ul></li></ul>
        Action: discard outer list
    */

    private boolean nestedList(Lexer lexer, Node node, MutableObject pnode)
    {
        Node child, list;

        if (node.tag == tt.tagUl || node.tag == tt.tagOl)
        {
            child = node.content;

            if (child == null)
                return false;

            /* check child has no peers */

            if (child.next != null)
                return false;

            list = child.content;

            if (list == null)
                return false;

            if (list.tag != node.tag)
                return false;

            pnode.setObject(node.next);

            /* move inner list node into position of outer node */
            list.prev = node.prev;
            list.next = node.next;
            list.parent = node.parent;
            fixNodeLinks(list);

            /* get rid of outer ul and its li */
            child.content = null;
            node.content = null;
            node.next = null;

            /*
              If prev node was a list the chances are this node
              should be appended to that list. Word has no way of
              recognizing nested lists and just uses indents
            */

            if (list.prev != null)
            {
                node = list;
                list = node.prev;

                if (list.tag == tt.tagUl || list.tag == tt.tagOl)
                {
                    list.next = node.next;

                    if (list.next != null)
                        list.next.prev = list;

                    child = list.last;  /* <li> */

                    node.parent = child;
                    node.next = null;
                    node.prev = child.last;
                    fixNodeLinks(node);
                }
            }

            cleanNode(lexer, node);
            return true;
        }

        return false;
    }

    /*
        Symptom: the only child of a block-level element is a
        presentation element such as B, I or FONT

        Action: add style "font-weight: bold" to the block and
        strip the <b> element, leaving its children.

      example:

        <p>
          <b><font face="Arial" size="6">Draft Recommended Practice</font></b>
        </p>

      becomes:

          <p style="font-weight: bold; font-family: Arial; font-size: 6">
            Draft Recommended Practice
          </p>

      This code also replaces the align attribute by a style attribute.
      However, to avoid CSS problems with Navigator 4, this isn't done
      for the elements: caption, tr and table
    */
    private boolean blockStyle(Lexer lexer, Node node, MutableObject pnode)
    {
        Node child;

        if ((node.tag.model & (Dict.CM_BLOCK | Dict.CM_LIST | Dict.CM_DEFLIST | Dict.CM_TABLE)) != 0)
        {
            if (node.tag != tt.tagTable
                    && node.tag != tt.tagTr
                    && node.tag != tt.tagLi)
            {
                /* check for align attribute */
                if (node.tag != tt.tagCaption)
                    textAlign(lexer, node);

                child = node.content;

                if (child == null)
                    return false;

                /* check child has no peers */

                if (child.next != null)
                    return false;

                if (child.tag == tt.tagB)
                {
                    mergeStyles(node, child);
                    addStyleProperty(node, "font-weight: bold");
                    stripOnlyChild(node);
                    return true;
                }

                if (child.tag == tt.tagI)
                {
                    mergeStyles(node, child);
                    addStyleProperty(node, "font-style: italic");
                    stripOnlyChild(node);
                    return true;
                }

                if (child.tag == tt.tagFont)
                {
                    mergeStyles(node, child);
                    addFontStyles(node, child.attributes);
                    stripOnlyChild(node);
                    return true;
                }
            }
        }

        return false;
    }

    /* the only child of table cell or an inline element such as em */
    private boolean inlineStyle(Lexer lexer, Node node, MutableObject pnode)
    {
        Node child;

        if (node.tag != tt.tagFont && (node.tag.model & (Dict.CM_INLINE|Dict.CM_ROW)) != 0)
        {
            child = node.content;

            if (child == null)
                return false;

            /* check child has no peers */

            if (child.next != null)
                return false;

            if (child.tag == tt.tagB && lexer.configuration.LogicalEmphasis)
            {
                mergeStyles(node, child);
                addStyleProperty(node, "font-weight: bold");
                stripOnlyChild(node);
                return true;
            }

            if (child.tag == tt.tagI && lexer.configuration.LogicalEmphasis)
            {
                mergeStyles(node, child);
                addStyleProperty(node, "font-style: italic");
                stripOnlyChild(node);
                return true;
            }

            if (child.tag == tt.tagFont)
            {
                mergeStyles(node, child);
                addFontStyles(node, child.attributes);
                stripOnlyChild(node);
                return true;
            }
        }

        return false;
    }

    /*
      Replace font elements by span elements, deleting
      the font element's attributes and replacing them
      by a single style attribute.
    */
    private boolean font2Span(Lexer lexer, Node node, MutableObject pnode)
    {
        AttVal av, style, next;

        if (node.tag == tt.tagFont)
        {
            if (lexer.configuration.DropFontTags)
            {
                discardContainer(node, pnode);
                return false;
            }

            /* if FONT is only child of parent element then leave alone */
            if (node.parent.content == node
                && node.next == null)
                return false;

            addFontStyles(node, node.attributes);

            /* extract style attribute and free the rest */
            av = node.attributes;
            style = null;

            while (av != null)
            {
                next = av.next;

                if (av.attribute.equals("style"))
                {
                    av.next = null;
                    style = av;
                }

                av = next;
            }

            node.attributes = style;

            node.tag = tt.tagSpan;
            node.element = "span";

            return true;
        }

        return false;
    }

    /*
      Applies all matching rules to a node.
    */
    private Node cleanNode(Lexer lexer, Node node)
    {
        Node next = null;
        MutableObject o = new MutableObject();
        boolean b = false;

        for (next = node; node.isElement(); node = next)
        {
            o.setObject(next);

            b = dir2Div(lexer, node, o);
            next = (Node)o.getObject();
            if (b)
                continue;

            b = nestedList(lexer, node, o);
            next = (Node)o.getObject();
            if (b)
                continue;

            b = center2Div(lexer, node, o);
            next = (Node)o.getObject();
            if (b)
                continue;

            b = mergeDivs(lexer, node, o);
            next = (Node)o.getObject();
            if (b)
                continue;

            b = blockStyle(lexer, node, o);
            next = (Node)o.getObject();
            if (b)
                continue;

            b = inlineStyle(lexer, node, o);
            next = (Node)o.getObject();
            if (b)
                continue;

            b = font2Span(lexer, node, o);
            next = (Node)o.getObject();
            if (b)
                continue;

            break;
        }

        return next;
    }

    private Node createStyleProperties(Lexer lexer, Node node)
    {
        Node child;

        if (node.content != null)
        {
            for (child = node.content; child != null; child = child.next)
            {
                child = createStyleProperties(lexer, child);
            }
        }

        return cleanNode(lexer, node);
    }

    private void defineStyleRules(Lexer lexer, Node node)
    {
        Node child;

        if (node.content != null)
        {
            for (child = node.content;
                    child != null; child = child.next)
            {
                defineStyleRules(lexer, child);
            }
        }

        style2Rule(lexer, node);
    }

    public void cleanTree(Lexer lexer, Node doc)
    {
        doc = createStyleProperties(lexer, doc);

        if (!lexer.configuration.MakeClean)
        {
            defineStyleRules(lexer, doc);
            createStyleElement(lexer, doc);
        }
    }

    /* simplifies <b><b> ... </b> ...</b> etc. */
    public void nestedEmphasis(Node node)
    {
        MutableObject o = new MutableObject();
        Node next;

        while (node != null)
        {
            next = node.next;

            if ((node.tag == tt.tagB || node.tag == tt.tagI)
                && node.parent != null && node.parent.tag == node.tag)
            {
                /* strip redundant inner element */
                o.setObject(next);
                discardContainer(node, o);
                next = (Node)o.getObject();
                node = next;
                continue;
            }

            if (node.content != null)
                nestedEmphasis(node.content);

            node = next;
        }
    }

    /* replace i by em and b by strong */
    public void emFromI(Node node)
    {
        while (node != null)
        {
            if (node.tag == tt.tagI)
            {
                node.element = tt.tagEm.name;
                node.tag = tt.tagEm;
            }
            else if (node.tag == tt.tagB)
            {
                node.element = tt.tagStrong.name;
                node.tag = tt.tagStrong;
            }

            if (node.content != null)
                emFromI(node.content);

            node = node.next;
        }
    }

    /*
     Some people use dir or ul without an li
     to indent the content. The pattern to
     look for is a list with a single implicit
     li. This is recursively replaced by an
     implicit blockquote.
    */
    public void list2BQ(Node node)
    {
        while (node != null)
        {
            if (node.content != null)
                list2BQ(node.content);

            if (node.tag != null && node.tag.parser == ParserImpl.getParseList() &&
                node.hasOneChild() && node.content.implicit)
            {
                stripOnlyChild(node);
                node.element = tt.tagBlockquote.name;
                node.tag = tt.tagBlockquote;
                node.implicit = true;
            }

            node = node.next;
        }
    }

    /*
     Replace implicit blockquote by div with an indent
     taking care to reduce nested blockquotes to a single
     div with the indent set to match the nesting depth
    */
    public void bQ2Div(Node node)
    {
        int indent;
        String indent_buf;

        while (node != null)
        {
            if (node.tag == tt.tagBlockquote && node.implicit)
            {
                indent = 1;

                while(node.hasOneChild() &&
                      node.content.tag == tt.tagBlockquote &&
                      node.implicit)
                {
                    ++indent;
                    stripOnlyChild(node);
                }

                if (node.content != null)
                    bQ2Div(node.content);

                indent_buf = "margin-left: " +
                             (new Integer(2*indent)).toString() + "em";

                node.element = tt.tagDiv.name;
                node.tag = tt.tagDiv;
                node.addAttribute("style", indent_buf);
            }
            else if (node.content != null)
                bQ2Div(node.content);


            node = node.next;
        }
    }

    /* node is <![if ...]> prune up to <![endif]> */
    public Node pruneSection(Lexer lexer, Node node)
    {
        for (;;)
        {
            /* discard node and returns next */
            node = Node.discardElement(node);

            if (node == null)
                return null;
        
            if (node.type == Node.SectionTag)
            {
                if ((Lexer.getString(node.textarray, node.start, 2)).equals("if"))
                {
                    node = pruneSection(lexer, node);
                    continue;
                }

                if ((Lexer.getString(node.textarray, node.start, 5)).equals("endif"))
                {
                    node = Node.discardElement(node);
                    break;
                }
            }
        }

        return node;
    }

    public void dropSections(Lexer lexer, Node node)
    {
        while (node != null)
        {
            if (node.type == Node.SectionTag)
            {
                /* prune up to matching endif */
                if ((Lexer.getString(node.textarray, node.start, 2)).equals("if"))
                {
                    node = pruneSection(lexer, node);
                    continue;
                }

                /* discard others as well */
                node = Node.discardElement(node);
                continue;
            }

            if (node.content != null)
                dropSections(lexer, node.content);

            node = node.next;
        }
    }

    public void purgeAttributes(Node node)
    {
        AttVal attr = node.attributes;
        AttVal next = null;
        AttVal prev = null;

        while (attr != null)
        {
            next = attr.next;

            /* special check for class="Code" denoting pre text */
            if (attr.attribute != null &&
                attr.value != null &&
                attr.attribute.equals("class") &&
                attr.value.equals("Code"))
            {
                prev = attr;
            }
            else if (attr.attribute != null &&
                (attr.attribute.equals("class") ||
                 attr.attribute.equals("style") ||
                 attr.attribute.equals("lang") ||
                 attr.attribute.startsWith("x:") ||
                 ((attr.attribute.equals("height") || attr.attribute.equals("width")) &&
                    (node.tag == tt.tagTd || node.tag == tt.tagTr || node.tag == tt.tagTh))))
            {
                if (prev != null)
                    prev.next = next;
                else
                    node.attributes = next;

            }
            else
                prev = attr;

            attr = next;
        }
    }

    /* Word2000 uses span excessively, so we strip span out */
    public Node stripSpan(Lexer lexer, Node span)
    {
        Node node;
        Node prev = null;
        Node content;

        /*
         deal with span elements that have content
         by splicing the content in place of the span
         after having processed it
        */

        cleanWord2000(lexer, span.content);
        content = span.content;

        if (span.prev != null)
            prev = span.prev;
        else if (content != null)
        {
            node = content;
            content = content.next;
            Node.removeNode(node);
            Node.insertNodeBeforeElement(span, node);
            prev = node;
        }

        while (content != null)
        {
            node = content;
            content = content.next;
            Node.removeNode(node);
            Node.insertNodeAfterElement(prev, node);
            prev = node;
        }

        if (span.next == null)
            span.parent.last = prev;

        node = span.next;
        span.content = null;
        Node.discardElement(span);
        return node;
    }

    /* map non-breaking spaces to regular spaces */
    private void normalizeSpaces(Lexer lexer, Node node)
    {
        while (node != null)
        {
            if (node.content != null)
                normalizeSpaces(lexer, node.content);

            if (node.type == Node.TextNode)
            {
                int i;
                MutableInteger c = new MutableInteger();
                int p = node.start;

                for (i = node.start; i < node.end; ++i)
                {
                    c.value = (int)node.textarray[i];

                    /* look for UTF-8 multibyte character */
                    if (c.value > 0x7F)
                        i += PPrint.getUTF8(node.textarray, i, c);

                    if (c.value == 160)
                        c.value = ' ';

                    p = PPrint.putUTF8(node.textarray, p, c.value);
                }
            }

            node = node.next;
        }
    }

    /*
     This is a major clean up to strip out all the extra stuff you get
     when you save as web page from Word 2000. It doesn't yet know what
     to do with VML tags, but these will appear as errors unless you
     declare them as new tags, such as o:p which needs to be declared
     as inline.
    */
    public void cleanWord2000(Lexer lexer, Node node)
    {
        /* used to a list from a sequence of bulletted p's */
        Node list = null;

        while (node != null)
        {
            /* discard Word's style verbiage */
            if (node.tag == tt.tagStyle ||
                node.tag == tt.tagMeta ||
                node.type == Node.CommentTag)
            {
                node = Node.discardElement(node);
                continue;
            }

            /* strip out all span tags Word scatters so liberally! */
            if (node.tag == tt.tagSpan)
            {
                node = stripSpan(lexer, node);
                continue;
            }

            /* get rid of Word's xmlns attributes */
            if (node.tag == tt.tagHtml)
            {
                /* check that it's a Word 2000 document */
                if (node.getAttrByName("xmlns:o") == null)
                    return;
            }

            if (node.tag == tt.tagLink)
            {
                AttVal attr = node.getAttrByName("rel");

                if (attr != null && attr.value != null &&
                    attr.value.equals("File-List"))
                {
                    node = Node.discardElement(node);
                    continue;
                }
            }

            /* discard empty paragraphs */
            if (node.content == null && node.tag == tt.tagP)
            {
                node = Node.discardElement(node);
                continue;
            }

            if (node.tag == tt.tagP)
            {
                AttVal attr = node.getAttrByName("class");

                /* map sequence of <p class="MsoListBullet"> to <ul>...</ul> */
                if (attr != null && attr.value != null &&
                    attr.value.equals("MsoListBullet"))
                {
                    Node.coerceNode(lexer, node, tt.tagLi);

                    if (list == null || list.tag != tt.tagUl)
                    {
                        list = lexer.inferredTag("ul");
                        Node.insertNodeBeforeElement(node, list);
                    }

                    purgeAttributes(node);

                    if (node.content != null)
                        cleanWord2000(lexer, node.content);

                    /* remove node and append to contents of list */
                    Node.removeNode(node);
                    Node.insertNodeAtEnd(list, node);
                    node = list.next;
                }
                /* map sequence of <p class="Code"> to <pre>...</pre> */
                else if (attr != null && attr.value != null &&
                         attr.value.equals("Code"))
                {
                    Node br = lexer.newLineNode();
                    normalizeSpaces(lexer, node);

                    if (list == null || list.tag != tt.tagPre)
                    {
                        list = lexer.inferredTag("pre");
                        Node.insertNodeBeforeElement(node, list);
                    }

                    /* remove node and append to contents of list */
                    Node.removeNode(node);
                    Node.insertNodeAtEnd(list, node);
                    stripSpan(lexer, node);
                    Node.insertNodeAtEnd(list, br);
                    node = list.next;
                }
                else
                    list = null;
            }
            else
                list = null;

            /* strip out style and class attributes */
            if (node.type == Node.StartTag || node.type == Node.StartEndTag)
                purgeAttributes(node);

            if (node.content != null)
                cleanWord2000(lexer, node.content);

            node = node.next;
        }
    }

    public boolean isWord2000(Node root, TagTable tt)
    {
        Node html = root.findHTML(tt);

        return (html != null && html.getAttrByName("xmlns:o") != null);
    }
}