/*

 * 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.util.Arrays;

import java.util.List;

import java.util.Iterator;

public final class ProtocolMessage

{

    public static final int ROOM_FIELD_COUNT = 9;

    private static int minServerVersion = 49;

    public static enum Type {

        // for unknown message types

        _UNKNOWN_MESSAGETYPE_,

        // server messages

        ERROR,

        PING,

        PONG,

        NICK,

        PROTO,

        ASKPASSWORD,

        SERVER_AUTH,

        CONNECTED,

        SERVER_MESSAGE,

        BYE,

        INFO,

        NOTICE,

        CHAT,

        LOBBY__JOINED,

        LOBBY__LEFT,

        ROOMS,

        ROOM,

        ROOM_ADD,

        ROOM_DEL,

        ROOM_UPD,

        ROOM__JOINED,

        ROOM__LEFT,

        CFG,

        TOGGLE_RESTRICT_TEAMS,

        CLIENT_FLAGS,

        CF, // this just an alias and will be mapped to CLIENT_FLAGS

        EM // engine messages

    }

    public final boolean isValid;

    private Type type;

    private String[] args;

/*

    public ProtocolMessage(String messageType)

    {

        args = new String[0];

        try

        {

            type = Type.valueOf(messageType);

            isValid = messageSyntaxIsValid();

        }

        catch (IllegalArgumentException whoops)

        {

            type = Type._UNKNOWN_MESSAGETYPE_;

            args = new String[] { messageType };

            isValid = false;

        }

    }

*/

    private final String[] emptyArgs = new String[0];

    private String[] withoutFirst(final String[] array, final int amount) {

        return Arrays.copyOfRange(array, amount, array.length);

    }

    private final List<String> parts;

    // invalid Message

    public ProtocolMessage() {

        this.parts =  Arrays.asList(emptyArgs);

        this.args = emptyArgs;

        this.isValid = false;

    }

    public ProtocolMessage(final List<String> parts)

    {

        this.parts = parts;

        this.args = emptyArgs;

        final int partc = parts.size();

        if (partc < 1) {

            isValid = false;

            return;

        }

        try {

            type = Type.valueOf(parts.get(0).replaceAll(":", "__"));

        }

        catch (IllegalArgumentException whoops) {

            type = Type._UNKNOWN_MESSAGETYPE_;

        }

        if (type == Type._UNKNOWN_MESSAGETYPE_) {

            args = parts.toArray(args);

            isValid = false;

        }

        else {

            // all parts after command become arguments

            if (partc > 1)

                args = withoutFirst(parts.toArray(args), 1);

            isValid = checkMessage();

        }

    }

    private boolean checkMessage()

    {

        int argc = args.length;

        switch (type)

        {

            // no arguments allowed

            case PING:

            case PONG:

            case TOGGLE_RESTRICT_TEAMS:

                if (argc != 0)

                    return false;

                break;

            // one argument or more

            case EM: // engine messages

            case LOBBY__JOINED: // list of joined players

            case ROOM__JOINED: // list of joined players

                if (argc < 1)

                    return false;

                break;

            // one argument

            case SERVER_MESSAGE:

            case BYE: // disconnect reason

            case ERROR: // error message

            case NICK: // nickname

            case PROTO: // protocol version

            case SERVER_AUTH: // last stage of mutual of authentication

            case ASKPASSWORD: // request for auth with salt

                if (argc != 1)

                    return false;

                break;

            case NOTICE: // argument should be a number

                if (argc != 1)

                    return false;

                try {

                    Integer.parseInt(args[0]);

                } 

                catch (NumberFormatException e) {

                    return false;

                }

                break;

            // two arguments

            case CONNECTED: // server description and version

            case CHAT: // player nick and chat message

            case LOBBY__LEFT: // player nick and leave reason

            case ROOM__LEFT: // player nick and leave reason

                if (argc != 2)

                    return false;

                break;

            case ROOM: // "ADD" (or "UPD" + room name ) + room attrs or "DEL" and room name

                if(argc < 2)

                    return false;

                final String subC = args[0];

                if (subC.equals("ADD")) {

                    if(argc != ROOM_FIELD_COUNT + 1)

                        return false;

                    this.type = Type.ROOM_ADD;

                    this.args = withoutFirst(args, 1);

                }

                else if (subC.equals("UPD")) {

                    if(argc != ROOM_FIELD_COUNT + 2)

                        return false;

                    this.type = Type.ROOM_UPD;

                    this.args = withoutFirst(args, 1);

                }

                else if (subC.equals("DEL") && (argc == 2)) {

                    this.type = Type.ROOM_DEL;

                    this.args = withoutFirst(args, 1);

                }

                else

                    return false;

                break;

            // two arguments or more

            case CFG: // setting name and list of setting parameters

                if (argc < 2)

                    return false;

                break;

            case CLIENT_FLAGS: // string of changed flags and player name(s)

            case CF: // alias of CLIENT_FLAGS

                if (argc < 2)

                    return false;

                if (this.type == Type.CF)

                    this.type = Type.CLIENT_FLAGS;

                break;

            // four arguments

            case INFO: // info about a player, name, ip/id, version, room

                if (argc != 4)

                    return false;

                break;

            // multiple of ROOM_FIELD_COUNT arguments (incl. 0)

            case ROOMS:

                if (argc % ROOM_FIELD_COUNT != 0)

                    return false;

                break;

        }

        return true;

    }

    private void maybeSendPassword() {

    }

    public Type getType()

    {

        return type;

    }

    public String[] getArguments()

    {

        return args;

    }

    public boolean isValid()

    {

        return isValid;

    }

    public static String partsToString(final List<String> parts)

    {

        final Iterator<String> iter = parts.iterator();

        if (!iter.hasNext())

            return "( -EMPTY- )";

        String result = "(\"" + iter.next();

        while (iter.hasNext()) {

            result += "\", \"" + iter.next();

        }

        return result + "\")";

    }

    public String toString() {

        return partsToString(this.parts);

    }

}