/***************************************************************************
 * Copyright (C) 2014 by Renaud Guezennec                                   *
 * http://www.rolisteam.org/contact                      *
 *                                                                          *
 *  This file is part of DiceParser                                         *
 *                                                                          *
 * DiceParser 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; either version 2 of the License, or        *
 * (at your option) any later version.                                      *
 *                                                                          *
 * 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 "botircdiceparser.h"

#include <QDebug>
#include <QString>
#include <math.h>

BotIrcDiceParser::BotIrcDiceParser(QObject* parent) : QObject(parent)
{
    // Create socket
    m_socket= new QTcpSocket(this);

    m_parser= new DiceParser();

    // Connect signals and slots!
    connect(m_socket, SIGNAL(readyRead()), this, SLOT(readData()));
    connect(m_socket, SIGNAL(connected()), this, SLOT(authentificationProcess()));
    connect(m_socket, SIGNAL(disconnected()), this, SLOT(connectToServer()));
    connect(
        m_socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(errorOccurs(QAbstractSocket::SocketError)));
}

BotIrcDiceParser::~BotIrcDiceParser()
{
    //  delete ui;
}
void BotIrcDiceParser::connectToServer()
{
    qDebug() << "start connection";
    m_socket->connectToHost(QString("irc.freenode.net"), 8001);
}
void BotIrcDiceParser::errorOccurs(QAbstractSocket::SocketError)
{
    qDebug() << "ERROR" << m_socket->errorString();
}

void BotIrcDiceParser::readData()
{
    qDebug() << "Reply";
    QString readLine= m_socket->readLine();

    if(readLine.startsWith("!"))
        readLine= readLine.remove(0, 1);

    if(readLine.contains("!"))
    {
        // qDebug()<< "in /dice";
        QString dice= ".*PRIVMSG.*!(.*)";
        QRegExp exp(dice);
        exp.indexIn(readLine);

        QStringList list= exp.capturedTexts();
        qDebug() << list;
        if(list.size() == 2)
        {
            QString cmd= list[1];
            if(!cmd.isEmpty())
            {
                cmd= cmd.simplified();
                QString result= startDiceParsing(cmd, true);
                if(!result.isEmpty())
                {
                    QString msg("PRIVMSG #RolisteamOfficial :%1 \r\n");
                    m_socket->write(msg.arg(result).toLatin1());
                }
            }
        }
        else
        {
            return;
        }
        //
    }
    else if(readLine.contains("PING :"))
    {
        QString dice= "PING :(.*)";
        QRegExp exp(dice);
        exp.indexIn(readLine);
        QStringList list= exp.capturedTexts();
        if(list.size() == 2)
        {
            QString resp= "PONG :" + list[1];

            m_socket->write(resp.toLatin1());
        }
    }
    if(readLine.contains(QLatin1String("Found your hostname")))
    {
        authentificationProcess();
    }
    if(readLine.contains(QLatin1String("msg NickServ identify")))
    {
        setRegisterName();
    }
    // Add to ouput
    // ui->m_output->append(readLine.trimmed());
    QMessageLogger().debug() << readLine.trimmed();
    // Next data??
    if(m_socket->canReadLine())
        readData();
}
void BotIrcDiceParser::setRegisterName()
{
    m_socket->write(QLatin1String("msg NickServ identify  \r\n").data());
    joinChannel();
}

void BotIrcDiceParser::disconnectFromServer()
{
    // Disconnect from IRC server
    m_socket->write("QUIT Good bye \r\n"); // Good bye is optional message
    m_socket->flush();
    m_socket->disconnect(); // Now we can try it :-)
}
void BotIrcDiceParser::authentificationProcess()
{
    qDebug() << "authentification";
    m_socket->write(QLatin1String("NICK rolisteamDice \r\n").data());
    m_socket->write(QLatin1String("USER rolisteamDice rolisteamDice rolisteamDice :rolisteamDice BOT \r\n").data());
}
void BotIrcDiceParser::joinChannel()
{
    m_socket->write(QLatin1String("JOIN #RolisteamOfficial \r\n").data());
}
QString BotIrcDiceParser::diceToText(QList<ExportedDiceResult>& diceList, bool highlight, bool homogeneous)
{
    QStringList global;
    for(auto dice : diceList)
    {
        QStringList resultGlobal;
        for(int face : dice.keys())
        {
            QStringList result;
            ListDiceResult diceResult= dice.value(face);
            // patternColor = patternColorarg();
            foreach(HighLightDice tmp, diceResult)
            {
                QStringList diceListStr;
                QStringList diceListChildren;

                for(int i= 0; i < tmp.getResult().size(); ++i)
                {
                    qint64 dievalue= tmp.getResult()[i];
                    QString prefix("%1");

                    if((tmp.isHighlighted()) && (highlight))
                    {
                        if(tmp.getColor().isEmpty() || tmp.getColor() == "black")
                        {
                            prefix= "%1";
                        }
                        if(tmp.getColor() == "white")
                        {
                            prefix= "%1";
                        }
                        if(tmp.getColor() == "blue")
                        {
                            prefix= "%1";
                        }
                        if(tmp.getColor() == "red")
                        {
                            prefix= "%1";
                        }
                    }

                    if(i == 0)
                    {
                        diceListStr << prefix.arg(QString::number(dievalue));
                    }
                    else
                    {
                        diceListChildren << prefix.arg(QString::number(dievalue));
                    }
                }
                if(!diceListChildren.isEmpty())
                {
                    diceListStr << QString("[%1]").arg(diceListChildren.join(' '));
                }

                result << diceListStr.join(' ');
                // qDebug() << result << tmp.first << tmp.second;
            }

            if(dice.keys().size() > 1)
            {
                resultGlobal << QString(" d%2:(%1)").arg(result.join(',')).arg(face);
            }
            else
            {
                resultGlobal << result;
            }
        }
        global << resultGlobal.join(' ');
    }
    return global.join(' ');
}

QString BotIrcDiceParser::startDiceParsing(QString& cmd, bool highlight)
{
    QString result;
    QTextStream out(&result);
    if(m_parser->parseLine(cmd))
    {
        m_parser->start();
        if(!m_parser->getErrorMap().isEmpty())
        {
            out << "Error" << m_parser->humanReadableError() << "\n";
            return QString();
        }

        QList<ExportedDiceResult> list;
        bool homogeneous= true;
        m_parser->getLastDiceResult(list, homogeneous);
        QString diceText= diceToText(list, highlight, homogeneous);
        QString scalarText;
        QString str;

        if(m_parser->hasIntegerResultNotInFirst())
        {
            auto values= m_parser->getLastIntegerResults();
            QStringList strLst;
            for(auto val : values)
            {
                strLst << QString::number(val);
            }
            scalarText= QString("%1").arg(strLst.join(','));
        }
        else if(!list.isEmpty())
        {
            auto values= m_parser->getSumOfDiceResult();
            QStringList strLst;
            for(auto val : values)
            {
                strLst << QString::number(val);
            }
            scalarText= QString("%1").arg(strLst.join(','));
        }
        if(highlight)
            str= QString("Result: %1, details:[%3 (%2)]").arg(scalarText).arg(diceText).arg(m_parser->getDiceCommand());
        else
            str= QString("Result: %1, details:[%3 (%2)]").arg(scalarText).arg(diceText).arg(m_parser->getDiceCommand());

        if(m_parser->hasStringResult())
        {
            str= m_parser->getStringResult().join(",");
        }
        out << str << "\n";
    }
    else
    {
        out << m_parser->humanReadableError() << "\n";
        ;
    }

    return result;
}