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

**

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

                    if(newDisplay & hour) {

                        return false; // error in format

                    }

                    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;

                    if(newDisplay & MinuteSection) {

                        return false; // error in format

                    }

                    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;

                    if(newDisplay & SecondSection) {

                        return false; // error in format

                    }

                    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;

                    if(newDisplay & MSecSection) {

                        return false; // error in format

                    }

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

                    if(newDisplay & AmPmSection) {

                        return false; // error in format

                    }

                    newDisplay |= AmPmSection;

                    if (i + 1 < format.size()

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

                    }

                    index = i + 1;

                }

                break;

            case 'y':

                {

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

                    if (repeat >= 2) {

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

                        newSectionNodes.append(sn);

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

                        i += sn.count - 1;

                        index = i + 1;

                        if(newDisplay & sn.type) {

                            return false; //error in format

                        }

                        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;

                    if(newDisplay & MonthSection) {

                        return false; // error in format

                    }

                    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;

                    if(newDisplay & (DayOfWeekSection | DaySection)) {

                        return false; // error in format, dd and ddd not yet supported in same format

                    }

                    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)

    }

}

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

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

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

    HbStyle::setItemName(mContent,"content");

    mDateTimeMode = dateTimeMode;

    mIntervals[QDateTimeEdit::MinuteSection]=1;

    //read the format from locale

    QString newFormat = localeDateTimeFormat(dateTimeMode);

    }

    //create primitives

    createPrimitives();

}

/*!

  \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 mParser.parseFormat(newDisplayFormat);

}

/* 

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

{

        }

}

/*

   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|

    }

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

    }

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

    }

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

    }

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

    }

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

    }

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

    }

    mYearOffset = -1;

    mMonthOffset = -1;

    mDayOffset = -1;

    mHourOffset = -1;

    mMinuteOffset = -1;

    mSecondOffset = -1;

    while(mLayout->count()) {

    }