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

**

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

**

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

//

//  W A R N I N G

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

//

// This file is not part of the Hb API.  It exists purely as an

// implementation detail.  This file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include <QIntValidator>

#include <QRegExpValidator>

#include <QTextCursor>

#include <QRegExp>

#include <QtDebug>

#include <QTextDocument>

#include <QDate>

#include "hbdatetimevalidator_p_p.h"

#include "hbvalidator_p.h"

#define DEFAULT_YEAR_VALUE "2009"

const int KMinimumYear = -4713;

const int KMaximumYear = 11000000; // see more in QDate documentation

HbDateTimeValidatorPrivate::HbDateTimeValidatorPrivate() :

    HbValidatorPrivate()

{

}

HbDateTimeValidatorPrivate::~HbDateTimeValidatorPrivate()

{

}

class HbFixableIntQValidator : public QIntValidator

{

public:

    HbFixableIntQValidator( QObject * parent ) :

            QIntValidator ( parent ),

            mMaxLeght(10000)

    {

    }

    HbFixableIntQValidator ( int minimum, int maximum, QObject * parent ) :

            QIntValidator ( minimum, maximum, parent )

    {

        int topLenght = QString::number(top()).length();

        int bottomLenght = QString::number(bottom()).length();

        mMaxLeght = qMax(topLenght, bottomLenght);

    }

    void fixup ( QString & input ) const

    {

        QString newTextValue=input;

        newTextValue.remove(QRegExp((bottom()>=0)?"[^0-9]":"[^\\-0-9]"));

        bool ok;

        int value = newTextValue.toInt(&ok);

        if(ok) {

            value = qBound(bottom(), value, top());

            newTextValue.setNum(value);

            if(newTextValue!=input) {

                input = newTextValue;

            }

        }

    }

    State validate ( QString & input, int & pos ) const

    {

        if(input.length()>mMaxLeght) {

            return Invalid;

        }

        return QIntValidator::validate(input, pos);

    }

private:

    int mMaxLeght;

};

void HbDateTimeValidatorPrivate::addDateTimeField(const DataPositions& data)

{

    Q_Q(HbDateTimeValidator);

    QValidator *fieldValidator = NULL;

    QString defaultValue;

    switch(data.type) {

    case Year: {

            if(data.lenght() == 4) {

                fieldValidator = new HbFixableIntQValidator(KMinimumYear,

                                                            KMaximumYear,

                                                            q);

                defaultValue = "2009";

            } else {

                fieldValidator = new HbFixableIntQValidator(0,99,q);

                defaultValue = "09";

            }

        }

        break;

    case Month: {

            fieldValidator = new HbFixableIntQValidator(1,12,q);

            defaultValue = (data.lenght() == 1)?"1":"01";

        }

        break;

    case Day: {

            fieldValidator = new HbFixableIntQValidator(1,31,q);

            defaultValue = (data.lenght() == 1)?"1":"01";

        }

        break;

    case AmPm: {

            QRegExp regUxp("AM|PM", Qt::CaseInsensitive);

            fieldValidator = new QRegExpValidator(regUxp,q);

            defaultValue = "AM";

        }

        break;

    case Hour24: {

            fieldValidator = new HbFixableIntQValidator(0,23,q);

            defaultValue = (data.lenght() == 1)?"0":"00";

        }

        break;

    case Hour12: {

            fieldValidator = new HbFixableIntQValidator(1,12,q);

            defaultValue = "12";

        }

        break;

    case Minutes: {

            fieldValidator = new HbFixableIntQValidator(0,59,q);

            defaultValue = (data.lenght() == 1)?"0":"00";

        }

        break;

    case Seconds: {

            fieldValidator = new HbFixableIntQValidator(0,59,q);

            defaultValue = (data.lenght() == 1)?"0":"00";

        }

        break;

    case MilliSeconds: {

            fieldValidator = new HbFixableIntQValidator(0,999,q);

            defaultValue = (data.lenght() == 1)?"0":"000";

        }

        break;

    default:

        Q_ASSERT(false);

    }

    fieldTypes.append(data.type);

    addField(separatorToAdd,fieldValidator,defaultValue);

}

bool HbDateTimeValidatorPrivate::fixDate(QTextCursor *cursor, bool updateCursor)

{

    Q_ASSERT(!fieldTypes.isEmpty());

    QRegExp regExp = QRegExp(parseString,Qt::CaseInsensitive);

    Q_ASSERT(regExp.isValid());

    bool result = false;

    if(regExp.exactMatch(cursor->document()->toPlainText())) {

        QTextCursor fixingCursor(cursor->document());

        fixingCursor.beginEditBlock();

        // step one: fixing each field separately

        for(int i = fieldTypes.count()-1; i>=0; --i ) {

            int pos = regExp.pos(i+1);

            QString fieldTxt = regExp.cap(i+1);

            fixingCursor.setPosition(pos);

            fixingCursor.setPosition(pos + fieldTxt.length());

            int x = fieldTxt.length();

            if( QValidator::Acceptable != fields.at(i)->mValidator->validate(fieldTxt, x) ) {

                fields.at(i)->mValidator->fixup(fieldTxt);

                if(QValidator::Acceptable == fields.at(i)->mValidator->validate(fieldTxt, x)) {

                    // successful fix

                    fixingCursor.insertText(fieldTxt);

                    result = true;

                }

            }

        }

        // step two: fixing correlations between fields

        // Note: this functionality is specific for HbDateTimeValidator

        int yearCapture  = fieldTypes.indexOf(Year)+1;

        int monthCapture = fieldTypes.indexOf(Month)+1;

        int dayCapture   = fieldTypes.indexOf(Day)+1;

        if(dayCapture<=0 || monthCapture<=0) {

            fixingCursor.endEditBlock();

            return result; // nothing to fix no date

        }

        // match content again

        if(regExp.exactMatch(cursor->document()->toPlainText())) {

            int year=1900, month, day;

            if(yearCapture>0) {

                year = regExp.cap(yearCapture).toInt();

            }

            month = regExp.cap(monthCapture).toInt();

            int daySize =0;

            QString s = regExp.cap(dayCapture);

            daySize = s.length();

            day   = s.toInt();

            if( !QDate::isValid(year, month, day) ) {

                QDate dateFoFix(year,month,1);

                if(dateFoFix.daysInMonth()<day) {

                    dateFoFix.setDate(year,month,dateFoFix.daysInMonth());

                    int dayCapPos = regExp.pos(dayCapture);

                    fixingCursor.setPosition(dayCapPos);

                    fixingCursor.setPosition(dayCapPos+daySize, QTextCursor::KeepAnchor);

                    // updating date by changing document

                    // this will prevent some unexpected isues

                    fixingCursor.insertText(QString().setNum(dateFoFix.daysInMonth()));

                    if(updateCursor) {

                        fixingCursor.setPosition(dayCapPos);

                        fixingCursor.setPosition(dayCapPos+daySize, QTextCursor::KeepAnchor);

                        *cursor = fixingCursor;

                    }

                    result = true;

                }

            }

        }

        fixingCursor.endEditBlock();

    }

    return result;

}

/*!

    \class HbDateTimeValidator

    \brief HbDateTimeValidator provides validation services for QAbstractEdit derived editors.

*/

/*!

    Constructs a HbDateTimeValidator object with a /a parent

*/

HbDateTimeValidator::HbDateTimeValidator(QObject *parent) :

    HbValidator(*new HbDateTimeValidatorPrivate, parent)

{

    Q_D(HbDateTimeValidator);

    d->q_ptr = this;

}

HbDateTimeValidator::HbDateTimeValidator(HbDateTimeValidatorPrivate &dd, QObject *parent) :

    HbValidator(dd, parent)

{

    Q_D(HbDateTimeValidator);

    d->q_ptr = this;

}

/*!

    Destructor

*/

HbDateTimeValidator::~HbDateTimeValidator()

{

}

inline void appendIfFound(DataType type, QList<DataPositions>* where, QRegExp& what, const QString& from)

{

    int pos = from.indexOf(what);

    if(pos>=0) {

        int matchLenght = what.cap(0).length();

        Q_ASSERT( matchLenght>0 );

        Q_ASSERT( from.indexOf(what, pos+matchLenght)==-1 );

        where->append(

                DataPositions(type, pos, matchLenght)

                );

    }

}

void HbDateTimeValidator::setDisplayFormat(const QString &format)

{

    QList<DataPositions> positions;

    QRegExp regExp;

    QString newParseString = QRegExp::escape(format);

    const QString captureNumber = "([0-9]+)";

    regExp.setPattern("yy(yy)?");

    appendIfFound(Year, &positions, regExp, format);

    newParseString.replace(regExp, captureNumber);

    regExp.setPattern("M{1,3}");

    appendIfFound(Month, &positions, regExp, format);

    newParseString.replace(regExp, captureNumber);

    regExp.setPattern("d{1,3}");

    appendIfFound(Day, &positions, regExp, format);

    newParseString.replace(regExp, captureNumber);

    const QString captureAmPm("(AM|PM|am|pm)");

    regExp.setPattern("ap");

    appendIfFound(AmPm, &positions, regExp, format);

    newParseString.replace(regExp, captureAmPm);

    regExp.setPattern("AP");

    appendIfFound(AmPm, &positions, regExp, format);

    newParseString.replace(regExp, captureAmPm);

    DataType hourType = Hour24;

    if(!positions.isEmpty()) {

        if(positions.last().type==AmPm) {

            hourType = Hour12;

        }

    }

    regExp.setPattern("hh?");

    appendIfFound(hourType, &positions, regExp, format);

    newParseString.replace(regExp, captureNumber);

    regExp.setPattern("HH?");

    appendIfFound(hourType, &positions, regExp, format);

    newParseString.replace(regExp, captureNumber);

    regExp.setPattern("mm?");

    appendIfFound(Minutes, &positions, regExp, format);

    newParseString.replace(regExp, captureNumber);

    regExp.setPattern("ss?");

    appendIfFound(Seconds, &positions, regExp, format);

    newParseString.replace(regExp, captureNumber);

    regExp.setPattern("z(zz)?");

    appendIfFound(MilliSeconds, &positions, regExp, format);

    newParseString.replace(regExp, captureNumber);

    if(positions.size()==0) {

        qWarning() << "HbDateTimeValidator::setDisplayFormat: format: \""

                << format << "\" is invalid so it was ignored" ;

        return;

    }

    qSort(positions);

    Q_D(HbDateTimeValidator);

    d->format = format;

    // ignore trailing separators:

    if(positions.back().stop < format.length()) {

        newParseString.chop(QRegExp::escape(format.mid(positions.back().stop)).length());

        d->format.resize(positions.back().stop);

    }

    // ignore front separators:

    if(positions.front().start != 0) {

        newParseString.remove(0,positions.front().start);

    }

    d->parseString = newParseString;

    d->fieldTypes.clear();

    d->deleteAllFields();

    const int n=positions.size()-1;

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

        d->addDateTimeField(positions.at(i));

        int separatorBegin = positions.at(i).stop;

        int separatorLenght = positions.at(i+1).start - separatorBegin;

        if(separatorLenght>0) {

            setDefaultSeparator(format.mid(separatorBegin,separatorLenght));

        } else {

            setDefaultSeparator(" ");

        }

    }

    d->addDateTimeField(positions.at(n));

}

const QString HbDateTimeValidator::displayFormat() const

{

    Q_D(const HbDateTimeValidator);

    return d->format;

}

bool HbDateTimeValidator::fixDate(QTextCursor *cursor, bool updateCursor)

{

    return d_func()->fixDate(cursor, updateCursor);

}