/*

 * Hedgewars, a free turn based strategy game

 * Copyright (c) 2006-2008 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 <QDebug>

#include <QInputDialog>

#include <QCryptographicHash>

#include <QSortFilterProxyModel>

#include "hwconsts.h"

#include "newnetclient.h"

#include "proto.h"

#include "game.h"

#include "roomslistmodel.h"

#include "playerslistmodel.h"

char delimeter='\n';

HWNewNet::HWNewNet() :

    isChief(false),

    m_game_connected(false),

    loginStep(0),

    netClientState(Disconnected)

{

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

}

HWNewNet::~HWNewNet()

{

    if (m_game_connected)

    {

        RawSendNet(QString("QUIT%1%2").arg(delimeter).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(delimeter).arg("User quit"));

    m_game_connected = false;

    NetSocket.disconnectFromHost();

}

void HWNewNet::CreateRoom(const QString & room)

{

    if(netClientState != InLobby)

    {

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

        return;

    }

    myroom = room;

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

    isChief = true;

}

void HWNewNet::JoinRoom(const QString & room)

{

    if(netClientState != InLobby)

    {

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

        return;

    }

    myroom = room;

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

    isChief = false;

}

void HWNewNet::AddTeam(const HWTeam & team)

{

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

                  team.name() + delimeter +

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

                  team.grave() + delimeter +

                  team.fort() + delimeter +

                  team.voicepack() + delimeter +

                  team.flag() + delimeter +

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

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

    {

        cmd.append(delimeter);

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

        cmd.append(delimeter);

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

    }

    RawSendNet(cmd);

}

void HWNewNet::RemoveTeam(const HWTeam & team)

{

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

}

void HWNewNet::NewNick(const QString & nick)

{

    RawSendNet(QString("NICK%1%2").arg(delimeter).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(delimeter).arg(msg));

}

void HWNewNet::RawSendNet(const QString & str)

{

    RawSendNet(str.toUtf8());

}

void HWNewNet::RawSendNet(const QByteArray & buf)

{

    qDebug() << "Client: " << QString(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();

        }

        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)

{

    RawSendNet(QString("PASSWORD%1%2").arg(delimeter).arg(hash));

}

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

        return ;

    }

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

        return ;

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

    {

        if (lst.size() == 2)

            emit Error(lst[1]);

        else

            emit Error("Unknown error");

        return;

    }

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

    {

        if (lst.size() == 2)

            emit Warning(lst[1]);

        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(delimeter).arg("Server too old"));

            Disconnect();

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

            return;

        }

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

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

        netClientState = Connected;

        m_game_connected = true;

        emit adminAccess(false);

        return;

    }

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

    {

        if (lst.size() > 1)

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

        else

            RawSendNet(QString("PONG"));

        return;

    }

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

    {

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

        {

            qWarning("Net: Malformed ROOMS message");

            return;

        }

        QStringList tmp = lst;

        tmp.removeFirst();

        m_roomsListModel->setRoomsList(tmp);

        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;

        }

        if (netClientState == InLobby)

            emit chatStringLobby(lst[1], HWProto::formatChatMsgForFrontend(lst[2]));

        else

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

        return;

    }

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

    {

        if(lst.size() < 5)

        {

            qWarning("Net: Malformed INFO message");

            return;

        }

        QStringList tmp = lst;

        tmp.removeFirst();

        if (netClientState == InLobby)

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

        else

            emit chatStringFromNet(tmp.join("\n").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] == "CLIENT_FLAGS")

    {

        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].toAscii();

            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)

                            {

                                if (isChief && !setFlag) ToggleReady();

                                else 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 has engine running

                case 'g':

                    if(inRoom)

                        foreach(const QString & nick, nicks)

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

                        break;

                // flag indicating if a player is the host/master of the room

                case 'h':

                    if(inRoom)

                        foreach (const QString & nick, nicks)

                        {

                            if (nick == mynick)

                            {

                                isChief = setFlag;

                                emit roomMaster(isChief);

                            }

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

                        }

                        break;

                // flag indicating if a player is admin (if so -> worship them!)

                case 'a':

                        foreach (const QString & nick, nicks)

                        {

                            if (nick == mynick)

                                emit adminAccess(setFlag);

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

                        }

                        break;

                default:

                        qWarning() << "Net: Unknown client-flag: " << c;

            }

        }

        return;

    }

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

    {

        netClientState = InLobby;

        askRoomsList();

        emit LeftRoom(tr("You got kicked"));

        m_playersModel->resetRoomFlags();

        return;

    }

    if(lst[0] == "LOBBY:JOINED")

    {

        if(lst.size() < 2)

        {

            qWarning("Net: Bad JOINED message");

            return;

        }

        for(int i = 1; i < lst.size(); ++i)

        {

            if (lst[i] == mynick)

            {

                netClientState = InLobby;

                RawSendNet(QString("LIST"));

                emit connected();

            }

            emit nickAddedLobby(lst[i], false);

            emit chatStringLobby(lst[i], tr("%1 *** %2 has joined").arg('\x03').arg("|nick|"));

            m_playersModel->addPlayer(lst[i]);

        }

        return;

    }

    if(lst[0] == "ROOM" && lst.size() == 10 && lst[1] == "ADD")

    {

        QStringList tmp = lst;

        tmp.removeFirst();

        tmp.removeFirst();