#include "settings.h"
#include "debug.h"

#include <QMetaType>
#include <MGConfItem>

QString databaseUrl = Settings.databaseUrl();


class Settings::Private
{
public:
    Private(Settings *parent);

private:
    Settings *q;
public:
    static Settings *server;
    QString errorString;
    MGConfItem language;
    MGConfItem japaneseInputMethodType;
    MGConfItem flickDistance;
    MGConfItem tsuModifyOrder;
    MGConfItem smallKaKe;
    MGConfItem pushWubi;
    MGConfItem pushAsso;
    MGConfItem showGuideAfter;
    MGConfItem foregroundColor;
    MGConfItem backgroundColor;
    MGConfItem databaseUrl;
    MGConfItem twinkleSource;
    MGConfItem twinkleVolume;
    MGConfItem twinkleBurst;
};

Settings *Settings::Private::server = 0;

Settings::Private::Private(Settings *parent)
    : q(parent)
    , language("/meegotouch/inputmethods/plugins/wubiCN/language")
    , japaneseInputMethodType("/meegotouch/inputmethods/plugins/wubiCN/romaji/active")
    , flickDistance("/meegotouch/inputmethods/plugins/wubiCN/flick/distance")
    , tsuModifyOrder("/meegotouch/inputmethods/plugins/wubiCN/flick/tsu")
    , smallKaKe("/meegotouch/inputmethods/plugins/wubiCN/flick/xkaxke")
    , pushWubi("/meegotouch/inputmethods/plugins/wubiCN/pushWubi")
    , pushAsso("/meegotouch/inputmethods/plugins/wubiCN/pushAsso")
    , showGuideAfter("/meegotouch/inputmethods/plugins/wubiCN/flick/show_guide_after")
    , backgroundColor("/meegotouch/inputmethods/plugins/wubiCN/background/color")
    , foregroundColor("/meegotouch/inputmethods/plugins/wubiCN/foreground/color")
    , databaseUrl("/meegotouch/inputmethods/plugins/wubiCN/databaseUrl")
    , twinkleSource("/meegotouch/inputmethods/plugins/wubiCN/twinkle/source")
    , twinkleVolume("/meegotouch/inputmethods/plugins/wubiCN/twinkle/volume")
    , twinkleBurst("/meegotouch/inputmethods/plugins/wubiCN/twinkle/burst")
{
    testDebugIn();
    qRegisterMetaType<Settings::JapaneseInputMethodType>("Settings::JapaneseInputMethodType");
    qRegisterMetaType<Settings::TsuModifyOrder>("Settings::TsuModifyOrder");

    connect(&language, SIGNAL(valueChanged()), q, SIGNAL(languageChanged()));
    connect(&japaneseInputMethodType, SIGNAL(valueChanged()), q, SIGNAL(japaneseInputMethodTypeChanged()));
    connect(&flickDistance, SIGNAL(valueChanged()), q, SIGNAL(flickDistanceChanged()));
    connect(&tsuModifyOrder, SIGNAL(valueChanged()), q, SIGNAL(tsuModifyOrderChanged()));
    connect(&smallKaKe, SIGNAL(valueChanged()), q, SIGNAL(smallKaKeChanged()));
    connect(&pushWubi, SIGNAL(valueChanged()), q, SIGNAL(pushWubiChanged()));
    connect(&pushAsso, SIGNAL(valueChanged()), q, SIGNAL(pushAssoChanged()));
    connect(&showGuideAfter, SIGNAL(valueChanged()), q, SIGNAL(showGuideAfterChanged()));
    connect(&foregroundColor, SIGNAL(valueChanged()), q, SIGNAL(foregroundColorChanged()));
    connect(&backgroundColor, SIGNAL(valueChanged()), q, SIGNAL(backgroundColorChanged()));
    connect(&databaseUrl, SIGNAL(valueChanged()), q, SIGNAL(databaseUrlChanged()));
    connect(&twinkleSource, SIGNAL(valueChanged()), q, SIGNAL(twinkleSourceChanged()));
    connect(&twinkleVolume, SIGNAL(valueChanged()), q, SIGNAL(twinkleVolumeChanged()));
    connect(&twinkleBurst, SIGNAL(valueChanged()), q, SIGNAL(twinkleBurstChanged()));

    if (language.value().isNull())
        language.set("简体五笔");

    if (flickDistance.value().isNull())
        flickDistance.set(24);

    if (smallKaKe.value().isNull())
        smallKaKe.set(false);

    if (pushAsso.value().isNull())
        pushAsso.set(true);

    if (showGuideAfter.value().isNull())
        showGuideAfter.set(512);

    if (foregroundColor.value().isNull())
        foregroundColor.set("white");

    if (backgroundColor.value().isNull())
        backgroundColor.set("black");

    if (twinkleSource.value().isNull())
        twinkleSource.set("1.png");
    if (twinkleSource.value().toString() == QLatin1String("star.png"))
        twinkleSource.set("1.png");

    if (twinkleVolume.value().isNull())
        twinkleVolume.set(25);

    if (twinkleBurst.value().isNull())
        twinkleBurst.set(false);

    if (pushWubi.value().isNull())
        pushWubi.set(true);

    testDebugOut();
}

Settings::Settings(QObject *parent)
    : QObject(parent)
{
    testDebugIn() << parent;
    d = new Private(this);
    testDebugOut();

}

Settings::~Settings()
{
    delete d;
}

QString Settings::language() const
{
    return d->language.value().toString();
}

void Settings::setLanguage(const QString &language)
{
    d->language.set(language);
}

Settings::JapaneseInputMethodType Settings::japaneseInputMethodType() const
{
    return (Settings::JapaneseInputMethodType)d->japaneseInputMethodType.value().toInt();
}

void Settings::setJapaneseInputMethodType(JapaneseInputMethodType japaneseInputMethodType)
{
    testDebugIn() << japaneseInputMethodType;
    d->japaneseInputMethodType.set((int)qBound(JapaneseRomaji, japaneseInputMethodType, JapaneseRomaji));
    testDebugOut();
}

int Settings::flickDistance() const
{
    return d->flickDistance.value().toInt();
}

void Settings::setFlickDistance(int flickDistance)
{
    testDebugIn() << flickDistance;
    d->flickDistance.set(qBound(12, flickDistance, 44));
    testDebugOut();
}

Settings::TsuModifyOrder Settings::tsuModifyOrder() const
{
    return (Settings::TsuModifyOrder)d->tsuModifyOrder.value().toInt();
}

void Settings::setTsuModifyOrder(Settings::TsuModifyOrder tsuModifyOrder)
{
    d->tsuModifyOrder.set((int)qBound(XtsuFirst, tsuModifyOrder, DsuFirst));
}

bool Settings::smallKaKe() const
{
    return d->smallKaKe.value().toBool();
}

void Settings::setSmallKaKe(bool smallKaKe)
{
    d->smallKaKe.set(smallKaKe);
}

bool Settings::pushWubi() const
{
    return d->pushWubi.value().toInt();
}

void Settings::setPushWubi(bool pushWubi)
{
    d->pushWubi.set(pushWubi);
}

bool Settings::pushAsso() const
{
    return d->pushAsso.value().toInt();
}

void Settings::setShowGuide(bool pushAsso)
{
    d->pushAsso.set(pushAsso);
}

int Settings::showGuideAfter() const
{
    return d->showGuideAfter.value().toInt();
}

void Settings::setShowGuideAfter(int showGuideAfter)
{
    d->showGuideAfter.set(qBound(0, showGuideAfter, 1000));
}

QColor Settings::foregroundColor() const
{
    return d->foregroundColor.value().value<QColor>();
}

void Settings::setForegroundColor(const QColor &foregroundColor)
{
    d->foregroundColor.set(foregroundColor.name());
}

QColor Settings::backgroundColor() const
{
    return d->backgroundColor.value().value<QColor>();
}

void Settings::setBackgroundColor(const QColor &backgroundColor)
{
    d->backgroundColor.set(backgroundColor.name());
}

QString Settings::databaseUrl() const
{
    return d->databaseUrl.value().toString();
}

void Settings::setDatabaseUrl(const QString &databaseUrl)
{
    d->databaseUrl.set(databaseUrl);
}

QString Settings::twinkleSource() const
{
    return d->twinkleSource.value().toString();
}

void Settings::setTwinkleSource(const QString &twinkleSource)
{
    d->twinkleSource.set(twinkleSource);
}

int Settings::twinkleVolume() const
{
    return d->twinkleVolume.value().toInt();
}

void Settings::setTwinkleVolume(int twinkleVolume)
{
    d->twinkleVolume.set(twinkleVolume);
}

bool Settings::twinkleBurst() const
{
    return d->twinkleBurst.value().toReal();
}

void Settings::setTwinkleBurst(bool twinkleBurst)
{
    d->twinkleBurst.set(twinkleBurst);
}

QString Settings::errorString() const
{
    return d->errorString;
}

void Settings::setErrorString(const QString &errorString)
{
    if (d->errorString == errorString) return;
    testDebugOn();
    testDebugIn() << errorString;
    d->errorString = errorString;
    emit errorStringChanged(errorString);
    testDebugOut();
    testDebugOff();
}