/*

 * Copyright (C) 2000 Lars Knoll (knoll@kde.org)

 * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010 Apple Inc. All right reserved.

 * Copyright (C) 2010 Google 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.

 *

 */

#ifndef InlineIterator_h

#define InlineIterator_h

#include "BidiRun.h"

#include "RenderBlock.h"

#include "RenderText.h"

#include <wtf/AlwaysInline.h>

#include <wtf/StdLibExtras.h>

namespace WebCore {

class InlineIterator {

public:

    InlineIterator()

        : block(0)

        , obj(0)

        , pos(0)

        , nextBreakablePosition(-1)

    {

    }

    InlineIterator(RenderBlock* b, RenderObject* o, unsigned p)

        : block(b)

        , obj(o)

        , pos(p)

        , nextBreakablePosition(-1)

    {

    }

    void increment(InlineBidiResolver* resolver = 0);

    bool atEnd() const;

    UChar current() const;

    WTF::Unicode::Direction direction() const;

    RenderBlock* block;

    RenderObject* obj;

    unsigned pos;

    int nextBreakablePosition;

};

inline bool operator==(const InlineIterator& it1, const InlineIterator& it2)

{

    return it1.pos == it2.pos && it1.obj == it2.obj;

}

inline bool operator!=(const InlineIterator& it1, const InlineIterator& it2)

{

    return it1.pos != it2.pos || it1.obj != it2.obj;

}

static inline RenderObject* bidiNext(RenderBlock* block, RenderObject* current, InlineBidiResolver* resolver = 0, bool skipInlines = true, bool* endOfInlinePtr = 0)

{

    RenderObject* next = 0;

    bool oldEndOfInline = endOfInlinePtr ? *endOfInlinePtr : false;

    bool endOfInline = false;

    while (current) {

        next = 0;

        if (!oldEndOfInline && !current->isFloating() && !current->isReplaced() && !current->isPositioned() && !current->isText()) {

            next = current->firstChild();

            if (next && resolver && next->isRenderInline()) {

                EUnicodeBidi ub = next->style()->unicodeBidi();

                if (ub != UBNormal) {

                    TextDirection dir = next->style()->direction();

                    WTF::Unicode::Direction d = (ub == Embed

                        ? (dir == RTL ? WTF::Unicode::RightToLeftEmbedding : WTF::Unicode::LeftToRightEmbedding)

                        : (dir == RTL ? WTF::Unicode::RightToLeftOverride : WTF::Unicode::LeftToRightOverride));

                    resolver->embed(d);

                }

            }

        }

        if (!next) {

            if (!skipInlines && !oldEndOfInline && current->isRenderInline()) {

                next = current;

                endOfInline = true;

                break;

            }

            while (current && current != block) {

                if (resolver && current->isRenderInline() && current->style()->unicodeBidi() != UBNormal)

                    resolver->embed(WTF::Unicode::PopDirectionalFormat);

                next = current->nextSibling();

                if (next) {

                    if (resolver && next->isRenderInline()) {

                        EUnicodeBidi ub = next->style()->unicodeBidi();

                        if (ub != UBNormal) {

                            TextDirection dir = next->style()->direction();

                            WTF::Unicode::Direction d = (ub == Embed

                                ? (dir == RTL ? WTF::Unicode::RightToLeftEmbedding: WTF::Unicode::LeftToRightEmbedding)

                                : (dir == RTL ? WTF::Unicode::RightToLeftOverride : WTF::Unicode::LeftToRightOverride));

                            resolver->embed(d);

                        }

                    }

                    break;

                }

                current = current->parent();

                if (!skipInlines && current && current != block && current->isRenderInline()) {

                    next = current;

                    endOfInline = true;

                    break;

                }

            }

        }

        if (!next)

            break;

        if (next->isText() || next->isFloating() || next->isReplaced() || next->isPositioned()

            || ((!skipInlines || !next->firstChild()) // Always return EMPTY inlines.

                && next->isRenderInline()))

            break;

        current = next;

    }

    if (endOfInlinePtr)

        *endOfInlinePtr = endOfInline;

    return next;

}

static inline RenderObject* bidiFirst(RenderBlock* block, InlineBidiResolver* resolver, bool skipInlines = true)

{

    if (!block->firstChild())

        return 0;

    RenderObject* o = block->firstChild();

    if (o->isRenderInline()) {

        if (resolver) {

            EUnicodeBidi ub = o->style()->unicodeBidi();

            if (ub != UBNormal) {

                TextDirection dir = o->style()->direction();

                WTF::Unicode::Direction d = (ub == Embed

                    ? (dir == RTL ? WTF::Unicode::RightToLeftEmbedding : WTF::Unicode::LeftToRightEmbedding)

                    : (dir == RTL ? WTF::Unicode::RightToLeftOverride : WTF::Unicode::LeftToRightOverride));

                resolver->embed(d);

            }

        }

        if (skipInlines && o->firstChild())

            o = bidiNext(block, o, resolver, skipInlines);

        else {

            // Never skip empty inlines.

            if (resolver)

                resolver->commitExplicitEmbedding();

            return o; 

        }

    }

    if (o && !o->isText() && !o->isReplaced() && !o->isFloating() && !o->isPositioned())

        o = bidiNext(block, o, resolver, skipInlines);

    if (resolver)

        resolver->commitExplicitEmbedding();

    return o;

}

inline void InlineIterator::increment(InlineBidiResolver* resolver)

{

    if (!obj)

        return;

    if (obj->isText()) {

        pos++;

        if (pos >= toRenderText(obj)->textLength()) {

            obj = bidiNext(block, obj, resolver);

            pos = 0;

            nextBreakablePosition = -1;

        }

    } else {

        obj = bidiNext(block, obj, resolver);

        pos = 0;

        nextBreakablePosition = -1;

    }

}

inline bool InlineIterator::atEnd() const

{

    return !obj;

}

inline UChar InlineIterator::current() const

{

    if (!obj || !obj->isText())

        return 0;

    RenderText* text = toRenderText(obj);

    if (pos >= text->textLength())

        return 0;

    return text->characters()[pos];

}

ALWAYS_INLINE WTF::Unicode::Direction InlineIterator::direction() const

{

    if (UChar c = current())

        return WTF::Unicode::direction(c);

    if (obj && obj->isListMarker())

        return obj->style()->direction() == LTR ? WTF::Unicode::LeftToRight : WTF::Unicode::RightToLeft;

    return WTF::Unicode::OtherNeutral;

}

template<>

inline void InlineBidiResolver::increment()

{

    current.increment(this);

}

template <>

inline void InlineBidiResolver::appendRun()

{

    if (!emptyRun && !eor.atEnd()) {

        int start = sor.pos;

        RenderObject *obj = sor.obj;

        while (obj && obj != eor.obj && obj != endOfLine.obj) {

            RenderBlock::appendRunsForObject(start, obj->length(), obj, *this);        

            start = 0;

            obj = bidiNext(sor.block, obj);

        }

        if (obj) {

            unsigned pos = obj == eor.obj ? eor.pos : UINT_MAX;

            if (obj == endOfLine.obj && endOfLine.pos <= pos) {

                reachedEndOfLine = true;

                pos = endOfLine.pos;

            }

            // It's OK to add runs for zero-length RenderObjects, just don't make the run larger than it should be

            int end = obj->length() ? pos+1 : 0;

            RenderBlock::appendRunsForObject(start, end, obj, *this);

        }

        eor.increment();

        sor = eor;

    }

    m_direction = WTF::Unicode::OtherNeutral;

    m_status.eor = WTF::Unicode::OtherNeutral;

}

}

#endif // InlineIterator_h