/**

 * Copyright (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)

 * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 *

 */

#include "config.h"

#include "RenderCounter.h"

#include "CounterNode.h"

#include "Document.h"

#include "HTMLNames.h"

#include "HTMLOListElement.h"

#include "RenderListItem.h"

#include "RenderListMarker.h"

#include "RenderStyle.h"

namespace WebCore {

using namespace HTMLNames;

typedef HashMap<RefPtr<AtomicStringImpl>, CounterNode*> CounterMap;

typedef HashMap<const RenderObject*, CounterMap*> CounterMaps;

static CounterNode* counter(RenderObject*, const AtomicString& counterName, bool alwaysCreateCounter);

static CounterMaps& counterMaps()

{

    static CounterMaps staticCounterMaps;

    return staticCounterMaps;

}

static inline RenderObject* previousSiblingOrParent(RenderObject* object)

{

    if (RenderObject* sibling = object->previousSibling())

        return sibling;

    return object->parent();

}

static CounterNode* lastDescendant(CounterNode* node)

{

    CounterNode* last = node->lastChild();

    if (!last)

        return 0;

    while (CounterNode* lastChild = last->lastChild())

        last = lastChild;

    return last;

}

static CounterNode* previousInPreOrder(CounterNode* node)

{

    CounterNode* previous = node->previousSibling();

    if (!previous)

        return node->parent();

    while (CounterNode* lastChild = previous->lastChild())

        previous = lastChild;

    return previous;

}

static bool planCounter(RenderObject* object, const AtomicString& counterName, bool& isReset, int& value)

{

    ASSERT(object);

    // Real text nodes don't have their own style so they can't have counters.

    // We can't even look at their styles or we'll see extra resets and increments!

    if (object->isText() && !object->isBR())

        return false;

    RenderStyle* style = object->style();

    ASSERT(style);

    if (const CounterDirectiveMap* directivesMap = style->counterDirectives()) {

        CounterDirectives directives = directivesMap->get(counterName.impl());

        if (directives.m_reset) {

            value = directives.m_resetValue;

            if (directives.m_increment)

                value += directives.m_incrementValue;

            isReset = true;

            return true;

        }

        if (directives.m_increment) {

            value = directives.m_incrementValue;

            isReset = false;

            return true;

        }

    }

    if (counterName == "list-item") {

        if (object->isListItem()) {

            if (static_cast<RenderListItem*>(object)->hasExplicitValue()) {

                value = static_cast<RenderListItem*>(object)->explicitValue();

                isReset = true;

                return true;

            }

            value = 1;

            isReset = false;

            return true;

        }

        if (Node* e = object->element()) {

            if (e->hasTagName(olTag)) {

                value = static_cast<HTMLOListElement*>(e)->start();

                isReset = true;

                return true;

            }

            if (e->hasTagName(ulTag) || e->hasTagName(menuTag) || e->hasTagName(dirTag)) {

                value = 0;

                isReset = true;

                return true;

            }

        }

    }

    return false;

}

static bool findPlaceForCounter(RenderObject* object, const AtomicString& counterName,

    bool isReset, CounterNode*& parent, CounterNode*& previousSibling)

{

    // Find the appropriate previous sibling for insertion into the parent node

    // by searching in render tree order for a child of the counter.

    parent = 0;

    previousSibling = 0;

    RenderObject* resetCandidate = isReset ? object->parent() : previousSiblingOrParent(object);

    RenderObject* prevCounterCandidate = object;

    CounterNode* candidateCounter = 0;

    while ((prevCounterCandidate = prevCounterCandidate->previousInPreOrder())) {

        CounterNode* c = counter(prevCounterCandidate, counterName, false);

        if (prevCounterCandidate == resetCandidate) {

            if (!candidateCounter)

                candidateCounter = c;

            if (candidateCounter) {

                if (candidateCounter->isReset()) {

                    parent = candidateCounter;

                    previousSibling = 0;

                } else {

                    parent = candidateCounter->parent();

                    previousSibling = candidateCounter;

                }

                return true;

            }

            resetCandidate = previousSiblingOrParent(resetCandidate);

        } else if (c) {

            if (c->isReset())

                candidateCounter = 0;

            else if (!candidateCounter)

                candidateCounter = c;

        }

    }

    return false;

}

static CounterNode* counter(RenderObject* object, const AtomicString& counterName, bool alwaysCreateCounter)

{

    ASSERT(object);

    if (object->m_hasCounterNodeMap)

        if (CounterMap* nodeMap = counterMaps().get(object))

            if (CounterNode* node = nodeMap->get(counterName.impl()))

                return node;

    bool isReset = false;

    int value = 0;

    if (!planCounter(object, counterName, isReset, value) && !alwaysCreateCounter)

        return 0;

    CounterNode* newParent = 0;

    CounterNode* newPreviousSibling = 0;

    CounterNode* newNode;

    if (findPlaceForCounter(object, counterName, isReset, newParent, newPreviousSibling)) {

        newNode = new CounterNode(object, isReset, value);

        newParent->insertAfter(newNode, newPreviousSibling);

    } else {

        // Make a reset node for counters that aren't inside an existing reset node.

        newNode = new CounterNode(object, true, value);

    }

    CounterMap* nodeMap;

    if (object->m_hasCounterNodeMap)

        nodeMap = counterMaps().get(object);

    else {

        nodeMap = new CounterMap;

        counterMaps().set(object, nodeMap);

        object->m_hasCounterNodeMap = true;

    }

    nodeMap->set(counterName.impl(), newNode);

    return newNode;

}

RenderCounter::RenderCounter(Document* node, const CounterContent& counter)

    : RenderText(node, StringImpl::empty())

    , m_counter(counter)

    , m_counterNode(0)

{

}

const char* RenderCounter::renderName() const

{

    return "RenderCounter";

}

bool RenderCounter::isRenderCounter() const

{

    return true;

}

PassRefPtr<StringImpl> RenderCounter::originalText() const

{

    if (!parent())

        return 0;

    if (!m_counterNode)

        m_counterNode = counter(parent(), m_counter.identifier(), true);

    CounterNode* child = m_counterNode;

    int value = child->isReset() ? child->value() : child->countInParent();

    String text = listMarkerText(m_counter.listStyle(), value);

    if (!m_counter.separator().isNull()) {

        if (!child->isReset())

            child = child->parent();

        while (CounterNode* parent = child->parent()) {

            text = listMarkerText(m_counter.listStyle(), child->countInParent())

                + m_counter.separator() + text;

            child = parent;

        }

    }

    return text.impl();

}

void RenderCounter::dirtyLineBoxes(bool fullLayout, bool dummy)

{

    if (prefWidthsDirty())

        calcPrefWidths(0);

    RenderText::dirtyLineBoxes(fullLayout, dummy);

}

void RenderCounter::calcPrefWidths(int lead)

{

    setTextInternal(originalText());

    RenderText::calcPrefWidths(lead);

}

static void destroyCounterNodeChildren(AtomicStringImpl* identifier, CounterNode* node)

{

    CounterNode* previous;

    for (CounterNode* child = lastDescendant(node); child && child != node; child = previous) {

        previous = previousInPreOrder(child);

        child->parent()->removeChild(child);

        ASSERT(counterMaps().get(child->renderer())->get(identifier) == child);

        counterMaps().get(child->renderer())->remove(identifier);

        delete child;

    }

}

void RenderCounter::destroyCounterNodes(RenderObject* object)

{

    CounterMaps& maps = counterMaps();

    CounterMap* map = maps.get(object);

    if (!map)

        return;

    maps.remove(object);

    CounterMap::const_iterator end = map->end();

    for (CounterMap::const_iterator it = map->begin(); it != end; ++it) {

        CounterNode* node = it->second;

        destroyCounterNodeChildren(it->first.get(), node);

        if (CounterNode* parent = node->parent())

            parent->removeChild(node);

        delete node;

    }

    delete map;

}

} // namespace WebCore