// Decompiled by Jad v1.5.7f. Copyright 2000 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   serverClient.java

package boggle.server.comms;

import boggle.server.*;
import boggle.settings;
import java.io.PrintStream;
import java.rmi.Naming;

// Referenced classes of package boggle.server.comms:
//            serverInterface

public class serverClient extends Thread
{

    public serverClient()
    {
        busy = true;
        busyAddNew = false;
        busyLogin = false;
        busyLogout = false;
        busyNewGame = false;
        busyJoinGame = false;
        busyScore = false;
        busyBroadcast = false;
        busyInformChange = false;
        setPriority(2);
    }

    public void run()
    {
        do
        {
            do
            {
                busy = false;
                if(busyAddNew)
                {
                    busy = true;
                    for(int i = 0; i < settings.otherServers.length; i++)
                    {
                        if(hostAddNew == settings.otherServers[i])
                            continue;
                        try
                        {
                            serverInterface serverinterface = (serverInterface)Naming.lookup("//" + settings.otherServers[i] + "/ServerServer");
                            serverinterface.addNewPlayer(hostAddNew, newPindex, newPlayer);
                            continue;
                        }
                        catch(Exception _ex)
                        {
                            serverFailure(i);
                        }
                        break;
                    }

                    busyAddNew = false;
                }
                if(busyLogin)
                {
                    busy = true;
                    for(int j = 0; j < settings.otherServers.length; j++)
                    {
                        if(hostLogin == settings.otherServers[j])
                            continue;
                        try
                        {
                            serverInterface serverinterface1 = (serverInterface)Naming.lookup("//" + settings.otherServers[j] + "/ServerServer");
                            serverinterface1.login(hostLogin, loginPnumber, loginLang);
                            continue;
                        }
                        catch(Exception _ex)
                        {
                            serverFailure(j);
                        }
                        break;
                    }

                    busyLogin = false;
                }
                if(busyLogout)
                {
                    busy = true;
                    for(int k = 0; k < settings.otherServers.length; k++)
                    {
                        if(hostLogout == settings.otherServers[k])
                            continue;
                        try
                        {
                            serverInterface serverinterface2 = (serverInterface)Naming.lookup("//" + settings.otherServers[k] + "/ServerServer");
                            serverinterface2.logout(hostLogout, logoutPnumber);
                            continue;
                        }
                        catch(Exception _ex)
                        {
                            serverFailure(k);
                        }
                        break;
                    }

                    busyLogout = false;
                }
                if(busyNewGame)
                {
                    busy = true;
                    for(int l = 0; l < settings.otherServers.length; l++)
                    {
                        if(hostNewGame == settings.otherServers[l])
                            continue;
                        try
                        {
                            serverInterface serverinterface3 = (serverInterface)Naming.lookup("//" + settings.otherServers[l] + "/ServerServer");
                            serverinterface3.newgame(hostNewGame, newGnumber, newGdesc, newGdef, newGlang, newGtype);
                            continue;
                        }
                        catch(Exception _ex)
                        {
                            serverFailure(l);
                        }
                        break;
                    }

                    busyNewGame = false;
                }
                if(busyJoinGame)
                {
                    busy = true;
                    for(int i1 = 0; i1 < settings.otherServers.length; i1++)
                    {
                        if(hostJoinGame == settings.otherServers[i1])
                            continue;
                        try
                        {
                            serverInterface serverinterface4 = (serverInterface)Naming.lookup("//" + settings.otherServers[i1] + "/ServerServer");
                            serverinterface4.joingame(hostJoinGame, joinPnumber, joinGnumber);
                            continue;
                        }
                        catch(Exception _ex)
                        {
                            serverFailure(i1);
                        }
                        break;
                    }

                    busyJoinGame = false;
                }
                if(busyScore)
                {
                    busy = true;
                    for(int j1 = 0; j1 < settings.otherServers.length; j1++)
                    {
                        if(hostScore == settings.otherServers[j1])
                            continue;
                        try
                        {
                            serverInterface serverinterface5 = (serverInterface)Naming.lookup("//" + settings.otherServers[j1] + "/ServerServer");
                            serverinterface5.finalscore(hostScore, scorePnumber, scoreGnumber, scoreScore);
                            continue;
                        }
                        catch(Exception _ex)
                        {
                            serverFailure(j1);
                        }
                        break;
                    }

                    busyScore = false;
                }
                if(busyBroadcast)
                {
                    busy = true;
                    for(int k1 = 0; k1 < settings.otherServers.length; k1++)
                    {
                        if(hostBroadcast == settings.otherServers[k1])
                            continue;
                        try
                        {
                            serverInterface serverinterface6 = (serverInterface)Naming.lookup("//" + settings.otherServers[k1] + "/ServerServer");
                            serverinterface6.broadcast(hostBroadcast, message, bLang);
                            continue;
                        }
                        catch(Exception _ex)
                        {
                            serverFailure(k1);
                        }
                        break;
                    }

                    busyBroadcast = false;
                }
                if(busyInformChange)
                {
                    busy = true;
                    for(int l1 = 0; l1 < settings.otherServers.length; l1++)
                    {
                        if(hostInformChange == settings.otherServers[l1])
                            continue;
                        try
                        {
                            serverInterface serverinterface7 = (serverInterface)Naming.lookup("//" + settings.otherServers[l1] + "/ServerServer");
                            serverinterface7.changeServer(oldServer, newServer);
                            continue;
                        }
                        catch(Exception _ex)
                        {
                            serverFailure(l1);
                        }
                        break;
                    }

                    busyInformChange = false;
                }
            } while(busy);
            try
            {
                Thread.sleep(30000L);
            }
            catch(InterruptedException _ex) { }
        } while(true);
    }

    private void serverFailure(int i)
    {
        if(numOtherServers != settings.otherServers.length)
        {
            numOtherServers = settings.otherServers.length;
            errors = new int[numOtherServers];
            for(int j = 0; j < numOtherServers; j++)
                errors[j] = 0;

        }
        errors[i]++;
        if(errors[i] > 3)
        {
            String s = settings.otherServers[0];
            settings.otherServers[0] = settings.otherServers[i];
            settings.otherServers[i] = s;
            settings.otherServers = (String[])tail(settings.otherServers);
        }
    }

    public synchronized void sync()
    {
        if(!settings.distributedServer())
        {
            System.out.println("Server running in Standalone mode");
            return;
        }
        if(settings.otherServers == null)
        {
            System.out.println("Server running as Master Server");
            return;
        }
        while(settings.otherServers != null) 
            try
            {
                serverInterface serverinterface = (serverInterface)Naming.lookup("//" + settings.otherServers[0] + "/ServerServer");
                if(serverinterface.attach(settings.otherServers[0]))
                {
                    synchronise(serverinterface);
                    String as[] = new String[1];
                    as[0] = settings.otherServers[0];
                    settings.otherServers = as;
                    System.out.println("Synchronising with " + settings.otherServers[0]);
                    return;
                }
                settings.otherServers = serverinterface.getAlternateServers();
            }
            catch(Exception _ex)
            {
                settings.otherServers = (String[])tail(settings.otherServers);
            }
        System.out.println("No Acceptable Master Servers found, running in Standalone mode");
    }

    public void synchronise(serverInterface serverinterface)
        throws Exception
    {
        if(settings.getGameNames().length != serverinterface.getGameNames().length)
            throw new Exception();
        if(settings.getLanguages().length != serverinterface.getLanguages().length)
        {
            throw new Exception();
        } else
        {
            gamePool.setDescriptions(serverinterface.getGameDescriptions());
            gamePool.setDefinitions(serverinterface.getGameDefinitions());
            gamePool.setLanguages(serverinterface.getGameLanguageList());
            gamePool.setTypes(serverinterface.getGameTypeList());
            playerPool.setPlayerList(serverinterface.getPlayerList());
            playerPool.setLoggedInList(serverinterface.getLoggedInList());
            return;
        }
    }

    private Object[] tail(Object aobj[])
    {
        if(aobj.length == 1)
            return null;
        Object aobj1[] = new Object[aobj.length - 1];
        for(int i = 0; i < aobj1.length; i++)
            aobj1[i] = aobj[i + 1];

        return aobj1;
    }

    public synchronized void addNewPlayer(String s, int i, player player)
    {
        if(settings.otherServers == null)
            return;
        while(busyAddNew) 
            Thread.yield();
        hostAddNew = s;
        newPindex = i;
        newPlayer = player;
        busyAddNew = true;
    }

    public synchronized void login(String s, int i, int j)
    {
        if(settings.otherServers == null)
            return;
        while(busyLogin) 
            Thread.yield();
        hostLogin = s;
        loginPnumber = i;
        loginLang = j;
        busyLogin = true;
    }

    public synchronized void logout(String s, int i)
    {
        if(settings.otherServers == null)
            return;
        while(busyLogout) 
            Thread.yield();
        hostLogout = s;
        logoutPnumber = i;
        busyLogout = true;
    }

    public synchronized void newgame(String s, int i, String s1, String s2, int j, int k)
    {
        if(settings.otherServers == null)
            return;
        while(busyNewGame) 
            Thread.yield();
        hostNewGame = s;
        newGnumber = i;
        newGdesc = s1;
        newGdef = s2;
        newGlang = j;
        newGtype = k;
        busyNewGame = true;
    }

    public synchronized void joingame(String s, int i, int j)
    {
        if(settings.otherServers == null)
            return;
        while(busyJoinGame) 
            Thread.yield();
        hostJoinGame = s;
        joinPnumber = i;
        joinGnumber = j;
        busyJoinGame = true;
    }

    public synchronized void finalscore(String s, int i, int j, int k)
    {
        if(settings.otherServers == null)
            return;
        while(busyScore) 
            Thread.yield();
        hostScore = s;
        scorePnumber = i;
        scoreGnumber = j;
        scoreScore = k;
        busyScore = true;
    }

    public synchronized void broadcast(String s, String s1, int i)
    {
        if(settings.otherServers == null)
            return;
        while(busyBroadcast) 
            Thread.yield();
        hostBroadcast = s;
        message = s1;
        bLang = i;
    }

    public synchronized void informChangeServer(String s, String s1, String s2)
    {
        if(settings.otherServers == null)
            return;
        while(busyInformChange) 
            Thread.yield();
        hostInformChange = s;
        oldServer = s1;
        newServer = s2;
        busyInformChange = true;
    }

    private boolean busy;
    private boolean busyAddNew;
    private String hostAddNew;
    private int newPindex;
    private player newPlayer;
    private boolean busyLogin;
    private String hostLogin;
    private int loginPnumber;
    private int loginLang;
    private boolean busyLogout;
    private String hostLogout;
    private int logoutPnumber;
    private boolean busyNewGame;
    private String hostNewGame;
    private int newGnumber;
    private String newGdesc;
    private String newGdef;
    private int newGlang;
    private int newGtype;
    private boolean busyJoinGame;
    private String hostJoinGame;
    private int joinPnumber;
    private int joinGnumber;
    private boolean busyScore;
    private String hostScore;
    private int scorePnumber;
    private int scoreGnumber;
    private int scoreScore;
    private boolean busyBroadcast;
    private String hostBroadcast;
    private String message;
    private int bLang;
    private boolean busyInformChange;
    private String hostInformChange;
    private String oldServer;
    private String newServer;
    private int numOtherServers;
    private int errors[];
}
