/*

 * 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").arg(delimiter));

        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").arg(delimiter));

    m_game_connected = false;

    NetSocket.disconnectFromHost();

}

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

{

    if(netClientState != InLobby || !ByteLength(room))

    {

        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));

}

int HWNewNet::ByteLength(const QString & str)

{

	return str.toUtf8().size();

}

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:

            if (getHost() == (QString("%1:%2").arg(NETGAME_DEFAULT_SERVER).arg(NETGAME_DEFAULT_PORT)))

                // Error for official server

                emit disconnected(tr("The connection was refused by the official server or timed out. Something seems to be wrong with the official server at the moment. This might be a temporary problem. Please try again later."));

            else

                // Error for every other host

                emit disconnected(tr("The connection was refused by the host or timed out. This might have one of the following reasons:\n- The Hedgewars Server program does currently not run on the host\n- The specified port number is incorrect\n- There is a temporary network problem\n\nPlease check the host name and port settings and/or try again later."));

            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;

        QString message;

        // '[' is a special character used in fake nick names of server messages.

        // Those are supposed to be translated

        if(!lst[1].startsWith('['))

        {

            // Normal message

            message = lst[2];

            // Another kind of fake nick. '(' nicks are server messages, but they must not be translated

            if(!lst[1].startsWith('('))

            {

                // Check for action (/me command)

                action = HWProto::chatStringToAction(message);

            }

        }

        else

        {

            // Server message

            // Server messages are translated client-side

            message = HWApplication::translate("server", lst[2].toLatin1().constData());

        }

        if (netClientState == InLobby)

        {

            if (!action.isNull())

                emit lobbyChatAction(lst[1], action);

            else

                emit lobbyChatMessage(lst[1], message);

        }

        else

        {

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

            if (!action.isNull())

                emit roomChatAction(lst[1], action);

            else

                emit roomChatMessage(lst[1], message);

        }

        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)

            {