/*

 * Hedgewars, a free turn based strategy game

 * Copyright (c) 2006-2008 Igor Ulyanov <iulyanov@gmail.com>

 * Copyright (c) 2004-2015 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

#include <QDebug>

#include <QInputDialog>

#include <QCryptographicHash>

#include <QSortFilterProxyModel>

#include <QUuid>

#include "hwconsts.h"

#include "newnetclient.h"

#include "proto.h"

#include "game.h"

#include "roomslistmodel.h"

#include "playerslistmodel.h"

#include "servermessages.h"

#include "HWApplication.h"

char delimiter='\n';

HWNewNet::HWNewNet() :

    isChief(false),

    m_game_connected(false),

    netClientState(Disconnected)

{

    m_private_game = false;

    m_nick_registered = false;

    m_roomsListModel = new RoomsListModel(this);

    m_playersModel = new PlayersListModel(this);

    m_lobbyPlayersModel = new QSortFilterProxyModel(this);

    m_lobbyPlayersModel->setSourceModel(m_playersModel);

    m_lobbyPlayersModel->setSortRole(PlayersListModel::SortRole);

    m_lobbyPlayersModel->setDynamicSortFilter(true);

    m_lobbyPlayersModel->sort(0);

    m_roomPlayersModel = new QSortFilterProxyModel(this);

    m_roomPlayersModel->setSourceModel(m_playersModel);

    m_roomPlayersModel->setSortRole(PlayersListModel::SortRole);

    m_roomPlayersModel->setDynamicSortFilter(true);

    m_roomPlayersModel->sort(0);

    m_roomPlayersModel->setFilterRole(PlayersListModel::RoomFilterRole);

    m_roomPlayersModel->setFilterFixedString("true");

    // socket stuff

    connect(&NetSocket, SIGNAL(readyRead()), this, SLOT(ClientRead()));

    connect(&NetSocket, SIGNAL(connected()), this, SLOT(OnConnect()));

    connect(&NetSocket, SIGNAL(disconnected()), this, SLOT(OnDisconnect()));

    connect(&NetSocket, SIGNAL(error(QAbstractSocket::SocketError)), this,

            SLOT(displayError(QAbstractSocket::SocketError)));

    connect(this, SIGNAL(messageProcessed()), this, SLOT(ClientRead()), Qt::QueuedConnection);

}

HWNewNet::~HWNewNet()

{

    if (m_game_connected)

    {

        RawSendNet(QString("QUIT%1%2").arg(delimiter).arg("User quit"));

        emit disconnected(tr("User quit"));

    }

    NetSocket.flush();

}

void HWNewNet::Connect(const QString & hostName, quint16 port, const QString & nick)

{

    netClientState = Connecting;

    mynick = nick;

    myhost = hostName + QString(":%1").arg(port);

    NetSocket.connectToHost(hostName, port);

}

void HWNewNet::Disconnect()

{

    if (m_game_connected)

        RawSendNet(QString("QUIT%1%2").arg(delimiter).arg("User quit"));

    m_game_connected = false;

    NetSocket.disconnectFromHost();

}

void HWNewNet::CreateRoom(const QString & room, const QString & password)

{

    if(netClientState != InLobby)

    {

        qWarning("Illegal try to create room!");

        return;

    }

    myroom = room;

    if(password.isEmpty())

        RawSendNet(QString("CREATE_ROOM%1%2").arg(delimiter).arg(room));

    else

        RawSendNet(QString("CREATE_ROOM%1%2%1%3").arg(delimiter).arg(room).arg(password));

    isChief = true;

}

void HWNewNet::JoinRoom(const QString & room, const QString &password)

{

    if(netClientState != InLobby)

    {

        qWarning("Illegal try to join room!");

        return;

    }

    myroom = room;

    if(password.isEmpty())

        RawSendNet(QString("JOIN_ROOM%1%2").arg(delimiter).arg(room));

    else

        RawSendNet(QString("JOIN_ROOM%1%2%1%3").arg(delimiter).arg(room).arg(password));

    isChief = false;

}

void HWNewNet::AddTeam(const HWTeam & team)

{

    QString cmd = QString("ADD_TEAM") + delimiter +

                  team.name() + delimiter +

                  QString::number(team.color()) + delimiter +

                  team.grave() + delimiter +

                  team.fort() + delimiter +

                  team.voicepack() + delimiter +

                  team.flag() + delimiter +

                  QString::number(team.difficulty());

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

    {

        cmd.append(delimiter);

        cmd.append(team.hedgehog(i).Name);

        cmd.append(delimiter);

        cmd.append(team.hedgehog(i).Hat);

    }

    RawSendNet(cmd);

}

void HWNewNet::RemoveTeam(const HWTeam & team)

{

    RawSendNet(QString("REMOVE_TEAM") + delimiter + team.name());

}

void HWNewNet::NewNick(const QString & nick)

{

    RawSendNet(QString("NICK%1%2").arg(delimiter).arg(nick));

}

void HWNewNet::ToggleReady()

{

    RawSendNet(QString("TOGGLE_READY"));

}

void HWNewNet::SendNet(const QByteArray & buf)

{

    QString msg = QString(buf.toBase64());

    RawSendNet(QString("EM%1%2").arg(delimiter).arg(msg));

}

void HWNewNet::RawSendNet(const QString & str)

{

    RawSendNet(str.toUtf8());

}

void HWNewNet::RawSendNet(const QByteArray & buf)

{

    qDebug() << "Client: " << QString(QString::fromUtf8(buf)).split("\n");

    NetSocket.write(buf);

    NetSocket.write("\n\n", 2);

}

void HWNewNet::ClientRead()

{

    while (NetSocket.canReadLine())

    {

        QString s = QString::fromUtf8(NetSocket.readLine());

        if (s.endsWith('\n')) s.chop(1);

        if (s.size() == 0)

        {

            ParseCmd(cmdbuf);

            cmdbuf.clear();

            emit messageProcessed();

            return ;

        }

        else

            cmdbuf << s;

    }

}

void HWNewNet::OnConnect()

{

    netClientState = Connected;

}

void HWNewNet::OnDisconnect()

{

    netClientState = Disconnected;

    if(m_game_connected) emit disconnected("");

    m_game_connected = false;

}

void HWNewNet::displayError(QAbstractSocket::SocketError socketError)

{

    m_game_connected = false;

    switch (socketError)

    {

        case QAbstractSocket::RemoteHostClosedError:

            emit disconnected(tr("Remote host has closed connection"));

            break;

        case QAbstractSocket::HostNotFoundError:

            emit disconnected(tr("The host was not found. Please check the host name and port settings."));

            break;

        case QAbstractSocket::ConnectionRefusedError:

            emit disconnected(tr("Connection refused"));

            break;

        default:

            emit disconnected(NetSocket.errorString());

    }

}

void HWNewNet::SendPasswordHash(const QString & hash)

{

    // don't send it immediately, only store and check if server asked us for a password

    m_passwordHash = hash.toLatin1();

    maybeSendPassword();

}

void HWNewNet::ParseCmd(const QStringList & lst)

{

    qDebug() << "Server: " << lst;

    if(!lst.size())

    {

        qWarning("Net client: Bad message");

        return;

    }

    if (lst[0] == "NICK")

    {

        mynick = lst[1];

        m_playersModel->setNickname(mynick);

        m_nick_registered = false;

        return ;

    }

    if (lst[0] == "PROTO")

        return ;

    if (lst[0] == "ERROR")

    {

        if (lst.size() == 2)

            emit Error(HWApplication::translate("server", lst[1].toLatin1().constData()));

        else

            emit Error("Unknown error");

        return;

    }

    if (lst[0] == "WARNING")

    {

        if (lst.size() == 2)

            emit Warning(HWApplication::translate("server", lst[1].toLatin1().constData()));

        else

            emit Warning("Unknown warning");

        return;

    }

    if (lst[0] == "CONNECTED")

    {

        if(lst.size() < 3 || lst[2].toInt() < cMinServerVersion)

        {

            // TODO: Warn user, disconnect

            qWarning() << "Server too old";

            RawSendNet(QString("QUIT%1%2").arg(delimiter).arg("Server too old"));

            Disconnect();

            emit disconnected(tr("The server is too old. Disconnecting now."));

            return;

        }

        RawSendNet(QString("NICK%1%2").arg(delimiter).arg(mynick));

        RawSendNet(QString("PROTO%1%2").arg(delimiter).arg(*cProtoVer));

        netClientState = Connected;

        m_game_connected = true;

        emit adminAccess(false);

        return;

    }

    if (lst[0] == "SERVER_AUTH")

    {

        if(lst.size() < 2)

        {

            qWarning("Net: Malformed SERVER_AUTH message");

            return;

        }

        if(lst[1] != m_serverHash)

        {

            Error("Server authentication error");

            Disconnect();

        } else

        {

            // empty m_serverHash variable means no authentication was performed

            // or server passed authentication

            m_serverHash.clear();

        }

        return;

    }

    if (lst[0] == "PING")

    {

        if (lst.size() > 1)

            RawSendNet(QString("PONG%1%2").arg(delimiter).arg(lst[1]));

        else

            RawSendNet(QString("PONG"));

        return;

    }

    if (lst[0] == "ROOMS")

    {

        if(lst.size() % 9 != 1)

        {

            qWarning("Net: Malformed ROOMS message");

            return;

        }

        m_roomsListModel->setRoomsList(lst.mid(1));

        if (m_private_game == false && m_nick_registered == false)

        {

            emit NickNotRegistered(mynick);

        }

        return;

    }

    if (lst[0] == "SERVER_MESSAGE")

    {

        if(lst.size() < 2)

        {

            qWarning("Net: Empty SERVERMESSAGE message");

            return;

        }

        emit serverMessage(lst[1]);

        return;

    }

    if (lst[0] == "CHAT")

    {

        if(lst.size() < 3)

        {

            qWarning("Net: Empty CHAT message");

            return;

        }

        QString action = HWProto::chatStringToAction(lst[2]);

        if (netClientState == InLobby)

        {

            if (action != NULL)

                emit lobbyChatAction(lst[1], action);

            else

                emit lobbyChatMessage(lst[1], lst[2]);

        }

        else

        {

            emit chatStringFromNet(HWProto::formatChatMsg(lst[1], lst[2]));

            if (action != NULL)

                emit roomChatAction(lst[1], action);

            else

                emit roomChatMessage(lst[1], lst[2]);

        }

        return;

    }

    if (lst[0] == "INFO")

    {

        if(lst.size() < 5)

        {

            qWarning("Net: Malformed INFO message");

            return;

        }

        emit playerInfo(lst[1], lst[2], lst[3], lst[4]);

        if (netClientState != InLobby)

        {

            QStringList tmp = lst;

            tmp.removeFirst();

            emit chatStringFromNet(tmp.join(" ").prepend('\x01'));

        }

        return;

    }

    if (lst[0] == "SERVER_VARS")

    {

        QStringList tmp = lst;

        tmp.removeFirst();

        while (tmp.size() >= 2)

        {

            if(tmp[0] == "MOTD_NEW") emit serverMessageNew(tmp[1]);

            else if(tmp[0] == "MOTD_OLD") emit serverMessageOld(tmp[1]);

            else if(tmp[0] == "LATEST_PROTO") emit latestProtocolVar(tmp[1].toInt());

            tmp.removeFirst();

            tmp.removeFirst();

        }

        return;

    }

    if (lst[0] == "BANLIST")

    {

        QStringList tmp = lst;

        tmp.removeFirst();

        emit bansList(tmp);

        return;

    }

    if (lst[0] == "CLIENT_FLAGS" || lst[0] == "CF")

    {

        if(lst.size() < 3 || lst[1].size() < 2)

        {

            qWarning("Net: Malformed CLIENT_FLAGS message");

            return;

        }

        QString flags = lst[1];

        bool setFlag = flags[0] == '+';

        const QStringList nicks = lst.mid(2);

        while(flags.size() > 1)

        {

            flags.remove(0, 1);

            char c = flags[0].toLatin1();

            bool inRoom = (netClientState == InRoom || netClientState == InGame);

            switch(c)

            {

                // flag indicating if a player is ready to start a game

                case 'r':

                    if(inRoom)

                        foreach (const QString & nick, nicks)

                        {

                            if (nick == mynick)

                            {

                                emit setMyReadyStatus(setFlag);

                            }

                            m_playersModel->setFlag(nick, PlayersListModel::Ready, setFlag);

                        }

                        break;

                // flag indicating if a player is a registered user

                case 'u':

                        foreach(const QString & nick, nicks)

                            m_playersModel->setFlag(nick, PlayersListModel::Registered, setFlag);

                        break;

                // flag indicating if a player is in room

                case 'i':

                        foreach(const QString & nick, nicks)

                            m_playersModel->setFlag(nick, PlayersListModel::InRoom, setFlag);

                        break;

                // flag indicating if a player is contributor

                case 'c':

                        foreach(const QString & nick, nicks)

                            m_playersModel->setFlag(nick, PlayersListModel::Contributor, setFlag);

                        break;

                // flag indicating if a player has engine running

                case 'g':