package pad.prac2;

import java.io.IOException;
import java.util.Collection;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Server
{
	private MyServerSocket ss;
	private int roomSize;
	private boolean kill;
	private Connection[] workerPool;
	private int freeWorkers;
	private Lock lock;
	private Condition availableWorkers;
	private ConcurrentHashMap<Connection,String> activeConnections;
	
	public Server(String ip, int port, int rS)
	{
		try
		{
			ss = new MyServerSocket();
			lock = new ReentrantLock();
			activeConnections = new ConcurrentHashMap<Connection,String>();
			roomSize = rS;
			freeWorkers = roomSize;
			kill = false;
			availableWorkers = lock.newCondition();
			workerPool = new Connection[roomSize];
			for(int i = 0; i < roomSize; i++)
			{
				workerPool[i] = new Connection(this);
				workerPool[i].start();
			}
			ss.bind(ip, port);
		}
		catch(IOException ioExc)
		{
			System.out.println("TCP: Error initializating server socket");
		}
	}
	
	public void startServer()
	{
		while(!kill)
		{
			try
			{
				MySocket incoming = ss.accept();
				System.out.println("Accepted connection from " + incoming.getInetAddress());
				startWorker(incoming);
			}
			catch(IOException ioExc)
			{
				if(!kill)
				{
					System.out.println("TCP: Error accepting connection");
					break;
				}
			}
		}
		
	}
	
	public void startWorker(MySocket s)
	{
		lock.lock();
		while(freeWorkers == 0)
		{
			try
			{
				s.sendMsg("CHATFULL");
				synchronized(this)
				{
					availableWorkers.await();
				}
			}
			catch(InterruptedException intExc)
			{
				intExc.printStackTrace();
			}
			catch(IOException ioExc)
			{
				System.out.println("TCP: Error while sending message to client");
			}
		}
		workerPool[roomSize - freeWorkers].setSock(s);
		workerPool[roomSize - freeWorkers].awake();
		workerPool[roomSize - freeWorkers] = null;
		freeWorkers--;
		lock.unlock();
	}
	
	public void finishWorker(Connection c)
	{
		lock.lock();
		removeFromChatroom(c);
		freeWorkers++;
		workerPool[roomSize - freeWorkers] = c;
		availableWorkers.signal();
		lock.unlock();
	}
	
	public void sendTo(Connection orig, String nick, String msg) throws IOException, ChatException
	{
		lock.lock();
		System.out.println("FROM " + getNickname(orig) + " TO " + nick + ": " + msg);
		msg = getNickname(orig) + ": " + msg;
		Set<Connection> conns = activeConnections.keySet();
		Iterator<Connection> it = conns.iterator();
		Connection dest;
		while(it.hasNext())
		{
			dest = it.next();
			if(getNickname(dest).equals(nick))
			{
				dest.sendMessage(msg);
				lock.unlock();
				return;
			}
		}
		lock.unlock();
		throw new ChatException("No such nickname");
	}
	
	public void sendToChat(Connection origin, String message) throws IOException
	{
		lock.lock();
		String nickname = activeConnections.get(origin);
		Set<Connection> connections = activeConnections.keySet();
		Iterator<Connection> it = connections.iterator();
		Connection conn;
		while(it.hasNext())
		{
			conn = it.next();
			if(conn != origin)
			{
				conn.sendMessage(nickname + ": " + message);
			}
		}
		lock.unlock();
	}
	
	public String getNickname(Connection c)
	{
		return activeConnections.get(c);
	}
	
	public void addToChatroom(Connection c, String nickName)
	{
		activeConnections.put(c, nickName);
		System.out.println(nickName + " has entered the room");
	}
	
	private void removeFromChatroom(Connection c)
	{
		activeConnections.remove(c);
	}
	
	public boolean isOnline(String nick)
	{
		return activeConnections.contains(nick);
	}
	
	public String listOnline()
	{
		lock.lock();
		String ret = new Integer(activeConnections.size()).toString();
		ret += " people currently online:";
		Collection<String> nickNames = activeConnections.values();
		Iterator<String> it = nickNames.iterator();
		while(it.hasNext())
		{
			ret += "\n";
			ret += it.next();
		}
		lock.unlock();
		return ret;
	}
	
	public void killServer()
	{
		kill = true;
		ss.close();
		finishConnections();
	}
	
	public void finishConnections()
	{
		Set<Connection> conns = activeConnections.keySet();
		Iterator<Connection> it = conns.iterator();
		while(it.hasNext())
		{
			it.next().finish();
		}
	}
}