package geniusweb.partiesserver.websocket;

import java.io.EOFException;
import java.io.IOException;
import java.net.URI;
import java.util.Date;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.logging.Level;

import javax.websocket.CloseReason;
import javax.websocket.CloseReason.CloseCodes;
import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;

import geniusweb.actions.Action;
import geniusweb.actions.PartyId;
import geniusweb.connection.ConnectionEnd;
import geniusweb.inform.Inform;
import geniusweb.inform.Settings;
import geniusweb.partiesserver.Jackson;
import geniusweb.partiesserver.repository.RunningPartiesRepo;
import geniusweb.partiesserver.repository.RunningParty;
import geniusweb.party.Party;
import geniusweb.references.Reference;
import tudelft.utilities.listener.Listener;
import tudelft.utilities.logging.ReportToLogger;
import tudelft.utilities.logging.Reporter;

/**
 * Returns a websocket that communicates with the {@link RunningParty}. The
 * websocket is initiated/called/requested by an external party, typicall hte
 * protocol running on another server. We close the socket when we detect the
 * party is gone (eg, due to a bug in the party or a time-out). If the socket
 * breaks, we close the party as it becomes isolated.
 */
@ServerEndpoint("/party/{party}")
public class PartySocket implements ConnectionEnd<Inform, Action> {

	private final Reporter log;
	private final RunningPartiesRepo runningparties;
	private final List<Listener<Inform>> listeners = new CopyOnWriteArrayList<Listener<Inform>>();
	private final ActiveThreads threads;

	// should all be final, except that we can only set them when start is
	// called...
	private Session session;

	private PartyId partyID;

	private SendBuffer outstream;
	private Throwable error = null;

	private StringBuffer buffer = new StringBuffer();

	public PartySocket() {
		this(RunningPartiesRepo.instance(),
				new ReportToLogger("partiesserver"));
	}

	public PartySocket(RunningPartiesRepo parties, Reporter reporter) {
		this.runningparties = parties;
		this.log = reporter;
		this.threads = new ActiveThreads(log);
	}

	@OnOpen
	public void start(Session session,
			@PathParam("party") final String partyidname) throws IOException {
		if (partyidname == null) {
			throw new IllegalArgumentException("party can't be null");
		}

		this.session = session;
		this.partyID = new PartyId(partyidname);
		this.outstream = new SendBuffer(session.getBasicRemote(), log);

		// listen to parties repo, so that we can act if party is terminated
		runningparties.addListener(new Listener<PartyId>() {
			@Override
			public void notifyChange(PartyId data) {
				if (runningparties.get(partyID) == null) {
					// party was removed, probably due to time out.
					try {
						log.log(Level.INFO,
								"Party " + partyID + " was terminated ");
						runningparties.removeListener(this);
						session.close(new CloseReason(CloseCodes.GOING_AWAY,
								"detected that party vanished"));
					} catch (IOException e) {
						log.log(Level.WARNING,
								"failed to close the socket for " + partyID, e);
					}
				}
			}
		});
		RunningParty runningparty = runningparties.get(partyID);

		if (runningparty == null) {
			session.close(new CloseReason(CloseReason.CloseCodes.CANNOT_ACCEPT,
					"No such party: " + partyID));
		} else {
			runningparties.replace(runningparty.withConnection(this));
		}

		// we do not listen for changes on the Parties factory as we can't
		// replace the running party anyway
	}

	/**
	 * Called when a message comes in on the server socket that needs to be
	 * passed into the {@link Party}. We also sniff the message for termination
	 * indicators.
	 * 
	 * @param informmessage the incoming string, supposedly a JSON-fornatted
	 *                      {@link Inform}
	 * @param last          true if this is the last part of the incoming
	 *                      message. We queue these manually here, to avoid
	 *                      pre-allocating a fixed, very large memory block.
	 * @param session       the session. We already have this info.
	 * @throws IOException if there is a socket/connection error, we can't parse
	 *                     the received data, etc
	 */
	@OnMessage
	public void onMessage(String informpart, boolean islast, Session session)
			throws IOException {
		if (this.session != session) {
			throw new IllegalStateException("Unexpected change of session ID");
		}
		if (!threads.isEmpty()) {
			log.log(Level.WARNING, "Party " + partyID
					+ " is still busy with previous message");
		}
		buffer.append(informpart);
		if (!islast)
			return;

		String informmessage = buffer.toString();
		buffer = new StringBuffer();

		// if we get here, full message is now in

		Inform info = Jackson.instance().readValue(informmessage, Inform.class);
		RunningParty party = runningparties.get(partyID);
		if (party != null) {
			// first sniff, to ensure the deadlines are updated first.
			sniff(info, party);
			log.log(Level.FINE, "Inform " + partyID + ": " + info);
			try {
				threads.add();
				party.inform(info);
				threads.remove();
			} catch (Throwable e) {
				threads.remove();
				if (e instanceof ThreadDeath)
					/*
					 * ThreadDeath always prints stacktrace anwyay, stacktrace
					 * is useless because it contains the thrower's stacktrace
					 * instead of a useful message.
					 */
					log.log(Level.WARNING,
							"Party was killed while handling inform.");
				else
					log.log(Level.WARNING, "Party failed on inform.", e);
				/*
				 * severe as someone wants to debug that. Not severe for us we
				 * don't use jackson.writeValueAsString(e) here because
				 * CloseReason has 123 char limit. The error will be too large
				 * to fit and will be truncated therefore we send a plain string
				 * and hope that enough will arrive at the other side (the
				 * protocol)
				 */
				session.close(new CloseReason(
						CloseReason.CloseCodes.CLOSED_ABNORMALLY,
						"party threw exception: " + collectReasons(e)));
			}
		} // else party is dead but that's handled in the listener above
	}

	/**
	 * 
	 * @param e an exception
	 * @return collect all reasons and sub-reasons
	 */
	private String collectReasons(Throwable e) {
		String reason = "";
		do {
			reason = reason + " : " + e.getClass().getSimpleName() + ":"
					+ e.getMessage();
			e = e.getCause();
		} while (e != null);
		return reason;
	}

	/**
	 * Sniffs the Inform for termination-related information
	 * 
	 * @param info
	 * @param party the party we're handling
	 * @throws IOException
	 */
	private void sniff(Inform info, RunningParty party) throws IOException {
		// do NOT sniff Finished messages and close sockets. Parties and their
		// sockets need to stay running till all messages are handled
		if (info instanceof Settings) {
			Date end = ((Settings) info).getProgress().getTerminationTime();
			runningparties.replace(party.withEndTime(end));
		}
	}

	@OnClose
	public void onClose() throws IOException {
		log.log(Level.INFO, "socket closed to " + partyID);
		if (!threads.isEmpty()) {
			log.log(Level.WARNING, "Party " + partyID
					+ " failed to terminate. Trying to kill the remaining threads.");
			threads.killall();
		}
		runningparties.remove(partyID);
		outstream.stop();
	}

	@OnError
	public void onError(Throwable t) throws Throwable {
		if (t instanceof EOFException) {
			// This is a standard exception from Apache when a socket closes.
			// Just ignore it...
			log.log(Level.FINEST,
					"apache reported EOF from (probably closed) socket, ignoring");
			return;
		}
		log.log(Level.WARNING, "Unhandled exception was reported by Tomcat", t);
	}

	@Override
	public void send(Action action) throws IOException {
		if (action == null) {
			log.log(Level.INFO, "null action received. Closing websocket");
			// signals that party closed the stream
			close();
			return;
		}
		log.log(Level.FINE, "Action " + partyID + ": " + action);
		outstream.send(Jackson.instance().writeValueAsString(action));
	}

	@Override
	public Reference getReference() {
		return null;
	}

	@Override
	public URI getRemoteURI() {
		// In serverendpoints we apparently can't see who was contacting us.
		throw new UnsupportedOperationException();
	}

	@Override
	public void close() {
		try {
			session.close();
		} catch (IOException e) {
			log.log(Level.SEVERE, "failed to close " + partyID, e);
		}
	}

	@Override
	public Throwable getError() {
		return error;
	}

	@Override
	public void addListener(Listener<Inform> l) {
		listeners.add(l);
	}

	@Override
	public void removeListener(Listener<Inform> l) {
		listeners.remove(l);
	}

	/**
	 * This should only be called by the owner of the listenable, not by
	 * listeners or others. Avoid calling this from synchronized blocks as a
	 * notified listener might immediately make more calls to you.
	 * <p>
	 * Any listeners that throw an exception will be intercepted and their
	 * stacktrace is printed.
	 * 
	 * @param data information about the change.
	 */
	public void notifyListeners(Inform data) {
		for (Listener<Inform> l : listeners) {
			l.notifyChange(data);
		}
	}

}