/****************************************************************************

**

** 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 "hbdatetimepicker_p.h"

#include "hbdatetimepicker.h"

#include "hbstyleoption_p.h"

#include "hbfeaturemanager_r.h"

//TODO:remove frameitem dependency

#include "hbframeitem.h"

#include <QStringListModel>

#include <QGraphicsLinearLayout>

#include <QModelIndex>

#include <QDate>

#include <QLocale>

#include <QPointer>

//#define HBDATETIMEPICKER_DEBUG

#ifdef HBDATETIMEPICKER_DEBUG

#include <QDebug>

#endif

//////////HbDateTimeParser - Implementaion may change in future.//////////////

static inline int countRepeat(const QString &str, int index, int maxCount)

{

    int count = 1;

    const QChar ch(str.at(index));

    const int max = qMin(index + maxCount, str.size());

    while (index + count < max && str.at(index + count) == ch) {

        ++count;

    }

    return count;

}

static QString unquote(const QString &str)

{

    const QChar quote(QLatin1Char('\''));

    const QChar slash(QLatin1Char('\\'));

    const QChar zero(QLatin1Char('0'));

    QString ret;

    QChar status(zero);

    const int max = str.size();

    for (int i=0; i<max; ++i) { 

        if (str.at(i) == quote) {

            if (status != quote) {

                status = quote;

            } else if (!ret.isEmpty() && str.at(i - 1) == slash) {

                ret[ret.size() - 1] = quote;

            } else {

                status = zero;

            }

        } else {

            ret += str.at(i);

        }

    }

    return ret;

}

static inline void appendSeparator(QStringList *list, const QString &string, int from, int size, int lastQuote)

{

    QString str(string.mid(from, size));

    if (lastQuote >= from)

        str = unquote(str);

    list->append(str);

}

bool HbDateTimeParser::parseFormat(const QString &format)

{

    const QLatin1Char quote('\'');

    const QLatin1Char slash('\\');

    const QLatin1Char zero('0');

    if (format == mDisplayFormat && !format.isEmpty()) {

        return true;

    }

    QVector<SectionNode> newSectionNodes;

    Sections newDisplay = 0;

    QStringList newSeparators;

    int i, index = 0;

    int add = 0;

    QChar status(zero);

    const int max = format.size();

    int lastQuote = -1;

    for (i = 0; i<max; ++i) {

        if (format.at(i) == quote) {

            lastQuote = i;

            ++add;

            if (status != quote) {

                status = quote;

            } else if (format.at(i - 1) != slash) {

                status = zero;

            }

        } else if (status != quote) {

            const char sect = format.at(i).toLatin1();

            switch (sect) {

            case 'H':

            case 'h':

                {

                    const Section hour = (sect == 'h') ? Hour12Section : Hour24Section;

                    const SectionNode sn = { hour, i - add, countRepeat(format, i, 2) };

                    newSectionNodes.append(sn);

                    appendSeparator(&newSeparators, format, index, i - index, lastQuote);

                    i += sn.count - 1;

                    index = i + 1;

                    newDisplay |= hour;

                }

                break;

            case 'm':

                {

                    const SectionNode sn = { MinuteSection, i - add, countRepeat(format, i, 2) };

                    newSectionNodes.append(sn);

                    appendSeparator(&newSeparators, format, index, i - index, lastQuote);

                    i += sn.count - 1;

                    index = i + 1;

                    newDisplay |= MinuteSection;

                }

                break;

            case 's':

                {

                    const SectionNode sn = { SecondSection, i - add, countRepeat(format, i, 2) };

                    newSectionNodes.append(sn);

                    appendSeparator(&newSeparators, format, index, i - index, lastQuote);

                    i += sn.count - 1;

                    index = i + 1;

                    newDisplay |= SecondSection;

                }

                break;

            case 'z':

                {

                    const SectionNode sn = { MSecSection, i - add, countRepeat(format, i, 3) < 3 ? 1 : 3 };

                    newSectionNodes.append(sn);

                    appendSeparator(&newSeparators, format, index, i - index, lastQuote);

                    i += sn.count - 1;

                    index = i + 1;

                    newDisplay |= MSecSection;

                }

                break;

            case 'A':

            case 'a':

                {

                    const bool cap = (sect == 'A');

                    const SectionNode sn = { AmPmSection, i - add, (cap ? 1 : 0) };

                    newSectionNodes.append(sn);

                    appendSeparator(&newSeparators, format, index, i - index, lastQuote);

                    newDisplay |= AmPmSection;

                    if (i + 1 < format.size()

                        && format.at(i+1) == (cap ? QLatin1Char('P') : QLatin1Char('p'))) {

                            ++i;

                    }

                    index = i + 1;

                }

                break;

            case 'y':

                {

                    const int repeat = countRepeat(format, i, 4);

                    if (repeat >= 2) {

                        const SectionNode sn = { repeat == 4 ? YearSection : YearSection2Digits,

                            i - add, repeat == 4 ? 4 : 2 };

                        newSectionNodes.append(sn);

                        appendSeparator(&newSeparators, format, index, i - index, lastQuote);

                        i += sn.count - 1;

                        index = i + 1;

                        newDisplay |= sn.type;

                    }

                }

                break;

            case 'M':

                {

                    const SectionNode sn = { MonthSection, i - add, countRepeat(format, i, 4) };

                    newSectionNodes.append(sn);

                    newSeparators.append(unquote(format.mid(index, i - index)));

                    i += sn.count - 1;

                    index = i + 1;

                    newDisplay |= MonthSection;

                }

                break;

            case 'd':

                {

                    const int repeat = countRepeat(format, i, 4);

                    const SectionNode sn = { repeat >= 3 ? DayOfWeekSection : DaySection, i - add, repeat };

                    newSectionNodes.append(sn);

                    appendSeparator(&newSeparators, format, index, i - index, lastQuote);

                    i += sn.count - 1;

                    index = i + 1;

                    newDisplay |= sn.type;

                }

                break;

            default:

                break;

            }

        }

    }

    if ((newDisplay & (AmPmSection|Hour12Section)) == Hour12Section) {

        const int max = newSectionNodes.size();

        for (int i=0; i<max; ++i) {

            SectionNode &node = newSectionNodes[i];

            if (node.type == Hour12Section)

                node.type = Hour24Section;

        }

    }

    if (index < format.size()) {

        appendSeparator(&newSeparators, format, index, index - max, lastQuote);

    } else {

        newSeparators.append(QString());

    }

    mDisplayFormat = format;

    mSeparators = newSeparators;

    mSectionNodes = newSectionNodes;

    mDisplaySections = newDisplay;

    return true;

}

int HbDateTimeParser::sectionSize(int sectionIndex) const

{

    if (sectionIndex < 0)

        return 0;

    if (sectionIndex >= mSectionNodes.size()) {

        qWarning("QDateTimeParser::sectionSize Internal error (%d)", sectionIndex);

        return -1;

    }

    if (sectionIndex == mSectionNodes.size() - 1) {

        return mDisplayFormat.size() - sectionPos(sectionIndex) - mSeparators.last().size();

    } else {

        return sectionPos(sectionIndex + 1) - sectionPos(sectionIndex)

            - mSeparators.at(sectionIndex + 1).size();

    }

}

int HbDateTimeParser::sectionPos(int sectionIndex) const

{

    return sectionPos(sectionNode(sectionIndex));

}

int HbDateTimeParser::sectionPos(const SectionNode &sn) const

{

    if (sn.pos == -1) {

        return -1;

    }

    return sn.pos;

}

const HbDateTimeParser::SectionNode &HbDateTimeParser::sectionNode(int sectionIndex) const

{

    return mSectionNodes.at(sectionIndex);

}

/////////////////////////////////////////////////

HbDateTimePickerPrivate::HbDateTimePickerPrivate()

:HbWidgetPrivate()

    ,mDayPicker(0)

    ,mMonthPicker(0)

    ,mYearPicker(0)

    ,mHourPicker(0)

    ,mMinutePicker(0)

    ,mSecondPicker(0)

    ,mAmPmPicker(0)

    ,mDayModel(0)

    ,mMonthModel(0)

    ,mYearModel(0)

    ,mHourModel(0)

    ,mMinuteModel(0)

    ,mSecondModel(0)

    ,mAmPmModel(0)

    ,mYearOffset(-1)

    ,mMonthOffset(-1)

    ,mDayOffset(-1)

    ,mHourOffset(-1)

    ,mMinuteOffset(-1)

    ,mSecondOffset(-1)

    ,mDateTime(QDateTime::currentDateTime())

    ,mDateTimeMode(QVariant::Date) //default is date mode

    ,mLayout(0)         

    //,mFormat() //set the format again in init()

    //,mDisplaySecions() //is blank by default

    ,mParser()

    ,mYearFormat()

    ,mMonthFormat()

    ,mDayFormat()

    ,mHourFormat()

    ,mMinuteFormat()

    ,mSecondFormat() 

    ,mIs24HourFormat(false)

    ,mIsTwoDigitYearFormat(false)

    ,mBackground(0)

    ,mFrame(0)

    ,mContent(0)

    ,mIntervals()

    ,mHighlight(0)

{

    mMinimumDate = HBDATETIMEPICKER_DATETIME_MIN;

    mMaximumDate = HBDATETIMEPICKER_DATETIME_MAX;

    mDateTime = mMinimumDate;

}

HbDateTimePickerPrivate::~HbDateTimePickerPrivate()

{

}

/*

   called only once. while the widget is constructing.

*/

void HbDateTimePickerPrivate::init(QVariant::Type dateTimeMode)

{

    Q_Q(HbDateTimePicker);

    //create base content widget which contains the tumble views

    mContent=new HbWidget(q);

    mLayout = new QGraphicsLinearLayout(Qt::Horizontal);

    mLayout->setSpacing(1);

    mLayout->setContentsMargins(0,0,0,0);

    mContent->setLayout(mLayout);

    mDateTimeMode = dateTimeMode;

    mIntervals[QDateTimeEdit::MinuteSection]=1;

    //read the format from locale

    mFormat = localeDateTimeFormat(dateTimeMode);

    //parse the format and set the sections in order

    parseDisplayFormat(mFormat);

    //create primitives

    createPrimitives();

    //recreate and rearrange depending on the format

    rearrangeTumbleViews();

}

/*!

  \internal

  Getting the format from the local settings.

*/

QString HbDateTimePickerPrivate::localeDateTimeFormat(const QVariant::Type &dateTimeMode)

{

    if(dateTimeMode == QVariant::Date) {

        return mLocale.dateFormat(QLocale::ShortFormat);

    } else if(dateTimeMode == QVariant::Time) {

        return mLocale.timeFormat(QLocale::ShortFormat);

    }

    return mLocale.dateTimeFormat(QLocale::ShortFormat);

}

bool HbDateTimePickerPrivate::isFormatValid(const QString &newDisplayFormat)

{

    if(newDisplayFormat == mFormat) {

        return false;

    }

    return true;

}

/* 

   this will reset the display sections and re add them in order

   mentioned in the display format passed. this also sets the mIs24HourFormat var.

*/

void HbDateTimePickerPrivate::parseDisplayFormat(const QString &format)

{

    if(mParser.parseFormat(format)) {

        for(int i=0;i<mParser.mSectionNodes.count();++i) {

            switch(mParser.mSectionNodes[i].type) {

                case HbDateTimeParser::DaySection:

                case HbDateTimeParser::DayOfWeekSection:

                    mDayFormat = QString(mParser.mSectionNodes[i].count,'d');

                    break;

                case HbDateTimeParser::MonthSection:

                    mMonthFormat = QString(mParser.mSectionNodes[i].count,'M');

                    break;

                case HbDateTimeParser::YearSection:

                    mIsTwoDigitYearFormat = false;

                    mYearFormat = QString(mParser.mSectionNodes[i].count,'y');

                    break;

                case HbDateTimeParser::YearSection2Digits:

                    mIsTwoDigitYearFormat = true;

                    mYearFormat = QString(mParser.mSectionNodes[i].count,'y');

                    break;

                case HbDateTimeParser::SecondSection:

                    mSecondFormat = QString(mParser.mSectionNodes[i].count,'s');

                    break;

                case HbDateTimeParser::MinuteSection:

                    mMinuteFormat = QString(mParser.mSectionNodes[i].count,'m');

                    break;

                case HbDateTimeParser::Hour12Section:

                    mIs24HourFormat = false;

                    mHourFormat = QString(mParser.mSectionNodes[i].count,'h');

                    break;

                case HbDateTimeParser::Hour24Section:

                    mIs24HourFormat = true;

                    mHourFormat = QString(mParser.mSectionNodes[i].count,'h');

                    break;

                default:

                    break;

                    /*case HbDateTimeParser::DayOfWeekSection: not supported */

            }

        }

    }

}

/*

   this is called whenever the setDisplayFormat changes.

   function deletes all tumbleviews which currently exist and

   it creates the ones which are required and makes the connections.

*/

void HbDateTimePickerPrivate::rearrangeTumbleViews()

{                  

    Q_Q(HbDateTimePicker);

    if(!(mParser.mDisplaySections & (HbDateTimeParser::YearSection|

				     HbDateTimeParser::YearSection2Digits))) {

      deleteAndNull(mYearPicker);

      mYearModel = 0;

    }

    if(!(mParser.mDisplaySections & HbDateTimeParser::MonthSection)) {

      deleteAndNull(mMonthPicker);

      mMonthModel = 0;

    }

    if(!(mParser.mDisplaySections & HbDateTimeParser::DaySection)) {

      deleteAndNull(mDayPicker);

      mDayModel = 0;

    }

    if(!(mParser.mDisplaySections & (HbDateTimeParser::Hour12Section|

				     HbDateTimeParser::Hour24Section))) {

      deleteAndNull(mHourPicker);

      mHourModel = 0;

    }

    if(!(mParser.mDisplaySections & HbDateTimeParser::MinuteSection)) {

      deleteAndNull(mMinutePicker);

      mMinuteModel = 0;

    }

    if(!(mParser.mDisplaySections & HbDateTimeParser::SecondSection)) {

      deleteAndNull(mSecondPicker);

      mSecondModel = 0;

    }

    if(!(mParser.mDisplaySections & HbDateTimeParser::AmPmSection)) {

      deleteAndNull(mAmPmPicker);

      mAmPmModel = 0;

    }

    mYearOffset = -1;

    mMonthOffset = -1;

    mDayOffset = -1;

    mHourOffset = -1;

    mMinuteOffset = -1;

    mSecondOffset = -1;

    while(mLayout->count()) {

      mLayout->removeAt(0);

    }

    QPointer<VIEWER> lastAdded;

    for(int i=0;i<mParser.mSectionNodes.count();i++) {

        switch(mParser.mSectionNodes[i].type) {

            case HbDateTimeParser::AmPmSection:

                if(!mAmPmPicker) {

                    mAmPmPicker = new VIEWER(q);

                    mAmPmModel = static_cast<QStringListModel*>(mAmPmPicker->model());

                }

                mLayout->addItem(mAmPmPicker);

                lastAdded = mAmPmPicker;

                break;

            case HbDateTimeParser::DaySection:

            case HbDateTimeParser::DayOfWeekSection:

                if(!mDayPicker) {

                    mDayPicker = new VIEWER(q);

                    mDayModel = static_cast<QStringListModel*>(mDayPicker->model());

                    mDayPicker->setLoopingEnabled(true);

                }

                mLayout->addItem(mDayPicker);

                lastAdded = mDayPicker;

                break;

            case HbDateTimeParser::MonthSection:

                if(!mMonthPicker) {

                    mMonthPicker = new VIEWER(q);

                    mMonthModel = static_cast<QStringListModel*>(mMonthPicker->model());

                    mMonthPicker->setLoopingEnabled(true);

                }