/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, version 2.1 of the License.

*

* This program 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 Lesser General Public License for more details.

*

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

* along with this program.  If not,

* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

*

* Description:

*

*/

#include <QDebug>

#include <QImage>

#include <QPainter>

#include <QResizeEvent>

#include <QTimeLine>

#include <QGraphicsSceneResizeEvent>

#include <QGraphicsSceneMouseEvent>

#include <QGraphicsSceneMoveEvent>

#include <QGraphicsDropShadowEffect>

#include "linearflowsnippet.h"

#define SAFE_DELETE(p) if (p) delete p;

#define SNIPPET_AUTOHIDE_TIMEOUT 5000 //5secs

#define CALL_ON_PREV_PREV_FILM_STRIP(func) if (d->m_centerIndex - 2 >= 0) d->m_films[d->m_centerIndex - 2]->func; else if (d->m_centerIndex == 1) d->m_films[d->m_films.size() - 1]->func; else d->m_films[d->m_films.size() - 2]->func;

#define CALL_ON_CENTER_FILM_STRIP(func) if (d->m_centerIndex >= 0 && d->m_centerIndex < d->m_films.size()) d->m_films[d->m_centerIndex]->func; else if (d->m_centerIndex < 0) d->m_films[d->m_films.size() + d->m_centerIndex]->func; else d->m_films[(d->m_centerIndex)%d->m_films.size()]->func;

#define CALL_ON_PREV_PREV_PREV_FILM_STRIP(func) if (d->m_centerIndex - 3 >= 0) d->m_films[d->m_centerIndex - 3]->func; else if (d->m_centerIndex == 1) d->m_films[d->m_films.size() - 2]->func; else if (d->m_centerIndex == 2) d->m_films[d->m_films.size() - 1]->func; else d->m_films[d->m_films.size() - 3]->func;

#define CALL_ON_NEXT_NEXT_NEXT_FILM_STRIP(func) if (d->m_centerIndex + 3 < d->m_films.size()) d->m_films[d->m_centerIndex + 3]->func; else d->m_films[(d->m_centerIndex + 3)%d->m_films.size()]->func;

#define CALL_ON_NEXT_NEXT_FILM_STRIP(func) if (d->m_centerIndex + 2 < d->m_films.size()) d->m_films[d->m_centerIndex + 2]->func; else d->m_films[(d->m_centerIndex + 2)%d->m_films.size()]->func;

#define CALL_ON_PREV_FILM_STRIP(func) if (d->m_centerIndex - 1 >= 0) d->m_films[d->m_centerIndex - 1]->func; else d->m_films[d->m_films.size() - 1]->func;

#define CALL_ON_NEXT_FILM_STRIP(func) if (d->m_centerIndex + 1 < d->m_films.size()) d->m_films[d->m_centerIndex + 1]->func; else d->m_films[(d->m_centerIndex + 1)%d->m_films.size()]->func;

#define INVALID_INDEX -1

#define L_CENTER_WIDTH_P_C 0.27

#define L_CENTER_HEIGHT_P_C 0.70

#define L_SIDE_WIDTH_P_C 0.27

#define L_SIDE_HEIGHT_P_C 0.70

#define L_CENTER_TOP_SPACE_P_C 0.15

#define L_SIDE_TOP_SPACE_P_C 0.15

#define L_SPACE_P_C 0.05

#define SPACE_P_C 0.11

#define CLOSE_ICON_ADJUST_SIZE 5

#define TITLE_SPACE 10

#define FRAME_WIDTH 4

#define ANIMATION_DURATION 300

#define ANIMATION_MAX_FRAME 20.0

#define NEW_FILM_TITLE ""

#define WIDTH 360

#define TITLE_HEIGHT 0.15

#define FILM_HEIGHT 0.85

#define P_MAX_SLIDE 3

#define L_MAX_SLIDE 5

#define MAX_FLICK_SPEED 500

#define THRESHOLD_FLICK_SPEED 400

#define THRESHOLD_FLICK_TIME 75

namespace GVA {

// movies (animation) name

const QString BreakinLeft   = "bil";//"breakin - left";

const QString BreakinRight  = "bir";//"breakin - right";

const QString BreakoutLeft  = "bol";//"breakout - left";

const QString BreakoutRight = "bor";//"breakout - right";

const QString BreakinLeftLeft = "bill";//"breakin - leftleft"

const QString BreakinRightRight = "birr";//"breakin - rightright"

const QString BreakoutLeftLeft = "boll";//"breakout - leftleft"

const QString BreakoutRightRight = "borr";//"breakout rightright"

const QString RightToCenter = "rc";//"right - center";

const QString LeftToCenter  = "lc";//"left - center";

const QString CenterToRight = "cr";//"center - right";

const QString CenterToLeft  = "cl";//"center - left";

const QString LeftLeftToLeft = "lltl"; //"leftLft - left"

const QString LeftToLeftLeft = "ltll";//left - leftleft"

const QString RightToRightRight = "rtrr";//"right - rightright"

const QString RightRightToRight = "rrtr";//"rightright - right"

const QString FadeOut       = "fo";//"fadeout";

const QString ZoomIn        = "zi";//"zoomin";

const QString ZoomOut       = "zo";//"zoomto";

// -------------------------------------------------------

// Help functions

//static QImage* createFilmstrip(const QImage& img, QSize

// -------------------------------------------------------

// Help classes

class FilmstripMovieFactory;

class FilmstripMovie

{

friend class FilmstripMovieFactory;

public:

enum MovieType

{

FADE_IN,

FADE_OUT,

TRANSLATE

};

public:

    FilmstripMovie(const QString& name) { m_name = name; m_movieType = TRANSLATE;}

    ~FilmstripMovie() {m_movieClips.clear();}

    QRectF& movieClip(int frame);

public:

    MovieType m_movieType;

private:

    QString m_name;

    QList<QRectF> m_movieClips;

};

class FilmstripMovieFactory

{

public:

    FilmstripMovieFactory(FilmstripFlowPrivate* filmstripFlowData = NULL): m_filmstripFlowData(filmstripFlowData) {}

    ~FilmstripMovieFactory();

    FilmstripMovie* createMovie(const QString& name);

    void updateAllMovie();

    void setFilmstripFlowData(FilmstripFlowPrivate* filmstripFlowData) { m_filmstripFlowData = filmstripFlowData; }

protected:

    void addRectByFrame(FilmstripMovie* movie, QRectF& startRect, QRectF& endRect, qreal x1, qreal y1, qreal x2, qreal y2, bool debug = false);

    void createRightOutMovie(FilmstripMovie* movie);

    void createRightInMovie(FilmstripMovie* movie);

    void createLeftInMovie(FilmstripMovie* movie);

    void createLeftOutMovie(FilmstripMovie* movie);

    void createRightToCenterMovie(FilmstripMovie* movie);

    void createLeftToCenterMovie(FilmstripMovie* movie);

    void createCenterToLeftMovie(FilmstripMovie* movie);

    void createCenterToRightMovie(FilmstripMovie* movie);

    void createFadeOutMovie(FilmstripMovie* movie);

    void createZoomInMovie(FilmstripMovie* movie);

    void createZoomOutMovie(FilmstripMovie* movie);

    void createLeftLeftInMovie(FilmstripMovie* movie);

    void createRightRightInMovie(FilmstripMovie* movie);

    void createLeftLeftOutMovie(FilmstripMovie* movie);

    void createRightRightOutMovie(FilmstripMovie* movie);

    void createLeftLeftToLeftMovie(FilmstripMovie* movie);

    void createLeftToLeftLeftMovie(FilmstripMovie* movie);

    void createRightToRightRightMovie(FilmstripMovie* movie);

    void createRightRightToRightMovie(FilmstripMovie* movie);

private:

    FilmstripFlowPrivate* m_filmstripFlowData;

    QHash<QString, FilmstripMovie*> m_moviesCache;

};

class Filmstrip

{

public:

    Filmstrip(const QImage& img, FilmstripFlowPrivate* filmstripFlowData): m_img(img), m_frozen(false), m_movieFrame(0), m_movie(NULL), m_filmstripFlowData(filmstripFlowData) {}

    ~Filmstrip() {}

    void paint(QPainter* painter);

    void paintName(QPainter* painter);

    void freeze() {m_frozen = true;}

    void updateMovie(FilmstripMovie* movie) {m_movie = movie; m_movieFrame = 0; m_frozen = false;}

    void updateMovieFrame(int frame) { if (!m_frozen) m_movieFrame = frame;}

    void setName(const QString& name) {m_name = name;}

    QImage& image() {return m_img;}

    QString& name() {return m_name;}

private:

    void createEmptyImage();

public:

    QImage m_img;

    bool m_frozen;

    int m_movieFrame;

    QString m_name;

    FilmstripMovie* m_movie;

    FilmstripFlowPrivate* m_filmstripFlowData;

};

class FilmstripFlowPrivate

{

    ~FilmstripFlowPrivate() {

        for (int i = 0; i < m_films.size(); i++)

            SAFE_DELETE(m_films[i]);

        m_films.clear();

        SAFE_DELETE(m_buffer);

        SAFE_DELETE(m_titleBuffer);

        SAFE_DELETE(m_closeIcon);

    }

    void clear() {

        m_centerIndex = INVALID_INDEX;

        for (int i = 0; i < m_films.size(); i++)

            SAFE_DELETE(m_films[i]);

        m_films.clear();

    }

public:

    QRgb m_bgColor;

    QImage* m_buffer;

    QImage *m_titleBuffer;

    QImage* m_closeIcon;

    QList<Filmstrip*> m_films;

    QSize m_centerWindowSize;

    QSize m_sideWindowSize;

    QSize m_widgetSize;

    qreal m_centerTopSpace;

    qreal m_sideTopSpace;

    qreal m_space;

    QTimeLine m_movieTimer;

    FilmstripMovieFactory m_movieFactory;

    QPoint m_closeIconPos;

    QPoint m_lastMoveEventPos;

    int m_incIndex;

    int m_centerIndex;

};

// -------------------------------------------------------

// Filmstrip

void Filmstrip::createEmptyImage()

{

    QRectF target = m_movie->movieClip(0);

    int w = target.width();

    int h = target.height();

    m_name = NEW_FILM_TITLE;

    m_img = QImage(w, h, QImage::Format_RGB32);

    QPainter painter(&m_img);

    painter.fillRect(0, 0, w, h, Qt::white);

    painter.end();

}

void Filmstrip::paint(QPainter* painter)

{

    Q_ASSERT(painter);

    if (!m_movie)

        return;

    QRectF target;

    bool needFade = (m_movie->m_movieType == FilmstripMovie::FADE_OUT);

    if (needFade) // FIXME: no fade out support now

        target = m_movie->movieClip(0);

    else

        target = m_movie->movieClip(m_movieFrame);

    if (target.right() > 0 || target.left() < m_filmstripFlowData->m_widgetSize.width()) {

        if (needFade)

            painter->setOpacity((ANIMATION_MAX_FRAME - m_movieFrame) / ANIMATION_MAX_FRAME);

        painter->fillRect(target.adjusted(-FRAME_WIDTH,-FRAME_WIDTH,FRAME_WIDTH,FRAME_WIDTH), QColor(Qt::gray));

        if (!m_img.isNull())

            painter->drawImage(target, m_img);

        else {

            painter->save();

            painter->setPen(QColor(Qt::black));

            painter->setFont(QFont("Arial", 4));

            painter->drawText(target, Qt::AlignVCenter,m_name);

            painter->restore();

        }

        if (needFade)

            painter->setOpacity(1); // restore opacity

    }

}

void Filmstrip::paintName(QPainter* painter)

{

    Q_ASSERT(painter);

    if (!m_name.isEmpty()) {

        QPoint startPoint;

        QString name = m_name;

        QFontMetrics fm = painter->fontMetrics();

        int pixelWidth = fm.width(name);

        int filmstripWidth = m_filmstripFlowData->m_centerWindowSize.width();

        if (pixelWidth > filmstripWidth) {

            qreal letterWidth = pixelWidth / (qreal)name.size();

            name = name.leftJustified(filmstripWidth / letterWidth - 3, '.', true) + "...";

            startPoint = QPoint((m_filmstripFlowData->m_widgetSize.width() - filmstripWidth) /2, m_filmstripFlowData->m_centerTopSpace - TITLE_SPACE);

        }

        else

            startPoint = QPoint((m_filmstripFlowData->m_widgetSize.width() - pixelWidth) /2, m_filmstripFlowData->m_centerTopSpace - TITLE_SPACE);

        painter->save();

        painter->setPen(QColor(Qt::black));

        painter->drawText(startPoint, name);

        painter->restore();

    }

}

// -------------------------------------------------------

// FilmstripMovie

QRectF& FilmstripMovie::movieClip(int frame)

{

    Q_ASSERT(frame >= 0 && frame < m_movieClips.size());

    return m_movieClips[frame];

}

// -------------------------------------------------------

// FilmstripMovieFactory

FilmstripMovieFactory::~FilmstripMovieFactory()

{

    QHashIterator<QString, FilmstripMovie*> i(m_moviesCache);

    while (i.hasNext()) {

        i.next();

        delete i.value();

    }

    m_moviesCache.clear();

}

FilmstripMovie* FilmstripMovieFactory::createMovie(const QString& name)

{

    FilmstripMovie* movie = NULL;

    QHash<QString, FilmstripMovie*>::const_iterator i = m_moviesCache.find(name);

    if (i == m_moviesCache.end()) {

        //qDebug() << "create a new movie: " << name;

        movie = new FilmstripMovie(name);

        if (name == BreakoutRight)

            createRightOutMovie(movie);

        else if (name == BreakoutLeft)

            createLeftOutMovie(movie);

        else if (name == BreakinLeft)

            createLeftInMovie(movie);

        else if (name == BreakinRight)

            createRightInMovie(movie);

        else if (name == CenterToRight)

            createCenterToRightMovie(movie);

        else if (name == CenterToLeft)

            createCenterToLeftMovie(movie);

        else if (name == RightToCenter)

            createRightToCenterMovie(movie);

        else if (name == LeftToCenter)

            createLeftToCenterMovie(movie);

        else if (name == FadeOut)

            createFadeOutMovie(movie);

        else if (name == ZoomIn)

            createZoomInMovie(movie);

        else if (name == ZoomOut)

            createZoomOutMovie(movie);

        else if (name == BreakinLeftLeft)

            createLeftLeftInMovie(movie);

        else if (name == BreakinRightRight)

            createRightRightInMovie(movie);

        else if (name == BreakoutLeftLeft)

            createLeftLeftOutMovie(movie);

        else if (name == BreakoutRightRight)

            createRightRightOutMovie(movie);

        else if (name == LeftLeftToLeft)

            createLeftLeftToLeftMovie(movie);

        else if (name == LeftToLeftLeft)

            createLeftToLeftLeftMovie(movie);

        else if (name == RightToRightRight)

            createRightToRightRightMovie(movie);

        else if (name == RightRightToRight)

            createRightRightToRightMovie(movie);

        m_moviesCache[name] = movie;

    } else {

        movie =  m_moviesCache.value(name);

    }

    return movie;

}

void FilmstripMovieFactory::createLeftLeftInMovie(FilmstripMovie* movie)

{

    movie->m_movieClips.clear();

    int cw = m_filmstripFlowData->m_centerWindowSize.width();

    int sw = m_filmstripFlowData->m_sideWindowSize.width();

    int sh = m_filmstripFlowData->m_sideWindowSize.height();

    int w = m_filmstripFlowData->m_widgetSize.width();

    qreal cx = ((w - 4 * m_filmstripFlowData->m_space) - cw) / 2.0 - sw + m_filmstripFlowData->m_space;

    qreal sx = ((w - 4 * m_filmstripFlowData->m_space) - cw) / 2.0 - 2 * sw;

    qreal sy = m_filmstripFlowData->m_sideTopSpace;

    qreal stepx = (cx - sx) / ANIMATION_MAX_FRAME;

    QRectF startRect = QRectF( 2 *  sx - cx , sy, sw, sh);

    QRectF endRect = QRectF(sx, sy, sw, sh);

    addRectByFrame(movie, startRect, endRect, stepx, 0, stepx, 0);

}

void FilmstripMovieFactory::createRightRightInMovie(FilmstripMovie* movie)

{

    movie->m_movieClips.clear();

    int cw = m_filmstripFlowData->m_centerWindowSize.width();

    int sw = m_filmstripFlowData->m_sideWindowSize.width();

    int sh = m_filmstripFlowData->m_sideWindowSize.height();

    int w = m_filmstripFlowData->m_widgetSize.width();

    qreal cx = (w + 4 * m_filmstripFlowData->m_space + cw) / 2.0 - m_filmstripFlowData->m_space;

    qreal sx = ((w + 4 * m_filmstripFlowData->m_space + cw) / 2.0) + sw ;

    qreal sy = m_filmstripFlowData->m_sideTopSpace;

    qreal stepx = (cx - sx) / ANIMATION_MAX_FRAME;

    QRectF startRect = QRectF(2 * sx - cx, sy, sw, sh);

    QRectF endRect = QRectF(sx , sy, sw, sh);

    addRectByFrame(movie, startRect, endRect, stepx, 0, stepx, 0);

}

void FilmstripMovieFactory::createLeftLeftOutMovie(FilmstripMovie* movie)

{

    movie->m_movieClips.clear();

    int cw = m_filmstripFlowData->m_centerWindowSize.width();

    int sw = m_filmstripFlowData->m_sideWindowSize.width();

    int sh = m_filmstripFlowData->m_sideWindowSize.height();

    int w = m_filmstripFlowData->m_widgetSize.width();

    qreal cx = ((w - 4 * m_filmstripFlowData->m_space) - cw) / 2.0 - sw + m_filmstripFlowData->m_space;

    qreal sx = (((w - 4 * m_filmstripFlowData->m_space) - cw) / 2.0) - (2 *sw);

    qreal sy = m_filmstripFlowData->m_sideTopSpace;

    qreal stepx = (sx -cx) / ANIMATION_MAX_FRAME;

    QRectF startRect = QRectF(sx, sy, sw, sh);

    QRectF endRect = QRectF(2 * sx - cx , sy, sw, sh);

    addRectByFrame(movie, startRect, endRect, stepx, 0, stepx, 0);

}

void FilmstripMovieFactory::createRightRightOutMovie(FilmstripMovie* movie)

{

    movie->m_movieClips.clear();

    int cw = m_filmstripFlowData->m_centerWindowSize.width();

    int sw = m_filmstripFlowData->m_sideWindowSize.width();

    int sh = m_filmstripFlowData->m_sideWindowSize.height();

    int w = m_filmstripFlowData->m_widgetSize.width();

    qreal cx = (w + 4 * m_filmstripFlowData->m_space + cw) / 2.0 - m_filmstripFlowData->m_space;

    qreal sx = ((w + 4 * m_filmstripFlowData->m_space + cw) / 2.0) + sw ;

    qreal sy = m_filmstripFlowData->m_sideTopSpace;

    qreal stepx = (sx - cx) / ANIMATION_MAX_FRAME;

    QRectF startRect = QRectF(sx, sy, sw, sh);

    QRectF endRect = QRectF(2 * sx - cx, sy, sw, sh);

    addRectByFrame(movie, startRect, endRect, stepx, 0, stepx, 0);

}

void FilmstripMovieFactory::createLeftLeftToLeftMovie(FilmstripMovie* movie)

{

    movie->m_movieClips.clear();

    int cw = m_filmstripFlowData->m_centerWindowSize.width();

    int ch = m_filmstripFlowData->m_centerWindowSize.height();

    int sw = m_filmstripFlowData->m_sideWindowSize.width();

    int sh = m_filmstripFlowData->m_sideWindowSize.height();

    int w = m_filmstripFlowData->m_widgetSize.width();

    qreal step = ANIMATION_MAX_FRAME;

    qreal cx = ((w - 4 * m_filmstripFlowData->m_space) - cw) / 2.0 - sw + m_filmstripFlowData->m_space;

    qreal cy = m_filmstripFlowData->m_centerTopSpace;

    qreal sx = (((w - 4 * m_filmstripFlowData->m_space) - cw) / 2.0) - (2 *sw);

    qreal sy = m_filmstripFlowData->m_sideTopSpace;

    qreal stepx = (cx - sx) / step;

    qreal stepy = (cy - sy) / step;

    qreal stepx2 = stepx + (cw - sw) / step;

    qreal stepy2 = stepy + (ch - sh) / step;

    QRectF startRect = QRectF(sx, sy, sw, sh);

    QRectF endRect = QRectF(cx, cy, cw, ch);

    addRectByFrame(movie, startRect, endRect, stepx, stepy, stepx2, stepy2);

}

void FilmstripMovieFactory::createLeftToLeftLeftMovie(FilmstripMovie* movie)

{

    movie->m_movieClips.clear();

    int cw = m_filmstripFlowData->m_centerWindowSize.width();

    int ch = m_filmstripFlowData->m_centerWindowSize.height();

    int sw = m_filmstripFlowData->m_sideWindowSize.width();

    int sh = m_filmstripFlowData->m_sideWindowSize.height();

    int w = m_filmstripFlowData->m_widgetSize.width();

    qreal step = ANIMATION_MAX_FRAME;

    qreal cx = ((w - 4 * m_filmstripFlowData->m_space) - cw) / 2.0 - sw + m_filmstripFlowData->m_space;

    qreal cy = m_filmstripFlowData->m_centerTopSpace;

    qreal sx = (((w - 4 * m_filmstripFlowData->m_space) - cw) / 2.0) - (2 *sw);

    qreal sy = m_filmstripFlowData->m_sideTopSpace;

    qreal stepx = (sx - cx) / step;

    qreal stepy = (sy - cy) / step;

    qreal stepx2 = stepx + (sw - cw) / step;

    qreal stepy2 = stepy + (sh - ch) / step;

    QRectF startRect = QRectF(cx, cy, cw, ch);

    QRectF endRect = QRectF(sx, sy, sw, sh);

    addRectByFrame(movie, startRect, endRect, stepx, stepy, stepx2, stepy2);

}