import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Vector;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.Logger;



public class SimpleChatServer {

	private static final String HOST = "localhost";
	private static final int PORT = 9999;

	private static FileHandler fileHandler;
	private static Logger logger = Logger.getLogger("net.IOCP");

	private Selector selector = null;
	private ServerSocketChannel serverSocketChannel = null;
	private ServerSocket serverSocket = null;

	private Vector room = new Vector();

	public void initServer() {
		try {
			//select open
			selector = Selector.open();

			//Create ServerSocket Channel
			serverSocketChannel = ServerSocketChannel.open();

			//비 블록킹 모드로 설정한다.
			serverSocketChannel.configureBlocking(false);

			//서버소켓 채널과 연결된 서버소켓을 가져온다.
			serverSocket = serverSocketChannel.socket();


			// 주어진 파라미터에 해당하는 주소다. 포트로 서버소켓을 바인드한다.
			InetSocketAddress isa = new InetSocketAddress(HOST, PORT);
			serverSocket.bind(isa);

			//서버소켓 채널을 셀렉터에 등록한다.
			serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
		} catch (IOException ex) {

			log(Level.WARNING, "SimpleChatServer.initServer()", ex);
		}
	}

	public void startServer() {

		info("Server is Started....");

		try {

			while (true) {

				info("요청을 기다리는중...");

				//셀렉터의 select() 메소드로 준비된 이벤트가 있는지 확인한다.
				selector.select();

				//셀렉터의 SeelctedSet에 저장된 
				//준비된 이벤트들 (SelectionKey들) 을 하나씩 처리한다.

				Iterator it = selector.selectedKeys().iterator();

				while (it.hasNext()) {

					SelectionKey key = (SelectionKey)it.next();

					if (key.isAcceptable()) {
						//서버소켓 채널에 클라이언트가 접속을 시도한 경우.
						accept(key);
					}
					else if (key.isReadable()) {
						//이미 연결된 클라이언트가 메시지를 보낸경우
						read(key);
					}
					it.remove();
				}	//end while(iterator)
			}
		} 
		catch (Exception ex) {
			log(Level.WARNING, "SimpleChatServer.startServer()", ex);
		}
	}

	private void accept(SelectionKey key) {
		ServerSocketChannel server = (ServerSocketChannel)key.channel();
		SocketChannel sc;

		try {

			//서버소켓 채널의 accept() 메소드로 서버소켓을 생성한다.
			sc = server.accept();
			//생성된 소켓채널을 비 블록킹과 읽기 모드로 셀렉터에 등록한다.
			registerChannel(selector, sc, SelectionKey.OP_READ);
			info(sc.toString() + "클라이언트가 접속했습니다.");	
		} 
		catch (ClosedChannelException ex) {
			log(Level.WARNING, "SimpleChatServer.accept()", ex);
		} 
		catch (IOException ex) { 
			log(Level.WARNING, "SimpleChatServer.accept()", ex);
		}
	}

	private void registerChannel(Selector selector, SocketChannel sc, int ops) throws ClosedChannelException, IOException {

		if (sc == null) {
			info("Invalid Connection");
			return ;
		}

		sc.configureBlocking(false);
		sc.register(selector, ops);

		//채팅방에 추가한다.
		addUser(sc);
	}

	private void read(SelectionKey key) {

		//SelectionKey로부터 소켓채널을 얻어온다.
		SocketChannel sc = (SocketChannel)key.channel();
		//ByteBuffer를 생성한다.
		ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

		try {

			//요청한 클라이언트의 소켓채널로부터 데이터를 읽어들인다.
			int read = sc.read(buffer);
			info(read + "byte 를 읽었습니다.");
		}
		catch (IOException ex) {
			try {
				sc.close();
			} catch (IOException e) {}
			
			removeUser(sc);
			info(sc.toString() + " 클라이언트가 접속을 해제했습니다.");
		}
		

		try {
			//클라이언트가 보낸 메시지를 채팅방 안에 모든 사용자에게 브로드캐스트 해준다.
			//메시지 처리구간.. switch  case .. .
			broadcast(buffer);
		} catch (IOException ex) {
			log(Level.WARNING, "SimpleChatServer.broadcast()", ex);
		}
		clearBuffer(buffer);
	}

	private void broadcast(ByteBuffer buffer) throws IOException {

		buffer.flip();

		Iterator iter = room.iterator();

		while (iter.hasNext()) {
			SocketChannel sc = (SocketChannel)iter.next();

			if (sc != null) {
				sc.write(buffer);
				buffer.rewind();
			}
		}
	}

	private void clearBuffer(ByteBuffer buffer) {
		if (buffer != null) {
			buffer.clear();
			buffer = null;
		}
	}

	private void addUser(SocketChannel sc) {
		room.add(sc);
	}

	private void removeUser(SocketChannel sc) { 
		room.remove(sc);
	}

	/**
	 * 로그
	 */

	public void initLog() {
		try {
			fileHandler = new FileHandler("SimpleChatServer.log");
		}
		catch (IOException ex) {
			logger.addHandler(fileHandler);
			logger.setLevel(Level.ALL);
		}
	}

	public void log(Level level, String msg, Throwable error) {

		logger.log(level, msg, error);
	}
	
	public void info(String msg) {
		logger.info(msg);
	}
	
	public static void main(String[] args) {
		
		SimpleChatServer scs = new SimpleChatServer();
		scs.initLog();
		scs.initServer();
		scs.startServer();
	}
}