/*

 * Hedgewars, a free turn based strategy game

 * Copyright (c) 2007 Igor Ulyanov <iulyanov@gmail.com>

 * Copyright (c) 2004-2012 Andrey Korotaev <unC0Rr@gmail.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; version 2 of the License

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA

 */

#include <QDesktopServices>

#include <QTextBrowser>

#include <QLineEdit>

#include <QAction>

#include <QTextDocument>

#include <QFile>

#include <QList>

#include <QSettings>

#include <QTextStream>

#include <QMenu>

#include <QCursor>

#include <QScrollBar>

#include <QItemSelectionModel>

#include <QStringList>

#include <QDateTime>

#include <QTime>

#include <QMessageBox>

#include "DataManager.h"

#include "hwconsts.h"

#include "gameuiconfig.h"

#include "chatwidget.h"

ListWidgetNickItem::ListWidgetNickItem(const QString& nick, bool isFriend, bool isIgnored) : QListWidgetItem(nick)

{

}

{

}

bool ListWidgetNickItem::operator< (const QListWidgetItem & other) const

{

    // case in-sensitive comparison of the associated strings

    // chars that are no letters are sorted at the end of the list

    ListWidgetNickItem otherNick = const_cast<ListWidgetNickItem &>(dynamic_cast<const ListWidgetNickItem &>(other));

    // ignored always down

    // friends always up

    QString txt1 = text().toLower();

    QString txt2 = other.text().toLower();

    bool firstIsShorter = (txt1.size() < txt2.size());

    int len = firstIsShorter?txt1.size():txt2.size();

    for (int i = 0; i < len; i++)

    {

        if (txt1[i] == txt2[i])

            continue;

        if (txt1[i].isLetter() != txt2[i].isLetter())

            return txt1[i].isLetter();

        return (txt1[i] < txt2[i]);

    }

    return firstIsShorter;

}

QString * HWChatWidget::s_styleSheet = NULL;

QStringList * HWChatWidget::s_displayNone = NULL;

bool HWChatWidget::s_isTimeStamped = true;

QString HWChatWidget::s_tsFormat = ":mm:ss";

const QString & HWChatWidget::styleSheet()

{

    if (s_styleSheet != NULL)

        return *s_styleSheet;

    setStyleSheet();

    return *s_styleSheet;

}

void HWChatWidget::setStyleSheet(const QString & styleSheet)

{

    QString orgStyleSheet = styleSheet;

    QString style = QString(orgStyleSheet);

    // no stylesheet supplied, search for one or use default

    if (orgStyleSheet.isEmpty())

    {

        // load external stylesheet if there is any

        QFile extFile(DataManager::instance().findFileForRead("css/chat.css"));

        QFile resFile(":/res/css/chat.css");

        QFile & file = (extFile.exists()?extFile:resFile);

        if (file.open(QIODevice::ReadOnly | QIODevice::Text))

        {

            QTextStream in(&file);

            while (!in.atEnd())

            {

                style.append(in.readLine()+"\n");

            }

            orgStyleSheet = style;

            file.close();

        }

    }

    // let's parse display:none; ...

    // prepare for MAGIC :D

    // matches (multi-)whitespaces (for replacement with simple space)

    QRegExp ws("\\s+");

    // matches comments (for removal)

    QRegExp rem("/\\*([^*]|\\*(?!/))*\\*/");

    // strip comments and multi-whitespaces to compress the style-sheet a bit

    style = style.remove(rem).replace(ws," ");

    // now let's see what messages the user does not want to be displayed

    // by checking for display:none; (since QTextBrowser does not support it)

    // MOAR MAGIC :DDD

    // matches definitions lacking display:none; (for removal)

    QRegExp displayed(

        "([^{}]*\\{)(?!([^}]*;)* ?display ?: ?none ?(;[^}]*)?\\})[^}]*\\}");

    // matches all {...} and , (used as seperator for splitting into names)

    QRegExp split(" *(\\{[^}]*\\}|,) *");

    // matches class names that are referenced without hierachy

    QRegExp nohierarchy("^.[^ .]+$");

    QStringList victims = QString(style).

                          remove(displayed). // remove visible stuff

                          trimmed().

                          split(split). // get a list of the names

                          filter(nohierarchy). // only direct class names

                          replaceInStrings(QRegExp("^."),""); // crop .

    if (victims.contains("timestamp"))

    {

        s_isTimeStamped = false;

        victims.removeAll("timestamp");

    }

    else

    {

        s_isTimeStamped = true;

        s_tsFormat =

            ((victims.contains("timestamp:hours"))?"":"hh:") +

            QString("mm") +

            ((victims.contains("timestamp:seconds"))?"":":ss");

    }

    victims.removeAll("timestamp:hours");

    victims.removeAll("timestamp:seconds");

    victims.removeDuplicates();

    QStringList * oldDisplayNone = s_displayNone;

    QString * oldStyleSheet = s_styleSheet;

    s_displayNone = new QStringList(victims);

    s_styleSheet = new QString(orgStyleSheet);

    if (oldDisplayNone != NULL)

        delete oldDisplayNone;

    if (oldStyleSheet != NULL)

        delete oldStyleSheet;

}

void HWChatWidget::displayError(const QString & message)

{

    addLine("msg_Error", " !!! " + message);

    // scroll to the end

    chatText->moveCursor(QTextCursor::End);

}

void HWChatWidget::displayNotice(const QString & message)

{

    addLine("msg_Notice", " *** " + message);

    // scroll to the end

    chatText->moveCursor(QTextCursor::End);

}

void HWChatWidget::displayWarning(const QString & message)

{

    addLine("msg_Warning", " *!* " + message);

    // scroll to the end

    chatText->moveCursor(QTextCursor::End);

}

HWChatWidget::HWChatWidget(QWidget* parent, QSettings * gameSettings, bool notify) :

    QWidget(parent),

    mainLayout(this)

{

    this->gameSettings = gameSettings;

    this->notify = notify;

    m_isAdmin = false;

    m_autoKickEnabled = false;

    if(gameSettings->value("frontend/sound", true).toBool())

    {

        QStringList vpList =

             QStringList() << "Classic" << "Default" << "Mobster" << "Russian";

        foreach (QString vp, vpList)

        {

            m_helloSounds.append(DataManager::instance().findFileForRead(

                               QString("Sounds/voices/%1/Hello.ogg").arg(vp)));

        }

        m_hilightSound = DataManager::instance().findFileForRead(

                             "Sounds/beep.ogg");

    }

    mainLayout.setSpacing(1);

    mainLayout.setMargin(1);

    mainLayout.setSizeConstraint(QLayout::SetMinimumSize);

    mainLayout.setColumnStretch(0, 76);

    mainLayout.setColumnStretch(1, 24);

    chatEditLine = new SmartLineEdit(this);

    chatEditLine->setMaxLength(300);

    connect(chatEditLine, SIGNAL(returnPressed()), this, SLOT(returnPressed()));

    mainLayout.addWidget(chatEditLine, 2, 0);

    chatText = new QTextBrowser(this);

    chatText->document()->setDefaultStyleSheet(styleSheet());

    chatText->setMinimumHeight(20);

    chatText->setMinimumWidth(10);

    chatText->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

    chatText->setOpenLinks(false);

    connect(chatText, SIGNAL(anchorClicked(const QUrl&)),

            this, SLOT(linkClicked(const QUrl&)));

    mainLayout.addWidget(chatText, 0, 0, 2, 1);

    chatNicks = new QListWidget(this);

    chatNicks->setMinimumHeight(10);

    chatNicks->setMinimumWidth(10);

    chatNicks->setSortingEnabled(true);

    chatNicks->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

    chatNicks->setContextMenuPolicy(Qt::ActionsContextMenu);

    connect(chatNicks, SIGNAL(itemDoubleClicked(QListWidgetItem *)),

            this, SLOT(chatNickDoubleClicked(QListWidgetItem *)));

    connect(chatNicks, SIGNAL(currentRowChanged(int)),

            this, SLOT(chatNickSelected(int)));

    mainLayout.addWidget(chatNicks, 0, 1, 3, 1);

    // the userData is used to flag things that are even available when user

    // is offline

    acInfo = new QAction(QAction::tr("Info"), chatNicks);

    acInfo->setIcon(QIcon(":/res/info.png"));

    acInfo->setData(QVariant(false));

    connect(acInfo, SIGNAL(triggered(bool)), this, SLOT(onInfo()));

    acKick = new QAction(QAction::tr("Kick"), chatNicks);

    acKick->setIcon(QIcon(":/res/kick.png"));

    acKick->setData(QVariant(false));

    connect(acKick, SIGNAL(triggered(bool)), this, SLOT(onKick()));

    acBan = new QAction(QAction::tr("Ban"), chatNicks);

    acBan->setIcon(QIcon(":/res/ban.png"));

    acBan->setData(QVariant(true));

    connect(acBan, SIGNAL(triggered(bool)), this, SLOT(onBan()));

    acFollow = new QAction(QAction::tr("Follow"), chatNicks);

    acFollow->setIcon(QIcon(":/res/follow.png"));

    acFollow->setData(QVariant(false));

    connect(acFollow, SIGNAL(triggered(bool)), this, SLOT(onFollow()));

    acIgnore = new QAction(QAction::tr("Ignore"), chatNicks);

    acIgnore->setIcon(QIcon(":/res/ignore.png"));

    acIgnore->setData(QVariant(true));

    connect(acIgnore, SIGNAL(triggered(bool)), this, SLOT(onIgnore()));

    acFriend = new QAction(QAction::tr("Add friend"), chatNicks);

    acFriend->setIcon(QIcon(":/res/addfriend.png"));

    acFriend->setData(QVariant(true));

    connect(acFriend, SIGNAL(triggered(bool)), this, SLOT(onFriend()));

    chatNicks->insertAction(0, acFriend);

    chatNicks->insertAction(0, acInfo);

    chatNicks->insertAction(0, acIgnore);

    setShowFollow(true);

    setAcceptDrops(true);

    clear();

}

void HWChatWidget::linkClicked(const QUrl & link)

{

    if (link.scheme() == "http")

        QDesktopServices::openUrl(link);

    if (link.scheme() == "hwnick")

    {

        // decode nick

        QString nick = QString::fromUtf8(QByteArray::fromBase64(link.encodedQuery()));

        QList<QListWidgetItem *> items = chatNicks->findItems(nick, Qt::MatchExactly);

        bool isOffline = (items.size() < 1);

        QMenu * popup = new QMenu(this);

        if (isOffline)

        {

            m_clickedNick = nick;

            chatNickSelected(0); // update friend and ignore entry

            chatNicks->setCurrentItem(NULL, QItemSelectionModel::Clear);

        }

        else

        {

            // selecting an item will automatically scroll there, so let's save old position

            QScrollBar * scrollBar = chatNicks->verticalScrollBar();

            int oldScrollPos = scrollBar->sliderPosition();

            // select the nick which we want to see the actions for

            chatNicks->setCurrentItem(items[0], QItemSelectionModel::Clear);

            // selecting an item will automatically scroll there, so let's save old position

            scrollBar->setSliderPosition(oldScrollPos);

        }

        // load actions

        QList<QAction *> actions = chatNicks->actions();

        foreach(QAction * action, actions)

        {

            if ((!isOffline) || (action->data().toBool()))

                popup->addAction(action);

        }

        // display menu popup at mouse cursor position

        popup->popup(QCursor::pos());

    }

}

void HWChatWidget::setShowFollow(bool enabled)

{

    if (enabled)

    {

        if (!(chatNicks->actions().contains(acFollow)))

            chatNicks->insertAction(acFriend, acFollow);

    }

    else

    {

        if (chatNicks->actions().contains(acFollow))

            chatNicks->removeAction(acFollow);

    }

}

void HWChatWidget::setIgnoreListKick(bool enabled)

{

    m_autoKickEnabled = enabled;

}

void HWChatWidget::loadList(QStringList & list, const QString & file)

{

    list.clear();

    QFile txt(cfgdir->absolutePath() + "/" + file);

    if(!txt.open(QIODevice::ReadOnly))

        return;

    QTextStream stream(&txt);

    stream.setCodec("UTF-8");

    while(!stream.atEnd())

    {

        QString str = stream.readLine();