package server;

import java.io.IOException;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

import network.SocketWriter;
import network.protocol.Packet;
import network.protocol.PacketVisitor;
import network.protocol.packets.ChatMessagePacket;
import network.protocol.packets.CreateRoomPacket;
import network.protocol.packets.DisconnectPacket;
import network.protocol.packets.JoinRoomPacket;
import network.protocol.packets.LeaveRoomPacket;
import network.protocol.packets.LoginPacket;
import network.protocol.packets.RequestRoomListPacket;
import network.protocol.packets.RoomListPacket;
import network.protocol.packets.SendChatMessagePacket;
import network.protocol.packets.ServerResponsePacket;
import network.protocol.packets.ServerResponsePacket.Response;

public class ServerConnexion implements PacketVisitor {

	private final Server server;
	private final InetSocketAddress clientAddress;
	private final SocketWriter writer;
	private String chatterName;

	public ServerConnexion(Server server, DatagramSocket socket, InetSocketAddress clientAddress) {
		this.clientAddress = clientAddress;
		this.server = server;
		this.writer = new SocketWriter(socket);
	}

	public String getChatterName() {
		return this.chatterName;
	}

	public void sendPacket(Packet packet) {
		try {
			this.writer.sendPacket(packet, clientAddress);
		} catch (IOException e) {
			e.printStackTrace();
			this.server.removeConnexion(this);
		}
	}

	@Override
	public void visitPacket(CreateRoomPacket packet) {
		try {
			server.createRoom(packet.getRoomName(), this);
			sendPacket(new ServerResponsePacket(Response.RoomCreated));
		} catch (SocketException e) {
			sendPacket(new ServerResponsePacket(Response.RoomNotCreated));
		}
	}

	@Override
	public void visitPacket(JoinRoomPacket packet) {
		try {
			server.joinRoom(packet.getRoomName(), this);
			sendPacket(new ServerResponsePacket(Response.RoomJoined));
		} catch (SocketException e) {
			sendPacket(new ServerResponsePacket(Response.RoomNotJoined));
		}
	}

	@Override
	public void visitPacket(LeaveRoomPacket packet) {
		try {
			server.leaveRoom(this);
			sendPacket(new ServerResponsePacket(Response.RoomLeft));
		} catch (SocketException e) {
			sendPacket(new ServerResponsePacket(Response.RoomNotLeft));
		}
	}

	@Override
	public void visitPacket(LoginPacket packet) {
		if (server.hasChatterName(packet.getPseudo())) {
			sendPacket(new ServerResponsePacket(Response.AuthError));
			return;
		}

		this.chatterName = packet.getPseudo();
		sendPacket(new RoomListPacket(server.getRoomNames()));
		System.out.println("[Server] Chatter " + packet.getPseudo() + " connected !");
	}

	@Override
	public void visitPacket(RequestRoomListPacket packet) {
		sendPacket(new RoomListPacket(server.getRoomNames()));
	}

	@Override
	public void visitPacket(SendChatMessagePacket packet) {
		try {
			server.sendToRoom(this, packet);
		} catch (SocketException e) {
			sendPacket(new ServerResponsePacket(Response.MessageNotSent));
		}
	}

	@Override
	public void visitPacket(DisconnectPacket packet) {
		this.onDisconnect();
	}

	private void onDisconnect() {
		this.server.removeConnexion(this);
		System.out.println("[Server] Chatter " + chatterName + " disconnected !");
	}

	@Override
	public void visitPacket(RoomListPacket packet) {
		// I'm never supposed to receive this from the client
		throw new UnsupportedOperationException("Unimplemented method 'visitPacket'");
	}

	@Override
	public void visitPacket(ChatMessagePacket packet) {
		// I'm never supposed to receive this from the client
		throw new UnsupportedOperationException("Unimplemented method 'visitPacket'");
	}

	@Override
	public void visitPacket(ServerResponsePacket packet) {
		// I'm never supposed to receive this from the client
		throw new UnsupportedOperationException("Unimplemented method 'visitPacket'");
	}

}