// Processed by NMI's Java Code Viewer 4.8.2 © 1997-2000 B. Lemaire
// Website: http://njcv.htmlplanet.com	E-mail: info@njcv.htmlplanet.com
// Copy registered to Evaluation Copy
// Source File Name:   MultiServer.java

import java.awt.*;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;
import java.util.Vector;

class MultiServer extends Thread {

    private ClientHandler clientHandler[];
    private Receptionist receptionist;
    private Frame target;
    private ServerSocket serverSocket;
    private Socket clientSocket;
    private DataOutputStream os;
    private DataInputStream is;
    private int connectionStatus;
    private int loadedWhoseTurn;
    private CheckDictionary dictionary;
    private CheckWords checkWords;
    private boolean gameInProgress;
    private boolean needToCheckNewBoard;

    MultiServer(Frame frame) {
        clientHandler = new ClientHandler[C.MAX_NUM_OF_PLAYERS];
        dictionary = new CheckDictionary();
        checkWords = new CheckWords(target);
        gameInProgress = false;
        needToCheckNewBoard = true;
        target = frame;
        ServerData.clientsCurrentlyConnected = 0;
        for(int i = 0; i < C.MAX_NUM_OF_PLAYERS; i++) {
            ServerData.nicks[i] = null;
            ServerData.connected[i] = false;
            ServerData.needToSendGameData[i] = false;
            ServerData.validPlayer[i] = false;
            ServerData.playersOrder[i] = 0;
        }

    }

    public void run() {
        receptionist = new Receptionist(this);
        receptionist.setPriority(3);
        receptionist.start();
        while(ServerData.amI_Server)  {
            while(!gameInProgress && ServerData.amI_Server) 
                try {
                    Thread.sleep(5L);
                }
                catch(InterruptedException _ex) {
                    closeMultiServer();
                }
            if(!ServerData.amI_Server)
                break;
            if(ServerData.gameWasLoaded) {
                ServerData.gameWasLoaded = false;
                for(int i = 0; i < ServerData.clientsCurrentlyConnected; i++) {
                    for(int l = 0; l < C.MAX_NUM_OF_PLAYERS; l++) {
                        if(!ServerData.validPlayer[l] || !ServerData.loadedNicks[i].equals(ServerData.nicks[l]))
                            continue;
                        ClientHandler clienthandler = clientHandler[i];
                        clientHandler[i] = clientHandler[l];
                        ServerData.nicks[l] = ServerData.nicks[i];
                        ServerData.nicks[i] = ServerData.loadedNicks[i];
                        clientHandler[i].myNumber = i;
                        if(clienthandler == null) {
                            clientHandler[l] = null;
                        } else {
                            clientHandler[l] = clienthandler;
                            clientHandler[l].myNumber = l;
                        }
                        clienthandler = null;
                        break;
                    }

                    sendGameData();
                }

                for(int i1 = 0; i1 < C.MAX_NUM_OF_PLAYERS; i1++)
                    if(clientHandler[i1] == null) {
                        ServerData.validPlayer[i1] = false;
                        ServerData.connected[i1] = false;
                    } else {
                        ServerData.validPlayer[i1] = true;
                        ServerData.connected[i1] = true;
                    }

                ServerData.turnScore = 0;
                for(int j2 = 0; j2 < C.MAX_NUM_OF_PLAYERS; j2++) {
                    ServerData.needToSendTurnData[j2] = false;
                    ServerData.newTurn[j2] = false;
                }

            } else {
                ServerData.whoseTurn = 0;
                randomizePlayers();
                ServerData.turnScore = 0;
                for(int j = 0; j < 15; j++) {
                    for(int j1 = 0; j1 < 15; j1++) {
                        ServerData.newBoardLetters[j][j1] = '\0';
                        ServerData.oldBoardLetters[j][j1] = '\0';
                    }

                }

                for(int k1 = 0; k1 < C.MAX_NUM_OF_PLAYERS; k1++) {
                    if(ServerData.validPlayer[k1]) {
                        clientHandler[k1].nullifyBankLetters();
                        clientHandler[k1].newBankLetters();
                    }
                    ServerData.playerScore[k1] = 0;
                    ServerData.needToSendTurnData[k1] = false;
                    ServerData.newTurn[k1] = false;
                }

            }
            target.handleEvent(new Event(this, 1001, Integer.toString(127)));
            ServerData.multiServerStartedGame = true;
            nullifyTurnData();
            newTurn();
            ServerData.endTurnStatus = 166;
            while(ServerData.amI_Server)  {
                while(ServerData.endTurnStatus == 166 && gameInProgress && ServerData.amI_Server) 
                    try {
                        Thread.sleep(5L);
                    }
                    catch(InterruptedException _ex) {
                        closeMultiServer();
                    }
                if(!ServerData.amI_Server)
                    break;
                if(!gameInProgress) {
                    int k = 0;
                    for(int l1 = 0; l1 < C.MAX_NUM_OF_PLAYERS; l1++)
                        if(ServerData.validPlayer[l1]) {
                            System.out.println("Score normal =  " + ServerData.playerScore[l1]);
                            if(ServerData.playerScore[l1] > k) {
                                System.out.println("Score higher =  " + ServerData.playerScore[l1]);
                                k = ServerData.playerScore[l1];
                                ServerData.winner = l1;
                            }
                        }

                    ServerData.multiServerStartedGame = false;
                    tellHandlersToEndGame();
                    ServerData.winner = -1;
                    break;
                }
                switch(ServerData.endTurnStatus) {
                default:
                    break;

                case 170: 
                    for(boolean flag = false; !flag;) {
                        try {
                            Thread.sleep(5L);
                        }
                        catch(InterruptedException _ex) {
                            closeMultiServer();
                        }
                        flag = true;
                        for(int i2 = 0; i2 < C.MAX_NUM_OF_PLAYERS; i2++)
                            if(ServerData.validPlayer[i2])
                                flag = flag && !ServerData.needToSendGameData[i2];

                    }

                    nullifyTurnData();
                    newTurn();
                    ServerData.endTurnStatus = 166;
                    break;

                case 161: 
                    for(ServerData.needToSendTurnData[ServerData.playersOrder[ServerData.whoseTurn]] = true; ServerData.needToSendTurnData[ServerData.playersOrder[ServerData.whoseTurn]];)
                        try {
                            Thread.sleep(5L);
                        }
                        catch(InterruptedException _ex) {
                            closeMultiServer();
                        }

                    ServerData.endTurnStatus = 166;
                    break;

                case 160: 
                    sendTurnData();
                    nullifyTurnData();
                    newTurn();
                    ServerData.endTurnStatus = 166;
                    break;

                case 163: 
                    sendTurnData();
                    nullifyTurnData();
                    newTurn();
                    ServerData.endTurnStatus = 166;
                    break;

                case 162: 
                    sendTurnData();
                    nullifyTurnData();
                    newTurn();
                    ServerData.endTurnStatus = 166;
                    break;

                case 164: 
                    ServerData.endTurnStatus = checkNewBoard();
                    break;
                }
            }
            target.handleEvent(new Event(this, 1001, Integer.toString(172)));
        }
        closeMultiServer();
    }

    private void randomizePlayers() {
        Random random = new Random();
        float af[] = new float[C.MAX_NUM_OF_PLAYERS];
        for(int i = 0; i < C.MAX_NUM_OF_PLAYERS; i++)
            if(ServerData.validPlayer[i])
                af[i] = random.nextFloat();
            else
                af[i] = 0.0F;

        int j = 0;
        int k = 0;
        float f = 0.0F;
        for(; k < ServerData.clientsCurrentlyConnected; k++) {
            for(int l = 0; l < C.MAX_NUM_OF_PLAYERS; l++)
                if(af[l] > f) {
                    f = af[l];
                    j = l;
                }

            f = 0.0F;
            af[j] = 0.0F;
            ServerData.playersOrder[k] = j;
        }

    }

    public void sendGameData() {
        for(int i = 0; i < C.MAX_NUM_OF_PLAYERS; i++)
            if(ServerData.validPlayer[i])
                ServerData.needToSendGameData[i] = true;

    }

    private void nullifyTurnData() {
        for(int i = 0; i < C.MAX_NUM_OF_PLAYERS; i++) {
            ServerData.needToSendTurnData[i] = false;
            ServerData.newTurn[i] = false;
        }

    }

    private synchronized void tellHandlersToEndGame() {
        boolean flag = false;
        for(int i = 0; i < C.MAX_NUM_OF_PLAYERS; i++)
            if(ServerData.validPlayer[i])
                clientHandler[i].multiServerEndedGame = true;

        for(int j = 0; j < C.MAX_NUM_OF_PLAYERS; j++) {
            boolean flag1 = true;
            if(ServerData.validPlayer[j] && clientHandler[j].multiServerEndedGame)
                flag1 = false;
            if(flag1)
                return;
            try {
                Thread.sleep(5L);
            }
            catch(InterruptedException _ex) {
                closeMultiServer();
            }
        }

    }

    private void sendTurnData() {
        boolean flag = false;
        for(int i = 0; i < C.MAX_NUM_OF_PLAYERS; i++)
            if(ServerData.validPlayer[i])
                ServerData.needToSendTurnData[i] = true;

        while(!flag)  {
            try {
                Thread.sleep(5L);
            }
            catch(InterruptedException _ex) {
                closeMultiServer();
            }
            flag = true;
            for(int j = 0; j < C.MAX_NUM_OF_PLAYERS; j++)
                if(ServerData.validPlayer[j])
                    flag = flag && !ServerData.needToSendTurnData[j];

        }
        ServerData.whoseTurn++;
        if(ServerData.whoseTurn >= ServerData.clientsCurrentlyConnected)
            ServerData.whoseTurn = 0;
    }

    private void nullifyNewLetters() {
        for(int i = 0; i < 15; i++) {
            for(int j = 0; j < 15; j++)
                ServerData.newLetterPresent[i][j] = false;

        }

    }

    private int checkNewBoard() {
        StringBuffer stringbuffer = new StringBuffer();
        boolean flag = true;
        byte byte0 = -1;
        byte byte1 = -1;
        ServerData.turnScore = 0;
        ServerData.words.removeAllElements();
        if(ServerData.newBoardLetters[7][7] == 0) {
            nullifyNewLetters();
            return 161;
        }
        for(int i1 = 0; i1 < 15; i1++) {
            for(int j1 = 0; j1 < 15; j1++)
                if(ServerData.newLetterPresent[i1][j1]) {
                    boolean flag1 = true;
                    if(i1 - 1 > -1 && ServerData.newBoardLetters[i1 - 1][j1] != 0)
                        flag1 = false;
                    if(i1 + 1 < 15 && ServerData.newBoardLetters[i1 + 1][j1] != 0)
                        flag1 = false;
                    if(j1 - 1 > -1 && ServerData.newBoardLetters[i1][j1 - 1] != 0)
                        flag1 = false;
                    if(j1 + 1 < 15 && ServerData.newBoardLetters[i1][j1 + 1] != 0)
                        flag1 = false;
                    if(flag1) {
                        nullifyNewLetters();
                        return 161;
                    }
                }

        }

        for(int k1 = 0; k1 < 15; k1++) {
            for(int l1 = 0; l1 < 15; l1++) {
                StringBuffer stringbuffer1 = new StringBuffer();
                if(ServerData.newLetterPresent[k1][l1]) {
                    int j2 = l1;
                    int i;
                    int k;
                    do {
                        if(j2 == -1) {
                            k = 0;
                            i = k1;
                            break;
                        }
                        if(ServerData.newBoardLetters[k1][j2] == 0) {
                            k = j2 + 1;
                            i = k1;
                            break;
                        }
                        j2--;
                    } while(true);
                    int j3 = k;
                    do {
                        if(j3 == 15) {
                            l1 = 15;
                            break;
                        }
                        if(ServerData.newBoardLetters[k1][j3] == 0) {
                            l1 = j3 + 1;
                            break;
                        }
                        stringbuffer1.append((char)((ServerData.newBoardLetters[k1][j3] - 65) + 97));
                        j3++;
                    } while(true);
                    if(stringbuffer1.length() > 1) {
                        if(!checkWord(stringbuffer1.toString(), i, k, 1)) {
                            nullifyNewLetters();
                            return 161;
                        }
                        ServerData.words.addElement(stringbuffer1.toString());
                    }
                }
            }

        }

        for(int i2 = 0; i2 < 15; i2++) {
            for(int k2 = 0; k2 < 15; k2++)
                if(ServerData.newLetterPresent[k2][i2]) {
                    StringBuffer stringbuffer2 = new StringBuffer();
                    int k3 = k2;
                    int j;
                    int l;
                    do {
                        if(k3 == -1) {
                            j = 0;
                            l = i2;
                            break;
                        }
                        if(ServerData.newBoardLetters[k3][i2] == 0) {
                            j = k3 + 1;
                            l = i2;
                            break;
                        }
                        k3--;
                    } while(true);
                    int j4 = j;
                    do {
                        if(j4 == 15) {
                            k2 = 15;
                            break;
                        }
                        if(ServerData.newBoardLetters[j4][i2] == 0) {
                            k2 = j4 + 1;
                            break;
                        }
                        stringbuffer2.append((char)((ServerData.newBoardLetters[j4][i2] - 65) + 97));
                        j4++;
                    } while(true);
                    if(stringbuffer2.length() > 1) {
                        if(!checkWord(stringbuffer2.toString(), j, l, 2)) {
                            nullifyNewLetters();
                            return 161;
                        }
                        ServerData.words.addElement(stringbuffer2.toString());
                    }
                }

        }

        nullifyNewLetters();
        if(!ServerData.isSpellerUsed) {
            checkWords.show();
            while(!checkWords.checkHasEnded) 
                try {
                    Thread.sleep(5L);
                }
                catch(InterruptedException _ex) {
                    closeMultiServer();
                }
            checkWords.checkHasEnded = false;
            if(checkWords.moveIsLegal) {
                for(int l2 = 0; l2 < 15; l2++) {
                    for(int l3 = 0; l3 < 15; l3++)
                        ServerData.oldBoardLetters[l2][l3] = ServerData.newBoardLetters[l2][l3];

                }

                ServerData.playerScore[ServerData.playersOrder[ServerData.whoseTurn]] += ServerData.turnScore;
                return 160;
            } else {
                return 161;
            }
        }
        for(int i3 = 0; i3 < 15; i3++) {
            for(int i4 = 0; i4 < 15; i4++)
                ServerData.oldBoardLetters[i3][i4] = ServerData.newBoardLetters[i3][i4];

        }

        ServerData.playerScore[ServerData.whoseTurn] += ServerData.turnScore;
        return 160;
    }

    private boolean checkWord(String s, int i, int j, int k) {
        int l = 1;
        int i1 = 0;
        boolean flag = false;
        if(k == 2) {
            if(j == 7 && (i < 7 && s.length() + i > 7 || i == 7))
                flag = true;
            for(int j1 = 0; j1 < s.length() && i + j1 < 15; j1++) {
                if(ServerData.oldBoardLetters[i + j1][j] == 0)
                    continue;
                flag = true;
                break;
            }

            if(i - 1 > -1 && ServerData.oldBoardLetters[i - 1][j] != 0)
                flag = true;
            if(i + s.length() < 15 && ServerData.oldBoardLetters[i + s.length()][j] != 0)
                flag = true;
            for(int j2 = 0; j2 < s.length(); j2++) {
                if(j + 1 < 15 && ServerData.oldBoardLetters[i + j2][j + 1] != 0) {
                    flag = true;
                    break;
                }
                if(j - 1 <= -1 || ServerData.oldBoardLetters[i + j2][j - 1] == 0)
                    continue;
                flag = true;
                break;
            }

        }
        if(k == 1) {
            if(i == 7 && (j < 7 && s.length() + j > 7 || j == 7))
                flag = true;
            for(int k1 = 0; k1 < s.length() && j + k1 < 15; k1++) {
                if(ServerData.oldBoardLetters[i][j + k1] == 0)
                    continue;
                flag = true;
                break;
            }

            if(j - 1 > -1 && ServerData.oldBoardLetters[i][j - 1] != 0)
                flag = true;
            if(j + s.length() < 15 && ServerData.oldBoardLetters[i][j + s.length()] != 0)
                flag = true;
            for(int k2 = 0; k2 < s.length(); k2++) {
                if(i + 1 < 15 && ServerData.oldBoardLetters[i + 1][j + k2] != 0) {
                    flag = true;
                    break;
                }
                if(i - 1 <= -1 || ServerData.oldBoardLetters[i - 1][j + k2] == 0)
                    continue;
                flag = true;
                break;
            }

        }
        if(!flag)
            return false;
        if(ServerData.isSpellerUsed && !dictionary.searchWord(s.toLowerCase()))
            return false;
        if(k == 2) {
            for(int l1 = 0; l1 < s.length(); l1++)
                switch(ServerData.boardSquare[i + l1][j]) {
                case 5: // '\005'
                    i1 += ServerData.letterValues[s.charAt(l1) - 97];
                    l *= 2;
                    break;

                case 6: // '\006'
                    i1 += ServerData.letterValues[s.charAt(l1) - 97];
                    l *= 3;
                    break;

                case 3: // '\003'
                    i1 += ServerData.letterValues[s.charAt(l1) - 97] * 2;
                    break;

                case 4: // '\004'
                    i1 += ServerData.letterValues[s.charAt(l1) - 97] * 3;
                    break;

                default:
                    i1 += ServerData.letterValues[s.charAt(l1) - 97];
                    break;
                }

        }
        if(k == 1) {
            for(int i2 = 0; i2 < s.length(); i2++)
                switch(ServerData.boardSquare[i][j + i2]) {
                case 5: // '\005'
                    i1 += ServerData.letterValues[s.charAt(i2) - 97];
                    l *= 2;
                    break;

                case 6: // '\006'
                    i1 += ServerData.letterValues[s.charAt(i2) - 97];
                    l *= 3;
                    break;

                case 3: // '\003'
                    i1 += ServerData.letterValues[s.charAt(i2) - 97] * 2;
                    break;

                case 4: // '\004'
                    i1 += ServerData.letterValues[s.charAt(i2) - 97] * 3;
                    break;

                default:
                    i1 += ServerData.letterValues[s.charAt(i2) - 97];
                    break;
                }

        }
        i1 *= l;
        ServerData.turnScore += i1;
        return true;
    }

    private void newTurn() {
        for(int i = 0; i < C.MAX_NUM_OF_PLAYERS; i++)
            ServerData.newTurn[i] = true;

    }

    public boolean handleEvent(Event event) {
        if(event.id == 1001) {
            if(event.target instanceof Receptionist) {
                switch(event.x) {
                default:
                    break;

                case 181: 
                    receptionist = null;
                    target.handleEvent(new Event(this, 1001, Integer.toString(151)));
                    ServerData.amI_Server = false;
                    break;

                case 154: 
                    clientHandler[event.y] = ServerData.tempClientHandler;
                    clientHandler[event.y].setPriority(3);
                    ServerData.needToSendGameData[event.y] = true;
                    ServerData.connected[event.y] = true;
                    clientHandler[event.y].start();
                    break;

                case 180: 
                    gameInProgress = true;
                    break;

                case 172: 
                    gameInProgress = false;
                    break;

                case 190: 
                    for(int i = 0; i < C.MAX_NUM_OF_PLAYERS; i++)
                        if(ServerData.validPlayer[i])
                            clientHandler[i].clientToBeKicked = ServerData.clientToBeKicked;

                    try {
                        Thread.sleep(20L);
                    }
                    catch(InterruptedException _ex) {
                        closeMultiServer();
                    }
                    clientHandler[ServerData.clientToBeKicked].needToClose = true;
                    break;
                }
                return true;
            }
            if(event.target instanceof ClientHandler) {
                if(event.x == 153) {
                    ServerData.clientsCurrentlyConnected--;
                    if(ServerData.clientsCurrentlyConnected == 0 && ServerData.multiServerStartedGame)
                        closeMultiServer();
                    int j = Integer.valueOf(event.arg.toString()).intValue();
                    clientHandler[j] = null;
                    if(ServerData.multiServerStartedGame) {
                        int l = C.MAX_NUM_OF_PLAYERS;
                        for(int j1 = 0; j1 < C.MAX_NUM_OF_PLAYERS; j1++) {
                            if(ServerData.playersOrder[j1] != j)
                                continue;
                            l = j1;
                            break;
                        }

                        if(ServerData.playersOrder[ServerData.whoseTurn] == j)
                            ServerData.endTurnStatus = 170;
                        for(int k1 = l; k1 < C.MAX_NUM_OF_PLAYERS - 1; k1++)
                            ServerData.playersOrder[k1] = ServerData.playersOrder[k1 + 1];

                    }
                    for(int i1 = 0; i1 < C.MAX_NUM_OF_PLAYERS; i1++)
                        if(ServerData.validPlayer[i1])
                            clientHandler[i1].clientDisconnected = j;

                }
                if(event.x == 112) {
                    for(int k = 0; k < C.MAX_NUM_OF_PLAYERS; k++)
                        if((k == event.y || k == event.key || event.key == 129) && ServerData.validPlayer[k])
                            clientHandler[k].sendMessage(event.arg.toString());

                }
                if(event.x == 162)
                    ServerData.endTurnStatus = 162;
                if(event.x == 163)
                    ServerData.endTurnStatus = 163;
                if(event.x == 164)
                    ServerData.endTurnStatus = 164;
                if(event.x == 155)
                    sendGameData();
            }
            return true;
        } else {
            return false;
        }
    }

    public synchronized void closeMultiServer() {
        ServerData.amI_Server = false;
        ServerData.multiServerStartedGame = false;
        for(int i = 0; i < C.MAX_NUM_OF_PLAYERS; i++)
            if(ServerData.connected[i])
                clientHandler[i].needToClose = true;

        while(ServerData.clientsCurrentlyConnected != 0) 
            try {
                Thread.sleep(5L);
            }
            catch(InterruptedException _ex) { }
        ChatArea.updateChoiceList();
        stop();
    }
}