/*

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

* All rights reserved.

*

*

*

*/

#include <QDebug>

#include <QImage>

#include <QPainter>

#include <QResizeEvent>

#include <QTimeLine>

#include <QGraphicsSceneResizeEvent>

#include <QGraphicsSceneMouseEvent>

#include <QGraphicsSceneMoveEvent>

#include "FilmstripFlow.h"

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

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

#define CALL_ON_PREV_FILM_STRIP(func) if (d->m_centerIndex - 1 >= 0) d->m_films[d->m_centerIndex - 1]->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;

#define CALL_ON_NEXT_FILM_STRIP(func) if (d->m_centerIndex + 1 < d->m_films.size()) d->m_films[d->m_centerIndex + 1]->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;

#define INVALID_INDEX -1

#define L_CENTER_WIDTH_P_C 0.55

#define L_CENTER_HEIGHT_P_C 0.70

#define L_SIDE_WIDTH_P_C 0.40

#define L_SIDE_HEIGHT_P_C 0.62

//#define P_CENTER_WIDTH_P_C 0.50

#define P_CENTER_WIDTH_P_C 0.55

#define P_CENTER_HEIGHT_P_C 0.70

#define P_SIDE_WIDTH_P_C 0.40

#define P_SIDE_HEIGHT_P_C 0.55

//#define L_CENTER_TOP_SPACE_P_C 0.2

#define L_CENTER_TOP_SPACE_P_C 0.28

//#define L_SIDE_TOP_SPACE_P_C 0.24

#define L_SIDE_TOP_SPACE_P_C 0.36

#define L_SPACE_P_C 0.12

//#define P_CENTER_TOP_SPACE_P_C 0.20

#define P_CENTER_TOP_SPACE_P_C 0.22

//#define P_SIDE_TOP_SPACE_P_C 0.30

#define P_SIDE_TOP_SPACE_P_C 0.30

#define P_SPACE_P_C 0.12

#define SPACE_P_C 0.12

#define CLOSE_ICON_ADJUST_SIZE 20

//#define TITLE_SPACE 18

#define TITLE_SPACE 25

#define FRAME_WIDTH 4

#define ANIMATION_DURATION 400

#define ANIMATION_MAX_FRAME 15.0

#define NEW_FILM_TITLE "New Window"

namespace WRT {

// 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 RightToCenter = "rc";//"right - center";

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

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

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

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);

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

{

public:

    FilmstripFlowPrivate(): m_bgColor(QColor(Qt::white).rgb()), m_buffer(NULL), m_closeIcon(NULL), m_centerTopSpace(0), m_sideTopSpace(0), m_space(0), m_incIndex(0), m_centerIndex(INVALID_INDEX) {}

    ~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_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_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_img = QImage(w, h, QImage::Format_RGB32);

    QPainter painter(&m_img);

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

    /*QPoint p1(w*4/10, 0);

    QPoint p2(w*6/10, h);

    QLinearGradient linearGrad(p1, p2);

    linearGrad.setColorAt(0, Qt::black);

    linearGrad.setColorAt(1, Qt::white);

    painter.setBrush(linearGrad);

    painter.fillRect(0, 0, w, h, QBrush(linearGrad));

    */

    //painter.setPen(QPen(QColor(64,64,64), 4));

    //painter.setBrush(QBrush());

    //painter.drawRect(2, 2, w-3, h-3);

    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);

    //qDebug() << "m_movieFrame:" << m_movieFrame << " -- " << target;

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

        //painter->setPen(QPen(QColor(Qt::gray), 4));

        //painter->setBrush(QBrush());

        //painter->drawRect(target.x() - 2, target.y() - 2, target.width() + 5, target.height() + 5);

        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())

            createEmptyImage();

        painter->drawImage(target, m_img);

        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);

        m_moviesCache[name] = movie;

    } else {

        movie =  m_moviesCache.value(name);

    }

    return movie;

}

void FilmstripMovieFactory::addRectByFrame(FilmstripMovie* movie, QRectF& startRect, QRectF& endRect, qreal x1, qreal y1, qreal x2, qreal y2, bool debug)

{

    movie->m_movieClips.append(startRect);

    if (debug)

        qDebug() << "0:" << startRect;

    for (int i = 1; i < ANIMATION_MAX_FRAME; i++) {

        if (debug)

            qDebug() << i << ":" << movie->m_movieClips[i - 1].adjusted(x1, y1, x2, y2);

        movie->m_movieClips.append(movie->m_movieClips[i - 1].adjusted(x1, y1, x2, y2));

    }

    movie->m_movieClips.append(endRect);

    if (debug)

        qDebug() << movie->m_movieClips.size() - 1 << ":"  << endRect;

}

void FilmstripMovieFactory::createLeftToCenterMovie(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();

    int h = m_filmstripFlowData->m_widgetSize.height();

    qreal step = ANIMATION_MAX_FRAME;

    qreal cx = (w - cw) / 2.0;

    qreal cy = m_filmstripFlowData->m_centerTopSpace;

    qreal sx = (w * (1 - 2 * SPACE_P_C) - cw) / 2.0 - sw; // sild window's x

    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;

    //qDebug() << "sw:" << sw << " sh:" << sh << " cw:" << cw << " ch:" << ch;

    //qDebug() << " --------- " << stepx << " " << stepy << " " << stepx2 << " " << stepy2;

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

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

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

    //qDebug() << "!!!!!!createLeftToCenterMovie" << startRect << " ---> " << endRect;

}

void FilmstripMovieFactory::createRightToCenterMovie(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();

    int h = m_filmstripFlowData->m_widgetSize.height();

    qreal step = ANIMATION_MAX_FRAME;

    qreal cx = (w - cw) / 2.0;

    qreal cy = m_filmstripFlowData->m_centerTopSpace;

    qreal sx = (w * (1 + 2 * SPACE_P_C) + cw) / 2.0; // sild window's x

    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;

    //qDebug() << " --------- " << stepx << " " << stepy << " " << stepx2 << " " << stepy2;

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

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

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

    //qDebug() << "!!!!!!createRightToCenterMovie" << startRect << " ---> " << endRect;

}

void FilmstripMovieFactory::createCenterToLeftMovie(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();

    int h = m_filmstripFlowData->m_widgetSize.height();

    qreal step = ANIMATION_MAX_FRAME;

    qreal cx = (w - cw) / 2.0;

    qreal cy = m_filmstripFlowData->m_centerTopSpace;

    qreal sx = (w * (1 - 2 * SPACE_P_C) - cw) / 2.0 - sw; // sild window's x

    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;

    //qDebug() << " --------- " << stepx << " " << stepy << " " << stepx2 << " " << stepy2;

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

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

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

    //qDebug() << "!!!!!!createCenterToLeftMovie" << startRect << " ---> " << endRect;

}

void FilmstripMovieFactory::createCenterToRightMovie(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();

    int h = m_filmstripFlowData->m_widgetSize.height();

    qreal step = ANIMATION_MAX_FRAME;

    qreal cx = (w - cw) / 2.0;

    qreal cy = m_filmstripFlowData->m_centerTopSpace;

    qreal sx = (w * (1 + 2 * SPACE_P_C) + cw) / 2.0; // sild window's x

    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;

    //qDebug() << " --------- " << stepx << " " << stepy << " " << stepx2 << " " << stepy2;

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

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

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

    //qDebug() << "!!!!!!createCenterToRightMovie" << startRect << " ---> " << endRect;

}

void FilmstripMovieFactory::createLeftOutMovie(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();

    int h = m_filmstripFlowData->m_widgetSize.height();

    qreal cx = (w - cw) / 2.0;

    qreal sx = (w * (1 - 2 * SPACE_P_C) - cw) / 2.0 - sw; // sild window's x

    qreal sy = m_filmstripFlowData->m_sideTopSpace;

    qreal stepx = (sx -cx) / ANIMATION_MAX_FRAME;

    //qDebug() << " --------- " << stepx << " " << stepy << " " << stepx2 << " " << stepy2;

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

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

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

    //qDebug() << "!!!!!!createLeftInMovie" << startRect << " ---> " << endRect;

}

void FilmstripMovieFactory::createLeftInMovie(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();

    int h = m_filmstripFlowData->m_widgetSize.height();

    qreal cx = (w - cw) / 2.0;

    qreal sx = (w * (1 - 2 * SPACE_P_C) - cw) / 2.0 - sw; // sild window's x

    qreal sy = m_filmstripFlowData->m_sideTopSpace;

    qreal stepx = (cx - sx) / ANIMATION_MAX_FRAME;

    //qDebug() << " --------- " << stepx << " " << stepy << " " << stepx2 << " " << stepy2;