import java.util.ArrayList;
import java.util.concurrent.Semaphore;
 
class LODServer
{
     ServerBase<ClientHandler> server = null;
 
    /*
    ** Once the given number of players has connected,
    ** the instance of ServerBase<ClientHandler> returns
    ** an array of them.
    */
    ArrayList<ClientHandler> clients = null;
 
    /*
    ** This is the data that encodes the state of the game.
    ** The labyrinth is stored in a 2D array with
    ** numbers corresponding to the contents of each location.
    */
    static final int TREASURE     = 1;
    /* Larger positive numbers are several lots of treasure */
    static final int EMPTY        = 0;
    static final int HEALTH       = -1;
    static final int LANTERN      = -2;
    static final int SWORD        = -3;
    static final int ARMOUR       = -4;
    static final int EXIT         = -5;
    static final int WALL         = -6;
 
    int mapWidth = 5;
    int mapHeight = 5;
    int map[/*mapHeight*/][/*mapWidth*/] =
    {
	{WALL,    WALL,     ARMOUR,  WALL,     WALL    },
	{WALL,    EXIT,     EMPTY,   TREASURE, TREASURE},
	{LANTERN, TREASURE, EMPTY,   HEALTH,   LANTERN },
	{WALL,    SWORD,    EMPTY,   ARMOUR,   TREASURE},
	{WALL,    WALL,     SWORD,   WALL,     WALL    }
    };
 
    boolean gameStarted = false;
    boolean gameFinished = false;
    int goal = 2;           // The amount of treasure to collect
 
    /*
    ** The server has to be able to wait until the end of the player's turn.
    ** It uses a semaphore to do this.
    ** The player acquires the semaphore at the start of the turn
    ** and releases it at the end of the turn.
    ** This allows the server to wait until the end of the player's turn by
    ** simply waiting for the semaphore to be released.
    */
    Semaphore playerTurn = new Semaphore(1);
 
 
    public void setup (int port, int players, String map) {
	// Limit to one player
	if (players > 1) {
	    System.err.println("The current implementation is limited to one player.");
	    players = 1;
	}
 
	// Create the object to handle the incoming connections
	// ( you don't have to understand how this works )
	// If the last arguement is true then all incoming and outgoing messages
	// to the instances of ClientHandler will be logged.
	// Set to false if you don't want this.
	server = new ServerBase<ClientHandler>(ClientHandler.class, players, port, true);
 
 
 
	// Any set up for the game that can be done
	// before the clients connect goes here...
 
	// Map name is currently ignored
	System.err.println("Map loading is not implemented, \"" + map + "\" ignored.");
 
 
 
	// Start accepting incoming connections.
	System.out.print("Waiting for players to connect ... ");
	server.start();
    }
 
    public void play () throws InterruptedException {
 
	// Wait for all of the clients to connect
	clients = server.getConnections();
	System.out.println(" done.");
 
	// Any set up for the game that is specific
	// to the clients goes here.
 
 
	// Give each ClientHandler a reference to this object
	// and thus access to the game data
	for (ClientHandler c : clients) {
	    c.server = this;
	}
 
	// Fix the player's starting location
	clients.get(0).x = 2;
	clients.get(0).y = 2;
 
	// Let each client know the amount of treasure it needs
	for (ClientHandler c : clients) {
	    c.serverGoal(goal);
	}
 
	// Play the game!
	System.out.println("Starting the game.");
	gameStarted = true;
	while (gameFinished == false) {
 
	    // Check that there is at least one player connected
	    if (clients.size() <= 0) {
		System.out.println("Game abandoned");
		break;
	    }
 
	    // Each player takes a turn
	    //for (ClientHandler c : clients) {
	    ClientHandler c = clients.get(0);
 
	    // Start turn
	    System.out.println("Starting the turn of player \"" + c.name + "\"");
	    c.startTurn();     // During this, c will acquire() the playerTurn semaphore
 
	    // Wait for the player to finish their turn
	    // (they will release() the semaphore at the end of their turn)
	    try {
		playerTurn.acquire();
	    } catch (InterruptedException e) {
		// This shouldn't happen in normal operation
		// If it happens, it is because this code
		// has been used in a larger bit of software
		// thus the wrapper can deal with this condition
		throw(e);
	    }
	    System.out.println("End of turn");
 
	    // Check to see if the current player has won
	    // (gameFinished is set to true in ClientHandler.clientEndTurn())
	    if (gameFinished == true) {
 
		System.out.println("Game over, \"" + c.name + "\" is the winner");
 
		// Tell the player they have won
		c.serverMessage("Congratulations " + c.name + " you won!");
		c.serverWin();
 
		// Tell everyone else that they haven't
		for (ClientHandler d : clients) {
 
		    if (d != c) {
			d.serverMessage("Sorry " + d.name + " it looks like " + c.name + " beat you.");
			d.serverLose();
		    }
 
		}
 
	    }
 
	    // Release the semaphore so that the next player can start their turn
	    playerTurn.release();
	    //}
 
 
	}
 
	return;
 
    }
 
    // A simple helper function
    public static void printUsageAndDie(String error) {
	System.err.println(error);
	System.err.println("Usage:");
	System.err.println("\tjava LODServer <port> <players> <map>");
	System.exit(1);
    }
 
    // The main method just handles the command line arguements
    // creates one instance of LODServer and starts it running
    public static void main(String args[])
    {
 
	// Check the command line arguements
	if (args.length != 3) {
	    printUsageAndDie("Incorrect number of command line arguements");
	} else {
	    // Parse the command line arguements
	    int port = Integer.parseInt(args[0]);
 
	    // Only ports 1025 to 65535 are suitable
	    if ((port <= 1024) || (port >= 65536)) {
		printUsageAndDie("Invalid port number");
	    }
 
	    int players = Integer.parseInt(args[1]);
	    if (players < 0) {
		printUsageAndDie("Invalid number of users");
	    }
 
	    // Create a LODServer object to run the game
	    LODServer s = new LODServer();
 
	    // Set it up
	    s.setup(port,players,args[2]);
 
	    // Go!
	    try {
		s.play();
	    } catch (InterruptedException e) {
		// Something has gone wrong - abort
		System.err.println("Caught InterruptedException(?)");
		System.exit(1);
	    }
	}
    }
}