/*

 * Java net client for Hedgewars, a free turn based strategy game

 * Copyright (c) 2011 Richard Karolyi <sheepluva@ercatec.net>

 *

 * 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

 */

package net.ercatec.hw;

import java.lang.*;

import java.lang.IllegalArgumentException;

import java.lang.Runnable;

import java.lang.Thread;

import java.io.*;

import java.net.*;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Scanner;

import java.util.Vector;

// for auth

import java.math.BigInteger;

import java.security.MessageDigest;

import java.security.SecureRandom;

import java.security.NoSuchAlgorithmException;

public final class ProtocolConnection implements Runnable

{

    private static final String DEFAULT_HOST = "netserver.hedgewars.org";

    private static final int DEFAULT_PORT = 46631;

    private static final String PROTOCOL_VERSION = "53";

    private final Socket socket;

    private BufferedReader fromSvr;

    private PrintWriter toSvr;

    private final INetClient netClient;

    private boolean quit;

    private boolean debug;

    private final String host;

    private final int port;

    private String nick;

    public ProtocolConnection(INetClient netClient) throws Exception {

        this(netClient, DEFAULT_HOST);

    }

    public ProtocolConnection(INetClient netClient, String host) throws Exception {

        this(netClient, host, DEFAULT_PORT);

    }

    public ProtocolConnection(INetClient netClient, String host, int port) throws Exception {

        this.netClient = netClient;

        this.host = host;

        this.port = port;

        this.nick = nick = "";

        this.quit = false;

        fromSvr = null;

        toSvr = null;

        try {

            socket = new Socket(host, port);

            fromSvr = new BufferedReader(new InputStreamReader(socket.getInputStream()));

            toSvr = new PrintWriter(socket.getOutputStream(), true);

        }

        catch(Exception ex) {

            throw ex;

        }

        ProtocolMessage firstMsg = processNextMessage();

        if (firstMsg.getType() != ProtocolMessage.Type.CONNECTED) {

            closeConnection();

            throw new Exception("First Message wasn't CONNECTED.");

        }

    }

    public void run() {

        try {

            while (!quit) {

                processNextMessage();

            }

        }

        catch(Exception ex) {

            netClient.logError("FATAL: Run loop died unexpectedly!");

            ex.printStackTrace();

            handleConnectionLoss();

        }

        // only gets here when connection was closed

    }

    public void processMessages() {

        processMessages(false);

    }

    public Thread processMessages(boolean inNewThread)

    {

        if (inNewThread)

            return new Thread(this);

        run();

        return null;

    }

    public void processNextClientFlagsMessages()

    {

        while (!quit) {

            if (!processNextMessage(true).isValid)

                break;

        }

    }

    private ProtocolMessage processNextMessage() {

        return processNextMessage(false);

    }

    private void handleConnectionLoss() {

        closeConnection();

        netClient.onConnectionLoss();

    }

    public void close() {

        this.closeConnection();

    }

    private synchronized void closeConnection() {

        if (quit)

            return;

        quit = true;

        try {

            if (fromSvr != null)

                fromSvr.close();

        } catch(Exception ex) {};

        try {

            if (toSvr != null)

                toSvr.close();

        } catch(Exception ex) {};

        try {

            socket.close();

        } catch(Exception ex) {};

    }

    private String resumeLine = "";

    private ProtocolMessage processNextMessage(boolean onlyIfClientFlags)

    {

        String line;

        final List<String> parts = new ArrayList<String>(32);

        while (!quit) {

            if (!resumeLine.isEmpty()) {

                    line = resumeLine;

                    resumeLine = "";

                }

            else {

                try {

                    line = fromSvr.readLine();

                    if (onlyIfClientFlags && (parts.size() == 0)

                        && !line.equals("CLIENT_FLAGS")) {

                            resumeLine = line;

                            // return invalid message

                            return new ProtocolMessage();

                        }

                }

                catch(Exception whoops) {

                    handleConnectionLoss();

                    break;

                }

            }

            if (line == null) {

                handleConnectionLoss();

                // return invalid message

                return new ProtocolMessage();

            }

            if (!quit && line.isEmpty()) {

                if (parts.size() > 0) {

                    ProtocolMessage msg = new ProtocolMessage(parts);

                    netClient.logDebug("Server: " + msg.toString());

                    if (!msg.isValid()) {

                        netClient.onMalformedMessage(msg.toString());

                        if (msg.getType() != ProtocolMessage.Type.BYE)

                            continue;

                    }

                    final String[] args = msg.getArguments();

                    netClient.sanitizeInputs(args);

                    final int argc = args.length;

                    try {

                        switch (msg.getType()) {

                            case PING:

                                netClient.onPing();

                                break;

                            case LOBBY__JOINED:

                                try {

                                    assertAuthNotIncomplete();

                                }

                                catch (Exception ex) {

                                    disconnect();

                                    netClient.onDisconnect(ex.getMessage());

                                }

                                netClient.onLobbyJoin(args);

                                break;

                            case LOBBY__LEFT:

                                netClient.onLobbyLeave(args[0], args[1]);

                                break;

                            case CLIENT_FLAGS:

                                String user;

                                final String flags = args[0];

                                if (flags.length() < 2) {

                                    //netClient.onMalformedMessage(msg.toString());

                                    break;

                                }

                                final char mode = flags.charAt(0);

                                if ((mode != '-') && (mode != '+')) {

                                    //netClient.onMalformedMessage(msg.toString());

                                    break;

                                }

                                final int l = flags.length();

                                for (int i = 1; i < l; i++) {

                                    // set flag type

                                    final INetClient.UserFlagType flag;

                                    // TODO support more flags

                                    switch (flags.charAt(i)) {

                                        case 'a':

                                            flag = INetClient.UserFlagType.ADMIN;

                                            break;

                                        case 'i':

                                            flag = INetClient.UserFlagType.INROOM;

                                            break;

                                        case 'u':

                                            flag = INetClient.UserFlagType.REGISTERED;

                                            break;

                                        default:

                                            flag = INetClient.UserFlagType.UNKNOWN;

                                            break;

                                        }

                                    for (int j = 1; j < args.length; j++) {

                                        netClient.onUserFlagChange(args[j], flag, mode=='+');

                                    }

                                }

                                break;

                            case CHAT:

                                netClient.onChat(args[0], args[1]);

                                break;

                            case INFO:

                                netClient.onUserInfo(args[0], args[1], args[2], args[3]);

                                break;

                            case PONG:

                                netClient.onPong();

                                break;

                            case NICK:

                                final String newNick = args[0];

                                if (!newNick.equals(this.nick)) {

                                    this.nick = newNick;

                                }

                                    netClient.onNickSet(this.nick);

                                sendMessage(new String[] { "PROTO", PROTOCOL_VERSION });

                                break;

                            case NOTICE:

                                // nickname collision

                                if (args[0].equals("0"))

                                    setNick(netClient.onNickCollision(this.nick));

                                break;

                            case ASKPASSWORD:

                                try {

                                    final String pwHash = netClient.onPasswordHashNeededForAuth();

                                    doAuthPart1(pwHash, args[0]);

                                }

                                catch (Exception ex) {

                                    disconnect();

                                    netClient.onDisconnect(ex.getMessage());

                                }

                                break;

                            case ROOMS:

                                final int nf = ProtocolMessage.ROOM_FIELD_COUNT;

                                for (int a = 0; a < argc; a += nf) {

                                    handleRoomInfo(args[a+1], Arrays.copyOfRange(args, a, a + nf));

                                }

                            case ROOM_ADD:

                                handleRoomInfo(args[1], args);

                                break;

                            case ROOM_DEL:

                                netClient.onRoomDel(args[0]);

                                break;

                            case ROOM_UPD:

                                handleRoomInfo(args[0], Arrays.copyOfRange(args, 1, args.length));

                                break;

                            case BYE:

                                closeConnection();

                                if (argc > 0)

                                    netClient.onDisconnect(args[0]);

                                else

                                    netClient.onDisconnect("");

                                break;

                            case SERVER_AUTH:

                                try {

                                    doAuthPart2(args[0]);

                                }

                                catch (Exception ex) {

                                    disconnect();

                                    netClient.onDisconnect(ex.getMessage());

                                }

                                break;

                        }

                        // end of message

                        return msg;

                    }

                    catch(IllegalArgumentException ex) {

                        netClient.logError("Illegal arguments! "

                            + ProtocolMessage.partsToString(parts)

                            + "caused: " + ex.getMessage());

                        return new ProtocolMessage();

                    }

                }

            }

            else

            {

                parts.add(line);

            }

        }

        netClient.logError("WARNING: Message wasn't parsed correctly: "

                            + ProtocolMessage.partsToString(parts));

        // return invalid message

        return new ProtocolMessage(); // never to be reached

    }

    private void handleRoomInfo(final String name, final String[] info) throws IllegalArgumentException

    {

        // TODO room flags enum array

        final int nUsers;

        final int nTeams;

        try {

            nUsers = Integer.parseInt(info[2]);

        }

        catch(IllegalArgumentException ex) {

            throw new IllegalArgumentException(

                "Player count is not an valid integer!",

                ex);

        }

        try {

            nTeams = Integer.parseInt(info[3]);

        }

        catch(IllegalArgumentException ex) {

            throw new IllegalArgumentException(

                "Team count is not an valid integer!",

                ex);

        }

        netClient.onRoomInfo(name, info[0], info[1], nUsers, nTeams,

                             info[4], info[5], info[6], info[7], info[8]);

    }

    private static final String AUTH_SALT = PROTOCOL_VERSION + "!hedgewars";

    private static final int PASSWORD_HASH_LENGTH = 32;

    public static final int SERVER_SALT_MIN_LENGTH = 16;

    private static final String AUTH_ALG = "SHA-1";

    private String serverAuthHash = "";

    private void assertAuthNotIncomplete() throws Exception {

        if (!serverAuthHash.isEmpty()) {

            netClient.logError("AUTH-ERROR: assertAuthNotIncomplete() found that authentication was not completed!");

            throw new Exception("Authentication was not finished properly!");

        }

        serverAuthHash = "";

    }

    private void doAuthPart2(final String serverAuthHash) throws Exception {

        if (!this.serverAuthHash.equals(serverAuthHash)) {

            netClient.logError("AUTH-ERROR: Server's authentication hash is incorrect!");

            throw new Exception("Server failed mutual authentication! (wrong hash provided by server)");

        }

        netClient.logDebug("Auth: Mutual authentication successful.");

        this.serverAuthHash = "";

    }

    private void doAuthPart1(final String pwHash, final String serverSalt) throws Exception {

        if ((pwHash == null) || pwHash.isEmpty()) {

            netClient.logDebug("AUTH: Password required, but no password hash was provided.");

            throw new Exception("Auth: Password needed, but none specified.");

        }

        if (pwHash.length() != PASSWORD_HASH_LENGTH) {

            netClient.logError("AUTH-ERROR: Your password hash has an unexpected length! Should be "

                               + PASSWORD_HASH_LENGTH + " but is " + pwHash.length()

                              );

            throw new Exception("Auth: Your password hash length seems wrong.");

        }

        if (serverSalt.length() < SERVER_SALT_MIN_LENGTH) {

            netClient.logError("AUTH-ERROR: Salt provided by server is too short! Should be at least "

                               + SERVER_SALT_MIN_LENGTH + " but is " + serverSalt.length()

                              );

            throw new Exception("Auth: Server violated authentication protocol! (auth salt too short)");

        }

        final MessageDigest sha1Digest;

        try {

             sha1Digest = MessageDigest.getInstance(AUTH_ALG);

        }

        catch(NoSuchAlgorithmException ex) {

            netClient.logError("AUTH-ERROR: Algorithm required for authentication ("

                                      + AUTH_ALG + ") not available!"

                                     );

            return;

        } 

        // generate 130 bit base32 encoded value

        // base32 = 5bits/char => 26 chars, which is more than min req

        final String clientSalt =

            new BigInteger(130, new SecureRandom()).toString(32);

        final String saltedPwHash =

            clientSalt + serverSalt + pwHash + AUTH_SALT;

        final String saltedPwHash2 =

            serverSalt + clientSalt + pwHash + AUTH_SALT;

        final String clientAuthHash =

            new BigInteger(1, sha1Digest.digest(saltedPwHash.getBytes("UTF-8"))).toString(16);

        serverAuthHash =

            new BigInteger(1, sha1Digest.digest(saltedPwHash2.getBytes("UTF-8"))).toString(16);

        sendMessage(new String[] { "PASSWORD", clientAuthHash, clientSalt });

/* When we got password hash, and server asked us for a password, perform mutual authentication:

 * at this point we have salt chosen by server

 * client sends client salt and hash of secret (password hash) salted with client salt, server salt,

 * and static salt (predefined string + protocol number)

 * server should respond with hash of the same set in different order.

    if(m_passwordHash.isEmpty() || m_serverSalt.isEmpty())

        return;

    QString hash = QCryptographicHash::hash(

                m_clientSalt.toAscii()

                .append(m_serverSalt.toAscii())

                .append(m_passwordHash)

                .append(cProtoVer->toAscii())

                .append("!hedgewars")

                , QCryptographicHash::Sha1).toHex();

    m_serverHash = QCryptographicHash::hash(

                m_serverSalt.toAscii()

                .append(m_clientSalt.toAscii())

                .append(m_passwordHash)

                .append(cProtoVer->toAscii())

                .append("!hedgewars")

                , QCryptographicHash::Sha1).toHex();

    RawSendNet(QString("PASSWORD%1%2%1%3").arg(delimiter).arg(hash).arg(m_clientSalt));

Server:  ("ASKPASSWORD", "5S4q9Dd0Qrn1PNsxymtRhupN") 

Client:  ("PASSWORD", "297a2b2f8ef83bcead4056b4df9313c27bb948af", "{cc82f4ca-f73c-469d-9ab7-9661bffeabd1}") 

Server:  ("SERVER_AUTH", "06ecc1cc23b2c9ebd177a110b149b945523752ae") 

 */

    }

    public void sendCommand(final String command)

    {

        String cmd = command;

        // don't execute empty commands

        if (cmd.length() < 1)

            return;

        // replace all newlines since they violate protocol

        cmd = cmd.replace('\n', ' ');

        // parameters are separated by one or more spaces.

        final String[] parts = cmd.split(" +");

        // command is always CAPS

        parts[0] = parts[0].toUpperCase();

        sendMessage(parts);