/****************************************************************************
**
** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (developer.feedback@nokia.com)
**
** This file is part of the HbWidgets module of the UI Extensions for Mobile.
**
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this file.
** Please review the following information to ensure the GNU Lesser General
** Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights.  These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at developer.feedback@nokia.com.
**
****************************************************************************/

#include "hbsmileyengine_p.h"
#include "hbsmileyengine_p_p.h"
#include <hbiconanimator.h>
#include <hbicon.h>
#include <QTextDocument>
#include <QFontMetricsF>
#include <QChar>
#include <QPainter>

HbSmileyTheme HbSmileyEnginePrivate::mDefaultTheme = HbSmileyTheme();

QSizeF HbIconTextObject::intrinsicSize(QTextDocument *doc, int posInDocument,
                                    const QTextFormat &format)
{
    Q_UNUSED(doc)
    Q_UNUSED(posInDocument)

    HbSmileyDataType smiley = qVariantValue<HbSmileyDataType>(format.property(HbSmileyData));
    HbIconAnimator *animator = smiley.animator;
    Q_ASSERT(animator);

    QFont f = static_cast<const QTextCharFormat&>(format).font();
    QFontMetricsF fm(f);

    // TODO: optimize this
    HbIcon icon = animator->icon();
    qreal iconHeight = fm.height() * smiley.scaleFactor;

    if(icon.height() != iconHeight) {
        icon.setHeight(iconHeight);
        animator->setIcon(icon);
    }
    // We are going to draw the smiley on the descent line not on the baseline
    // therefore the size needs to be adjusted accordingly.
    return (icon.size()-QSizeF(0,fm.descent()));
}

void HbIconTextObject::drawObject(QPainter *painter, const QRectF &rect,
                               QTextDocument *doc, int posInDocument,
                               const QTextFormat &format)
{
    Q_UNUSED(doc)
    Q_UNUSED(posInDocument)

    HbSmileyDataType smiley = qVariantValue<HbSmileyDataType>(format.property(HbSmileyData));

    QFont f = static_cast<const QTextCharFormat&>(format).font();
    QFontMetricsF fm(f);

    // Draw smiley on descent line
    QTransform matrix = painter->transform();
    painter->translate(0,fm.descent()-1);

    HbIconAnimator *animator = smiley.animator;
    animator->paint(painter,rect);
    painter->setTransform(matrix);
}

HbSmileyEnginePrivate::HbSmileyEnginePrivate()
    :mDocument(0),
     mEdited(true),
     mIconTextObject(new HbIconTextObject),
     mScaleFactor(1)
{
    q_ptr = 0;
}

HbSmileyEnginePrivate::~HbSmileyEnginePrivate()
{
    cleanUp();
    delete mIconTextObject;
}


void HbSmileyEnginePrivate::init()
{
    // Load default smiley theme
    if(mDefaultTheme.isNull()) {
        HbSmileyEnginePrivate::mDefaultTheme.load(":smileys/smileys_theme.sml");
        //
        //TODO: uncomment the lines below if animation definition file is provided for
        //      default smiley theme.
        //HbIconAnimationManager* m = HbIconAnimationManager::global();
        //m->addDefinitionFile(":smileys/smileys_animations.xml");
    }
    mSmileyTheme = HbSmileyEnginePrivate::mDefaultTheme;
}

void HbSmileyEnginePrivate::cleanUp()
{
    QList<QTextCursor*> cursors = mCursorToAnimator.keys();
    qDeleteAll(cursors);

    QList<HbIconAnimator*> animators = mAnimatorToCursors.keys();
    qDeleteAll(animators);

    mAnimatorToCursors.clear();
    mCursorToAnimator.clear();
    mSmileyAnimator.clear();
}

void HbSmileyEnginePrivate::setDocument(QTextDocument *doc)
{
    Q_Q(HbSmileyEngine);
    mDocument = doc;
    mDocument->documentLayout()->registerHandler(HbIconTextFormat, mIconTextObject);
    q->connect(mDocument, SIGNAL(contentsChange(int,int,int)), q, SLOT(_q_documentContentsChanged(int,int,int)));
    cleanUp();
}

void HbSmileyEnginePrivate::insertSmiley( QTextCursor cursor, const QString& name)
{
    QTextCharFormat hbiconFormat;
    QTextCursor *tmpCursor = new QTextCursor(cursor);
    hbiconFormat.setObjectType(HbIconTextFormat);

    HbSmileyDataType smiley;
    HbIconAnimator *animator = lookupAnimator(name);
    smiley.cursor = tmpCursor;
    smiley.animator = animator;
    smiley.scaleFactor = mScaleFactor;

    hbiconFormat.setProperty(HbIconTextObject::HbSmileyData, qVariantFromValue(smiley));

    mEdited = false;
    tmpCursor->insertText(QString(QChar::ObjectReplacementCharacter), hbiconFormat);
    mEdited = true;
    tmpCursor->setPosition(tmpCursor->position()-1);
    mAnimatorToCursors[animator] << tmpCursor;
    mCursorToAnimator[tmpCursor] = animator;
}

void HbSmileyEnginePrivate::insertSmileys( QTextCursor cursor, bool insertOne)
{
    QString regexpStr;
    foreach (QString pattern, mSmileyTheme.patterns()) {
        regexpStr += QRegExp::escape(pattern) + "|";
    }
    regexpStr.remove(regexpStr.count()-1, 1);

    QRegExp rx(regexpStr);
    cursor = mDocument->find(rx, cursor);
    while ( !cursor.isNull()){
        insertSmiley(cursor, mSmileyTheme.smiley(cursor.selectedText()));
        if (insertOne) {
            break;
        }
        cursor = mDocument->find(rx, cursor);
    }
}


HbIconAnimator* HbSmileyEnginePrivate::lookupAnimator(const QString& name)
{
    Q_Q(HbSmileyEngine);
    HbIconAnimator *animator = mSmileyAnimator.value(name);

    // Init icon if it doesn't already exits
    if (!animator) {
        HbIconAnimator *newAnimator = new HbIconAnimator();
        animator = newAnimator;
        HbIcon icon = HbIcon(name);
        icon.setFlags(HbIcon::NoAutoStartAnimation);
        animator->setIcon(icon);
        q->connect(animator,SIGNAL(animationProgressed()),q,SLOT(_q_animationProgressed()));
        animator->startAnimation();
        mSmileyAnimator[name] = animator;
    }

    return animator;
}


bool HbSmileyEnginePrivate::isCursorValid(QTextCursor* cursor) const
{
    bool ret = true;

    if (cursor) {
        if (mDocument->characterAt(cursor->position()) != QChar::ObjectReplacementCharacter) {
            ret = false;
         } else {
             QTextCursor tmpCursor(*cursor);
             tmpCursor.setPosition(tmpCursor.position()+1);
             QTextCharFormat format = tmpCursor.charFormat();

             HbSmileyDataType smiley = qVariantValue<HbSmileyDataType>(format.property(HbIconTextObject::HbSmileyData));
             if (cursor != smiley.cursor) {
                ret = false;
             }
         }
     } else {
        ret = false;
     }
    return ret;
}

void HbSmileyEnginePrivate::convertToText(QTextDocument *copyDoc) const
{
    QList<QTextCursor> cursors;
    // copy the cursors to copy document so that the positions get automatically updated
    foreach(QTextCursor *cursor, mCursorToAnimator.keys()) {
        if(isCursorValid(cursor)) {
            QTextCursor copyCursor(copyDoc);
            copyCursor.setPosition(cursor->position());
            cursors << copyCursor;
        }
    }

    foreach(QTextCursor copyCursor, cursors) {
        copyCursor.setPosition(copyCursor.position()+1, QTextCursor::KeepAnchor);
        QTextFormat format = copyCursor.charFormat();
        HbSmileyDataType smiley = qVariantValue<HbSmileyDataType>(format.property(HbIconTextObject::HbSmileyData));
        HbIconAnimator *animator = smiley.animator;
        Q_ASSERT(animator);

        QString pattern = mSmileyTheme.patterns(mSmileyAnimator.key(animator)).first();
        copyCursor.deleteChar();
        copyCursor.insertText(pattern);
    }
}

void HbSmileyEnginePrivate::_q_animationProgressed()
{
    Q_Q(HbSmileyEngine);
    HbIconAnimator *animator = qobject_cast<HbIconAnimator *>(q->sender());
    Q_ASSERT(animator);

    foreach(QTextCursor *cursor, mAnimatorToCursors.value(animator)) {
        QTextCursor tmpCursor(*cursor);
        tmpCursor.setPosition(tmpCursor.position()+1, QTextCursor::KeepAnchor);

        // update a bogus property, which will trigger a paint
        QTextCharFormat format;
        format.setProperty(HbIconTextObject::HbSmileyData+1, QString("Dummy"));
        mEdited = false;
        tmpCursor.mergeCharFormat(format);
        mEdited = true;
    }
}

void HbSmileyEnginePrivate::_q_documentContentsChanged(int position, int charsRemoved, int charsAdded)
{
    Q_UNUSED(position);
    Q_UNUSED(charsRemoved);
    Q_UNUSED(charsAdded);

    if(charsRemoved > 0 && mEdited) {
        foreach (QTextCursor* cursor, mCursorToAnimator.keys()) {          
            if (!isCursorValid(cursor)) {
                HbIconAnimator * animator = mCursorToAnimator.value(cursor);
                mCursorToAnimator.remove(cursor);
                QList<QTextCursor*> & cursorList = mAnimatorToCursors[animator];
                cursorList.removeFirst();
                if (!cursorList.count()) {
                    mAnimatorToCursors.remove(animator);
                    mSmileyAnimator.remove(mSmileyAnimator.key(animator));
                    animator->deleteLater();
                }
                delete cursor;
            }
        }
    }
}


HbSmileyEngine::HbSmileyEngine(QObject *parent)
    :QObject(parent),
    d_ptr(new HbSmileyEnginePrivate)

{
    Q_D(HbSmileyEngine);
    d->q_ptr = this;
    d->init();
}

HbSmileyEngine::HbSmileyEngine(HbSmileyEnginePrivate &dd, QObject *parent)
    :QObject(parent),
    d_ptr(&dd)
{
    Q_D(HbSmileyEngine);
    d->q_ptr = this;
    d->init();
}

HbSmileyEngine::~HbSmileyEngine()
{
    delete d_ptr;
}

void HbSmileyEngine::setDocument(QTextDocument *doc)
{
    Q_D(HbSmileyEngine);
    d->setDocument(doc);
}

void HbSmileyEngine::setTheme(const HbSmileyTheme& theme)
{
    Q_D(HbSmileyEngine);
    d->mSmileyTheme = theme;
}

HbSmileyTheme HbSmileyEngine::theme() const
{
    Q_D(const HbSmileyEngine);
    return d->mSmileyTheme;
}

HbSmileyTheme HbSmileyEngine::defaultTheme() const
{
    return HbSmileyEnginePrivate::mDefaultTheme;
}


QString HbSmileyEngine::toPlainText() const
{
    Q_D(const HbSmileyEngine);
    QTextDocument *copyDoc = d->mDocument->clone();
    d->convertToText(copyDoc);
    QString plainText = copyDoc->toPlainText();
    delete copyDoc;
    return plainText;
}

QString HbSmileyEngine::toHtml() const
{
    Q_D(const HbSmileyEngine);
    QTextDocument *copyDoc = d->mDocument->clone();
    d->convertToText(copyDoc);
    QString htmlString = copyDoc->toHtml();
    return htmlString;
}

void HbSmileyEngine::setSmileyScaleFactor(qreal scaleFactor)
{
    Q_D(HbSmileyEngine);
    if (d->mScaleFactor != scaleFactor) {
        // Note: it is assumed that the scale factor is not changed on the fly hence we do not need to redraw the smileyes.
        d->mScaleFactor = scaleFactor;
    }
}

void HbSmileyEngine::startAnimation()
{
    Q_D(HbSmileyEngine);
    foreach (HbIconAnimator *animator, d->mAnimatorToCursors.keys()) {
        animator->startAnimation();
    }
}

void HbSmileyEngine::stopAnimation()
{
    Q_D(HbSmileyEngine);
    foreach (HbIconAnimator *animator, d->mAnimatorToCursors.keys()) {
        animator->stopAnimation();
    }
}

void HbSmileyEngine::insertSmileys()
{
    Q_D(HbSmileyEngine);

    QTextCursor cursor(d->mDocument);
    d->insertSmileys(cursor);
}

void HbSmileyEngine::insertSmileys(const QTextCursor& cursor)
{
    Q_D(HbSmileyEngine);
    d->insertSmileys(cursor);
}

void HbSmileyEngine::insertSmiley(const QTextCursor& cursor)
{
    Q_D(HbSmileyEngine);
    d->insertSmileys(cursor,true);
}

#include "moc_hbsmileyengine_p.cpp"